// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
@[has_globals]
module util

import time

__global g_timers = new_timers(should_print: false, label: 'g_timers')

@[heap]
pub struct Timers {
    label string
pub mut:
    swatches     shared map[string]time.StopWatch
    should_print bool
    // already_shown records for which of the swatches .show() or .show_if_exists() had been called already
    already_shown []string
}

@[params]
pub struct TimerParams {
pub:
    should_print bool
    label        string
}

pub fn new_timers(params TimerParams) &Timers {
    $if trace_timers_creation ? {
        eprintln('>>>> new_timers, should_print: ${params.should_print} | label: ${params.label}')
    }
    return &Timers{
        label:         params.label
        swatches:      map[string]time.StopWatch{}
        should_print:  params.should_print
        already_shown: []string{cap: 100}
    }
}

pub fn get_timers() &Timers {
    return g_timers
}

pub fn timing_start(label string) {
    if !g_timers.should_print {
        return
    }
    mut t := get_timers()
    t.start(label)
}

pub fn timing_measure(label string) {
    if !g_timers.should_print {
        return
    }
    g_timers.show(label)
}

pub fn timing_measure_cumulative(label string) {
    if !g_timers.should_print {
        return
    }
    g_timers.measure_cumulative(label)
}

pub fn timing_set_should_print(should_print bool) {
    g_timers.should_print = should_print
}

pub fn (mut t Timers) start(name string) {
    if !t.should_print {
        return
    }
    mut sw := t.tsafe_get_sw(name) or { time.new_stopwatch() }
    sw.start()
    t.tsafe_set_sw(name, sw)
}

pub fn (mut t Timers) measure(name string) i64 {
    if !t.should_print {
        return 0
    }
    mut sw := t.tsafe_get_sw(name) or {
        timer_keys := t.tsafe_get_keys()
        eprintln('> Timer `${name}` was NOT started.')
        eprintln('>   Available timers:')
        eprintln('>   ${timer_keys}')
        time.new_stopwatch()
    }
    ms := sw.elapsed().microseconds()
    sw.pause()
    t.tsafe_set_sw(name, sw)
    return ms
}

pub fn (mut t Timers) measure_cumulative(name string) i64 {
    if !t.should_print {
        return 0
    }
    ms := t.measure(name)
    mut sw := t.tsafe_get_sw(name) or { return ms }
    sw.pause()
    t.tsafe_set_sw(name, sw)
    return ms
}

pub fn (mut t Timers) measure_pause(name string) {
    if !t.should_print {
        return
    }
    mut sw := t.tsafe_get_sw(name) or { return }
    sw.pause()
    t.tsafe_set_sw(name, sw)
}

pub fn (mut t Timers) measure_resume(name string) {
    if !t.should_print {
        return
    }
    mut sw := t.tsafe_get_sw(name) or { return }
    sw.start()
    t.tsafe_set_sw(name, sw)
}

pub fn (mut t Timers) message(name string) string {
    ms := f64(t.measure(name)) / 1000.0
    value := bold('${ms:-8.3f}')
    formatted_message := '${value} ms ${name}'
    return formatted_message
}

pub fn (mut t Timers) show(label string) {
    if v_memory_panic {
        // Showing timers uses string interpolation, and allocating in this case
        // will just cause a second panic to be shown; it is better to just not show anything
        return
    }
    if t.should_print {
        formatted_message := t.message(label)
        println(formatted_message)
    }
    t.already_shown << label
}

pub fn (mut t Timers) show_if_exists(label string) {
    if !t.should_print {
        return
    }
    t.tsafe_get_sw(label) or { return }
    t.show(label)
    t.already_shown << label
}

pub fn (mut t Timers) show_remaining() {
    if !t.should_print {
        return
    }
    keys := t.tsafe_get_keys()
    for k in keys {
        if k in t.already_shown {
            continue
        }
        t.show(k)
    }
}

pub fn (mut t Timers) dump_all() {
    if !t.should_print {
        return
    }
    keys := t.tsafe_get_keys()
    for k in keys {
        elapsed := t.message(k)
        println(elapsed)
    }
}

//

fn (mut t Timers) tsafe_get_keys() []string {
    keys := rlock t.swatches {
        t.swatches.keys()
    }
    return keys
}

fn (mut t Timers) tsafe_set_sw(name string, sw time.StopWatch) {
    lock t.swatches {
        t.swatches[name] = sw
    }
}

fn (mut t Timers) tsafe_get_sw(name string) ?time.StopWatch {
    rlock t.swatches {
        if name !in t.swatches {
            return none
        }
        return t.swatches[name]
    }
    return none
}