// 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.
module checker

import time
import v.ast
import v.token
import v.errors
import v.util

// call this *before* calling error or warn
fn (mut c Checker) add_error_detail(s string) {
    c.error_details << s
}

fn (mut c Checker) add_error_detail_with_pos(msg string, pos token.Pos) {
    file_path := if pos.file_idx < 0 { c.file.path } else { c.table.filelist[pos.file_idx] }
    c.add_error_detail(util.formatted_error('details:', msg, file_path, pos))
}

fn (mut c Checker) add_instruction_for_option_type() {
    c.add_error_detail_with_pos('prepend ? before the declaration of the return type of `${c.table.cur_fn.name}`',
        c.table.cur_fn.return_type_pos)
}

fn (mut c Checker) add_instruction_for_result_type() {
    c.add_error_detail_with_pos('prepend ! before the declaration of the return type of `${c.table.cur_fn.name}`',
        c.table.cur_fn.return_type_pos)
}

@[params]
pub struct MessageOptions {
pub:
    call_stack []errors.CallStackItem
}

fn (mut c Checker) warn(s string, pos token.Pos, options MessageOptions) {
    allow_warnings := !(c.pref.is_prod || c.pref.warns_are_errors) // allow warnings only in dev builds
    c.warn_or_error(s, pos, allow_warnings, options)
}

fn (mut c Checker) warn_alloc(s string, pos token.Pos) {
    if c.assign_stmt_attr == 'freed' {
        return
    }

    if !c.is_builtin_mod && c.mod !in ['strings', 'math', 'math.bits', 'builtin', 'strconv'] {
        c.warn('allocation (${s})', pos)
    }
}

fn (mut c Checker) error(message string, pos token.Pos, options MessageOptions) {
    if (c.pref.translated || c.file.is_translated) && message.starts_with('mismatched types') {
        // TODO: move this
        return
    }
    mut msg := message.replace('`Array_', '`[]')
    if c.pref.is_template { // set during veb template checking
        // Show in which veb action the error occurred (for easier debugging)
        veb_action := c.table.cur_fn.name.replace('veb_tmpl_', '')
        mut j := 0
        for _, ch in veb_action {
            if ch.is_digit() {
                break
            }
            j++
        }
        msg += ' (veb action: ${veb_action[..j]})'
    }
    c.warn_or_error(msg, pos, false, options)
}

fn (mut c Checker) fatal(message string, pos token.Pos, options MessageOptions) {
    if (c.pref.translated || c.file.is_translated) && message.starts_with('mismatched types') {
        // TODO: move this
        return
    }
    msg := message.replace('`Array_', '`[]')
    c.pref.fatal_errors = true
    c.warn_or_error(msg, pos, false, options)
}

fn (mut c Checker) note(message string, pos token.Pos) {
    if c.is_generated {
        return
    }
    if c.pref.notes_are_errors {
        c.error(message, pos)
    }
    mut details := ''
    if c.error_details.len > 0 {
        details = c.error_details.join('\n')
        c.error_details = []
    }
    // deduplicate notices for the same line
    file_path := if pos.file_idx < 0 { c.file.path } else { c.table.filelist[pos.file_idx] }
    kpos := '${file_path}:${pos.line_nr}:${message}'
    if kpos !in c.notice_lines {
        c.notice_lines[kpos] = true
        c.nr_notices++
        if c.pref.message_limit >= 0 && c.notices.len >= c.pref.message_limit {
            return
        }
        note := errors.Notice{
            reporter:  errors.Reporter.checker
            pos:       pos
            file_path: file_path
            message:   message
            details:   details
        }
        c.file.notices << note
        c.notices << note
    }
}

