module testing

import os
import time
import term
import strings
import runtime

pub const empty = term.header(' ', ' ')

// TODO: AGAIN --- this !!!*reliably*!!! fails compilation of `v cmd/tools/vbuild-examples.v` with a cgen error, without `-no-parallel`:
// pub const report_running_period_ms = os.getenv_opt('VTEST_REPORT_RUNNING_PERIOD_MS') or { '60000' }.int() * time.millisecond

pub const report_running_period_ms = get_report_running_period_ms()

fn get_report_running_period_ms() time.Duration {
	return os.getenv_opt('VTEST_REPORT_RUNNING_PERIOD_MS') or { '300_000' }.int() * time.millisecond // 5 minutes by default
}

// NormalReporter implements the interface testing.Reporter.
// It is used by default by `v test .`
// It was extracted by the original non customiseable output implementation directly in cmd/tools/modules/testing/common.v
pub struct NormalReporter {
mut:
	vroot    string
	runtime  time.Duration
	comptime time.Duration
	nfiles   int
	njobs    int
	//
	running   shared map[string]LogMessage
	compiling shared map[string]LogMessage
	rtimes    shared []TaskDuration
	ctimes    shared []TaskDuration
}

pub fn (mut r NormalReporter) session_start(message string, mut ts TestSession) {
	r.vroot = ts.vroot.replace('\\', '/') + '/'
	header(message)
	r.nfiles = ts.files.len
	r.njobs = runtime.nr_jobs()
	spawn r.report_current_running_and_compiling_status_periodically()
}

fn (r &NormalReporter) report_current_running_and_compiling_status_periodically() {
	if report_running_period_ms == 0 {
		return
	}
	mut start_t := time.now()
	mut pi := 0
	mut ccompiling := map[string]LogMessage{}
	mut crunning := map[string]LogMessage{}
	mut sb := strings.new_builder(1024)
	for {
		pi++
		time.sleep(report_running_period_ms)
		t := time.now()
		rlock r.compiling {
			ccompiling = r.compiling.clone()
		}
		rlock r.running {
			crunning = r.running.clone()
		}
		ckeys := ccompiling.keys()
		rkeys := crunning.keys()
		sb.writeln('')
		sb.writeln('       >>>>> ${t.format_ss_micro()} | period ${pi:2} | started: ${t - start_t:10} ago | vjobs: ${r.njobs} | _test.v files: ${r.nfiles:5} | C: ${ckeys.len:3} | R: ${rkeys.len:3}')
		for ik, k in ckeys {
			cval := ccompiling[k]
			sb.writeln('       >>>>> compiling ${ik + 1:2}/${ckeys.len:-2}, T: ${cval.flow_id:2}, started: ${t - cval.when:10} ago, `${k}`')
		}
		for ik, k in rkeys {
			cval := crunning[k]
			sb.writeln('       >>>>>   running ${ik + 1:2}/${rkeys.len:-2}, T: ${cval.flow_id:2}, started: ${t - cval.when:10} ago, `${k}`')
		}
		sb.writeln('')
		eprint(sb.str()) // write everything at once, to minimise the chance of interference with the normal output of `v test`
	}
}

fn (r &NormalReporter) show_longest(label string, limit int, kind TaskKind) {
	if limit <= 0 {
		return
	}
	println('> Longest ${limit} by ${label}:')
	mut tasks := []TaskDuration{cap: r.nfiles}
	match kind {
		.comptime {
			rlock r.ctimes {
				tasks << r.ctimes
			}
		}
		.runtime {
			rlock r.rtimes {
				tasks << r.rtimes
			}
		}
		.totaltime {
			mut tall := []TaskDuration{}
			rlock r.rtimes {
				tall << r.rtimes
			}
			rlock r.ctimes {
				tall << r.ctimes
			}
			mut mall := map[string]TaskDuration{}
			for task in tall {
				if current := mall[task.path] {
					mall[task.path].duration = current.duration + task.duration
					continue
				}
				mall[task.path] = task
			}
			tasks = mall.values()
		}
	}

	tasks.sort(a.duration > b.duration)
	for tidx, task in tasks {
		npath := task.path.replace('\\', '/').replace(r.vroot, '')
		println('  ${tidx + 1:3} | ${task.duration:10s} | ${npath}')
		if tidx + 1 >= limit {
			break
		}
	}
}

pub fn (r &NormalReporter) session_stop(message string, mut ts TestSession) {
	r.show_longest('compilation time', show_longest_by_comptime, .comptime)
	r.show_longest('run time', show_longest_by_runtime, .runtime)
	r.show_longest('total time', show_longest_by_totaltime, .totaltime)
	println('${ts.benchmark.total_message(message)} Comptime: ${r.comptime.microseconds() / 1000} ms. Runtime: ${r.runtime.microseconds() / 1000} ms.')
}

// the most general form; it may be useful for other reporters
// in the normal one, it currently does nothing
pub fn (mut r NormalReporter) report(index int, message LogMessage) {
	// eprintln('> ${@METHOD} index: ${index} | message: ${message}')
	if message.kind == .compile_begin {
		lock r.compiling {
			r.compiling[message.file] = message
		}
	}
	if message.kind == .compile_end {
		r.comptime += message.took
		lock r.ctimes {
			r.ctimes << TaskDuration{message.file, message.took}
		}
		lock r.compiling {
			r.compiling.delete(message.file)
		}
	}
	if message.kind == .cmd_end {
		lock r.rtimes {
			r.rtimes << TaskDuration{message.file, message.took}
		}
		r.runtime += message.took
	}
	if message.kind == .cmd_begin {
		lock r.running {
			r.running[message.file] = message
		}
	}
	if message.kind == .cmd_end {
		lock r.running {
			r.running.delete(message.file)
		}
	}
}

pub fn (r NormalReporter) report_stop() {
	// eprintln('> ${@METHOD}')
	eprintln('')
}

// progress will show the given message normally
// TODO: reconsider if these should be public:
pub fn (r NormalReporter) progress(index int, message string) {
	eprintln(message)
}

// in progress mode, the last line will be rewritten many times, and does not end with \n
// the \n will be printed just once when some progress has been made.
pub fn (r NormalReporter) update_last_line(index int, message string) {
	print('\r${empty}\r${message}')
	flush_stdout()
}

pub fn (r NormalReporter) update_last_line_and_move_to_next(index int, message string) {
	// the last \n is needed, so SKIP/FAIL messages
	// will not get overwritten by the OK ones
	eprint('\r${empty}\r${message}\n')
}

pub fn (r NormalReporter) message(index int, message string) {
	eprintln(message)
}

pub fn (r NormalReporter) divider() {
	h_divider()
}

//

pub fn (r NormalReporter) worker_threads_start(files []string, mut ts TestSession) {
	// eprintln('> ${@METHOD}')
}

pub fn (r NormalReporter) worker_threads_finish(mut ts TestSession) {
	// eprintln('> ${@METHOD}')
}

pub fn (r NormalReporter) list_of_failed_commands(failed_cmds []string) {
	for i, cmd in failed_cmds {
		eprintln(term.failed('To reproduce just failure ${i + 1} run:') + '    ${cmd}')
	}
	if failed_cmds.len > 0 {
		vflags := os.getenv('VFLAGS')
		if vflags != '' {
			eprintln(term.failed('VFLAGS was: "${vflags}"'))
		}
	}
}

enum TaskKind {
	comptime
	runtime
	totaltime
}

struct TaskDuration {
mut:
	path     string
	duration time.Duration
}