// Copyright (c) 2025 Felipe Pena. All rights reserved.
// Use of this source code is governed by an MIT license that can be found in the LICENSE file.
module main

import v.ast
import v.token
import os
import arrays

// cutoffs
const indexexpr_cutoff = os.getenv_opt('VET_INDEXEXPR_CUTOFF') or { '10' }.int()
const infixexpr_cutoff = os.getenv_opt('VET_INFIXEXPR_CUTOFF') or { '10' }.int()
const selectorexpr_cutoff = os.getenv_opt('VET_SELECTOREXPR_CUTOFF') or { '10' }.int()
const callexpr_cutoff = os.getenv_opt('VET_CALLEXPR_CUTOFF') or { '10' }.int()
const stringinterliteral_cutoff = os.getenv_opt('STRINGINTERLITERAL_CUTOFF') or { '10' }.int()
const stringliteral_cutoff = os.getenv_opt('STRINGLITERAL_CUTOFF') or { '10' }.int()
const ascast_cutoff = os.getenv_opt('ASCAST_CUTOFF') or { '10' }.int()
const stringconcat_cutoff = os.getenv_opt('STRINGCONCAT_CUTOFF') or { '10' }.int()

// possibly inline fn cutoff
const fns_call_cutoff = os.getenv_opt('VET_FNS_CALL_CUTOFF') or { '10' }.int() // at least N calls
const short_fns_cutoff = os.getenv_opt('VET_SHORT_FNS_CUTOFF') or { '3' }.int() // lines

// minimum size for string literals
const stringliteral_min_size = os.getenv_opt('VET_STRINGLITERAL_MIN_SIZE') or { '20' }.int()

// long functions cutoff
const long_fns_cutoff = os.getenv_opt('VET_LONG_FNS_CUTOFF') or { '300' }.int()

struct VetAnalyze {
mut:
    repeated_expr_cutoff  shared map[string]int // repeated code cutoff    
    repeated_expr         shared map[string]map[string]map[string][]token.Pos // repeated exprs in fn scope
    potential_non_inlined shared map[string]map[string]token.Pos              // fns might be inlined
    call_counter          shared map[string]int // fn call counter
    cur_fn                ast.FnDecl            // current fn declaration
}

// stmt checks for repeated code in statements
fn (mut vt VetAnalyze) stmt(vet &Vet, stmt ast.Stmt) {
    match stmt {
        ast.AssignStmt {
            if stmt.op == .plus_assign {
                if stmt.right[0] in [ast.StringLiteral, ast.StringInterLiteral] {
                    vt.save_expr(stringconcat_cutoff,
                        '${stmt.left[0].str()} += ${stmt.right[0].str()}', vet.file, stmt.pos)
                }
            }
        }
        else {}
    }
}

// save_expr registers a repeated code occurrence
fn (mut vt VetAnalyze) save_expr(cutoff int, expr string, file string, pos token.Pos) {
    lock vt.repeated_expr {
        if vt.cur_fn.name !in vt.repeated_expr {
            vt.repeated_expr[vt.cur_fn.name] = map[string]map[string][]token.Pos{}
        }
        if expr !in vt.repeated_expr[vt.cur_fn.name] {
            vt.repeated_expr[vt.cur_fn.name][expr] = map[string][]token.Pos{}
        }
        if file !in vt.repeated_expr[vt.cur_fn.name][expr] {
            vt.repeated_expr[vt.cur_fn.name][expr][file] = []token.Pos{}
        }
        vt.repeated_expr[vt.cur_fn.name][expr][file] << pos
    }
    lock vt.repeated_expr_cutoff {
        vt.repeated_expr_cutoff[expr] = cutoff
    }
}

// exprs checks for repeated code in expressions
fn (mut vt VetAnalyze) exprs(vet &Vet, exprs []ast.Expr) {
    for expr in exprs {
        vt.expr(vet, expr)
    }
}

