module main

import time
import term

// Provide a Teamcity implementation of the TestRunner interface.
// Used in Teamcity and JetBrains IDEs for nice test reporting.

fn vtest_init() {
    change_test_runner(&TestRunner(TeamcityTestRunner{}))
}

struct TeamcityTestRunner {
mut:
    fname      string
    start_time time.Time

    file_test_info   VTestFileMetaInfo
    fn_test_info     VTestFnMetaInfo
    fn_assert_passes u64
    fn_passes        u64
    fn_fails         u64

    assertion_info      VAssertMetaInfo
    total_assert_passes u64
    total_assert_fails  u64
}

fn (mut runner TeamcityTestRunner) free() {
    unsafe {
        runner.fname.free()
        runner.fn_test_info.free()
        runner.file_test_info.free()
    }
}

fn normalise_fname(name string) string {
    return name.replace('__', '.').replace('main.', '')
}

fn (mut runner TeamcityTestRunner) start(ntests int) {
}

fn (mut runner TeamcityTestRunner) finish() {
}

fn (mut runner TeamcityTestRunner) exit_code() int {
    if runner.fn_fails > 0 {
        return 1
    }
    if runner.total_assert_fails > 0 {
        return 1
    }
    return 0
}

//

fn (mut runner TeamcityTestRunner) fn_start() bool {
    runner.fn_assert_passes = 0
    runner.start_time = time.now()
    runner.fname = normalise_fname(runner.fn_test_info.name)

    msg := "Start '${runner.fname}' test"
    println(term.gray(msg))

    runner.print_service("
        |##teamcity[testStarted
        |name='${runner.fname}'
        |locationHint='v_qn://${runner.file_test_info.file}:${runner.fname}'
        |]".strip_margin())
    return true
}

fn (mut runner TeamcityTestRunner) fn_pass() {
    runner.fn_passes++
    duration := runner.test_duration()
    eprintln("##teamcity[testFinished name='${runner.fname}' duration='${duration}']")
    end_msg := "Finish '${runner.fname}' test"
    println(term.gray(end_msg))
    msg := "Test '${runner.fname}' passed"
    println(term.green(msg))
    println('\n')
}

fn (mut runner TeamcityTestRunner) fn_fail() {
    runner.fn_fails++
    duration := runner.test_duration()
    assertion := runner.assertion_info

    mut actual := runner.prepare_value(assertion.lvalue)
    mut expected := runner.prepare_value(assertion.rvalue)

    message := if assertion.has_msg {
        'Assertion "${assertion.message}" failed'
    } else {
        op := if assertion.op == '' { '' } else { assertion.op }

        if op == 'in' {
            parts := assertion.src.split('in')
            if parts.len == 2 {
                left := parts[0].trim(' ')
                right := parts[1].trim(' ')
                'Assertion that "${left}" in "${right}" failed'
            } else {
                'Assertion "${assertion.src}" failed'
            }
        } else if op == 'is' {
            'Assertion that left and right type are equal failed'
        } else if op == 'call' {
            actual = 'false'
            expected = 'true'
            'Assertion that function call "${assertion.src}" returns true failed'
        } else {
            lines := assertion.src.split_into_lines()
            if lines.len == 1 {
                'Assertion "${lines.first()}" failed'
            } else {
                'Assertion failed'
            }
        }
    }

    details := 'See failed assertion: ${assertion.fpath}:${assertion.line_nr + 1}'

    runner.print_service("
         |##teamcity[testFailed
         |name='${runner.fname}'
         |duration='${duration}'
         |details='${details}'
         |type='comparisonFailure'
         |actual='${actual}'
         |expected='${expected}'
         |message='${runner.prepare_value(message)}'
         |]".strip_margin())
    println('\n')
}

// prepare_value escapes the value for Teamcity output.
// For example, it replaces `\n` with `|n`, otherwise Teamcity
// will not correctly parse the output.
fn (mut _ TeamcityTestRunner) prepare_value(raw string) string {
    return raw
        .replace('\n', '|n')
        .replace('\r', '|r')
        .replace('[', '|[')
        .replace(']', '|]')
        .replace("'", "|'")
}

fn (mut runner TeamcityTestRunner) fn_error(line_nr int, file string, mod string, fn_name string, errmsg string) {
    eprintln('>>> TeamcityTestRunner fn_error ${runner.fname}, line_nr: ${line_nr}, file: ${file}, mod: ${mod}, fn_name: ${fn_name}, errmsg: ${errmsg}')
}

fn (mut runner TeamcityTestRunner) test_duration() i64 {
    return time.now().unix_milli() - runner.start_time.unix_milli()
}

// print_service prepare and prints a Teamcity service message.
fn (mut runner TeamcityTestRunner) print_service(msg string) {
    without_new_lines := msg
        .trim('\n\r ')
        .replace('\r', '')
        .replace('\n]', ']')
        .replace('\n', ' ')
    eprintln(without_new_lines)
}

//

fn (mut runner TeamcityTestRunner) assert_pass(i &VAssertMetaInfo) {
    runner.total_assert_passes++
    runner.fn_assert_passes++

    filepath := i.fpath.clone()
    msg := '>>> assertion passed ${filepath}:${i.line_nr + 1}'
    println(term.green(msg))

    unsafe { i.free() }
}

fn (mut runner TeamcityTestRunner) assert_fail(i &VAssertMetaInfo) {
    runner.total_assert_fails++
    runner.assertion_info = *i
}