fn (mut c Checker) warn_or_error(message string, pos token.Pos, warn bool, options MessageOptions) {
    if !warn {
        $if checker_exit_on_first_error ? {
            eprintln('\n\n>> checker error: ${message}, pos: ${pos}')
            print_backtrace()
            exit(1)
        }
        if c.pref.is_verbose {
            print_backtrace()
        }
    }
    mut details := ''
    if c.error_details.len > 0 {
        details = c.error_details.join('\n')
        c.error_details = []
    }
    file_path := if pos.file_idx < 0 { c.file.path } else { c.table.filelist[pos.file_idx] }
    if warn && !c.pref.skip_warnings {
        c.nr_warnings++
        if c.pref.message_limit >= 0 && c.warnings.len >= c.pref.message_limit {
            return
        }
        // deduplicate warnings for the same line
        kpos := '${file_path}:${pos.line_nr}:${message}'
        if kpos !in c.warning_lines {
            c.warning_lines[kpos] = true
            wrn := errors.Warning{
                reporter:  errors.Reporter.checker
                pos:       pos
                file_path: file_path
                message:   message
                details:   details
            }
            c.file.warnings << wrn
            c.warnings << wrn
        }
        return
    }
    if !warn {
        // Use provided call_stack or fall back to file.call_stack
        actual_call_stack := if options.call_stack.len > 0 {
            options.call_stack
        } else {
            c.file.call_stack
        }
        if c.pref.fatal_errors {
            util.show_compiler_message('error:', errors.CompilerMessage{
                pos:        pos
                file_path:  file_path
                message:    message
                details:    details
                call_stack: actual_call_stack
            })
            exit(1)
        }
        c.nr_errors++
        if c.pref.message_limit >= 0 && c.errors.len >= c.pref.message_limit {
            c.should_abort = true
            return
        }
        // deduplicate errors for the same line
        kpos := '${file_path}:${pos.line_nr}:${message}'
        if kpos !in c.error_lines {
            c.error_lines[kpos] = true
            err := errors.Error{
                reporter:   errors.Reporter.checker
                pos:        pos
                file_path:  file_path
                message:    message
                details:    details
                call_stack: actual_call_stack
            }
            c.file.errors << err
            c.errors << err
        }
    }
}

// for debugging only
fn (c &Checker) fileis(s string) bool {
    return c.file.path.contains(s)
}

fn (mut c Checker) trace[T](fbase string, x &T) {
    if c.file.path_base == fbase {
        println('> c.trace | ${fbase:-10s} | ${x}')
    }
}

fn (mut c Checker) deprecate(kind string, name string, attrs []ast.Attr, pos token.Pos) {
    // println('deprecate kind=${kind} name=${name} attrs=${attrs}')
    // print_backtrace()
    mut deprecation_message := ''
    now := time.now()
    mut after_time := now
    for attr in attrs {
        if attr.arg == '' {
            continue
        }
        if attr.name == 'deprecated' {
            deprecation_message = attr.arg
        } else if attr.name == 'deprecated_after' {
            after_time = time.parse_iso8601(attr.arg) or {
                c.error('invalid time format', attr.pos)
                now
            }
        }
    }
    start_message := '${kind} `${name}`'
    error_time := after_time.add_days(180)
    if error_time < now {
        c.error(semicolonize('${start_message} has been deprecated since ${after_time.ymmdd()}',
            deprecation_message), pos)
    } else if after_time < now {
        c.warn(semicolonize('${start_message} has been deprecated since ${after_time.ymmdd()}, it will be an error after ${error_time.ymmdd()}',
            deprecation_message), pos)
    } else if after_time == now {
        // print_backtrace()
        c.warn(semicolonize('${start_message} has been deprecated', deprecation_message), pos)
        // c.warn(semicolonize('${start_message} has been deprecated!11 m=${deprecation_message}',
        // deprecation_message), pos)
    } else {
        c.note(semicolonize('${start_message} will be deprecated after ${after_time.ymmdd()}, and will become an error after ${error_time.ymmdd()}',
            deprecation_message), pos)
    }
}

fn semicolonize(main string, details string) string {
    if details == '' {
        return main
    }
    return '${main}; ${details}'
}