// expr checks for repeated code
fn (mut vt VetAnalyze) expr(vet &Vet, expr ast.Expr) {
    match expr {
        ast.InfixExpr {
            vt.save_expr(infixexpr_cutoff, '${expr.left} ${expr.op} ${expr.right}', vet.file,
                expr.pos)
        }
        ast.IndexExpr {
            vt.save_expr(indexexpr_cutoff, '${expr.left}[${expr.index}]', vet.file, expr.pos)
        }
        ast.SelectorExpr {
            // nested selectors
            if expr.expr !is ast.Ident {
                vt.save_expr(selectorexpr_cutoff, '${expr.expr.str()}.${expr.field_name}',
                    vet.file, expr.pos)
            }
        }
        ast.CallExpr {
            if expr.is_static_method || expr.is_method {
                left_str := expr.left.str()
                lock vt.call_counter {
                    if vt.cur_fn.receiver.name == left_str {
                        vt.call_counter['${int(vt.cur_fn.receiver.typ)}.${expr.name}']++
                    }
                }
                vt.save_expr(callexpr_cutoff,
                    '${left_str}.${expr.name}(${expr.args.map(it.str()).join(', ')})', vet.file,
                    expr.pos)
            } else {
                lock vt.call_counter {
                    vt.call_counter[expr.name]++
                }
                vt.save_expr(callexpr_cutoff,
                    '${expr.name}(${expr.args.map(it.str()).join(', ')})', vet.file, expr.pos)
            }
        }
        ast.AsCast {
            vt.save_expr(ascast_cutoff, ast.Expr(expr).str(), vet.file, expr.pos)
        }
        ast.StringLiteral {
            if expr.val.len > stringliteral_min_size {
                vt.save_expr(stringliteral_cutoff, ast.Expr(expr).str(), vet.file, expr.pos)
            }
        }
        ast.StringInterLiteral {
            vt.save_expr(stringinterliteral_cutoff, ast.Expr(expr).str(), vet.file, expr.pos)
        }
        else {}
    }
}

// long_or_empty_fns checks for long or empty functions
fn (mut vt VetAnalyze) long_or_empty_fns(mut vet Vet, fn_decl ast.FnDecl) {
    nr_lines := fn_decl.end_pos.line_nr - fn_decl.pos.line_nr - 2
    if nr_lines > long_fns_cutoff {
        vet.notice('Long function - ${nr_lines} lines long.', fn_decl.pos.line_nr, .long_fns)
    } else if nr_lines == 0 {
        vet.notice('Empty function.', fn_decl.pos.line_nr, .empty_fn)
    }
}

// potential_non_inlined checks for potential fns to be inlined
fn (mut vt VetAnalyze) potential_non_inlined(mut vet Vet, fn_decl ast.FnDecl) {
    nr_lines := fn_decl.end_pos.line_nr - fn_decl.pos.line_nr - 2
    if nr_lines < short_fns_cutoff {
        attr := fn_decl.attrs.find_first('inline')
        if attr == none {
            lock vt.potential_non_inlined {
                vt.potential_non_inlined[fn_decl.fkey()][vet.file] = fn_decl.pos
            }
        }
    }
}

// vet_fn_analysis reports repeated code by scope
fn (mut vt VetAnalyze) vet_repeated_code(mut vet Vet) {
    rlock vt.repeated_expr {
        for fn_name, ref_expr in vt.repeated_expr {
            scope_name := if fn_name == '' { 'global scope' } else { 'function scope (${fn_name})' }
            for expr, info in ref_expr {
                occurrences := arrays.sum(info.values().map(it.len)) or { 0 }
                if occurrences < vt.repeated_expr_cutoff[expr] {
                    continue
                }
                for file, info_pos in info {
                    for k, pos in info_pos {
                        vet.notice_with_file(file,
                            '${expr} occurs ${k + 1}/${occurrences} times in ${scope_name}.',
                            pos.line_nr, .repeated_code)
                    }
                }
            }
        }
    }
}

// vet_inlining_fn reports possible fn to be inlined
fn (mut vt VetAnalyze) vet_inlining_fn(mut vet Vet) {
    for fn_name, info in vt.potential_non_inlined {
        for file, pos in info {
            calls := vt.call_counter[fn_name] or { 0 }
            if calls < fns_call_cutoff {
                continue
            }
            vet.notice_with_file(file,
                '${fn_name.all_after('.')} fn might be inlined (possibly called at least ${calls} times)',
                pos.line_nr, .inline_fn)
        }
    }
}

// vet_code_analyze performs code analysis
fn (mut vt Vet) vet_code_analyze() {
    if vt.opt.repeated_code {
        vt.analyze.vet_repeated_code(mut vt)
    }
    if vt.opt.fn_inlining {
        vt.analyze.vet_inlining_fn(mut vt)
    }
}