// 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 c

import strings
import v.ast

fn (g &Gen) needs_scope_cleanup() bool {
    return g.is_autofree || g.pref.gc_mode == .boehm_leak
}

fn (mut g Gen) autofree_scope_vars(pos int, line_nr int, free_parent_scopes bool) {
    if !g.needs_scope_cleanup() {
        return
    }
    // g.writeln('// afsv pos=${pos} line_nr=${line_nr} freeparent_scopes=${free_parent_scopes}')
    g.autofree_scope_vars_stop(pos, line_nr, free_parent_scopes, -1)
}

fn (mut g Gen) autofree_scope_vars_stop(pos int, line_nr int, free_parent_scopes bool, stop_pos int) {
    if !g.needs_scope_cleanup() {
        return
    }
    if g.is_builtin_mod {
        // In `builtin` everything is freed manually.
        return
    }
    if pos == -1 {
        // TODO: why can pos be -1?
        return
    }
    // eprintln('> free_scope_vars(${pos})')
    scope := g.file.scope.innermost(pos)
    // g.writeln('// scope start pos=${scope.start_pos} ')
    if scope.start_pos == 0 {
        // TODO: why can scope.pos be 0? (only outside fns?)
        return
    }
    g.trace_autofree('// autofree_scope_vars(pos=${pos} line_nr=${line_nr} scope.pos=${scope.start_pos} scope.end_pos=${scope.end_pos})')
    g.autofree_scope_vars2(scope, scope.start_pos, scope.end_pos, line_nr, free_parent_scopes,
        stop_pos)
}

@[if trace_autofree ?]
fn (mut g Gen) trace_autofree(line string) {
    g.writeln(line)
}

//@[if print_autofree_vars ?]
// fn (mut g Gen) print_autofree_var(var string, position string, comment string) {
fn (mut g Gen) print_autofree_var(var ast.Var, comment string) {
    if !g.pref.print_autofree_vars && g.pref.print_autofree_vars_in_fn == '' {
        return
    }
    println('autofree: ${g.file.path}:${var.pos.line_nr}: skipping `${var.name}` in fn `${g.last_fn_c_name}`. ${comment}')
}

fn (mut g Gen) autofree_scope_vars2(scope &ast.Scope, start_pos int, end_pos int, line_nr int, free_parent_scopes bool,
    stop_pos int) {
    if scope == unsafe { nil } {
        return
    }
    g.trace_autofree('// scopeobjects.len == ${scope.objects.len}')
    for _, obj in scope.objects {
        match obj {
            ast.Var {
                g.trace_autofree('// var "${obj.name}" var.pos=${obj.pos.pos} var.line_nr=${obj.pos.line_nr}')
                if obj.name in g.returned_var_names {
                    g.print_autofree_var(obj, 'returned from function')
                    g.trace_autofree('// skipping returned var')
                    continue
                }
                if obj.is_or {
                    // Skip vars inited with the `or {}`, since they are generated
                    // after the or block in C.
                    g.trace_autofree('// skipping `or {}` var "${obj.name}"')
                    continue
                }
                if obj.is_tmp {
                    // Skip for loop vars
                    g.print_autofree_var(obj, 'tmp var (loop?)')
                    g.trace_autofree('// skipping tmp var "${obj.name}"')
                    continue
                }
                if obj.is_inherited {
                    g.print_autofree_var(obj, 'inherited')
                    g.trace_autofree('// skipping inherited var "${obj.name}"')
                    continue
                }
                if obj.name in g.for_c_init_autofree_keep_vars {
                    g.print_autofree_var(obj, 'ForC init')
                    g.trace_autofree('// skipping ForC init var "${obj.name}"')
                    continue
                }
                // if var.typ == 0 {
                // // TODO: why 0?
                // continue
                // }
                // if v.pos.pos > end_pos {
                if obj.pos.pos > end_pos
                    || (obj.pos.pos < start_pos && obj.pos.line_nr == line_nr)
                    || (end_pos < scope.end_pos && obj.expr is ast.IfExpr) {
                    // Do not free vars that were declared after this scope
                    continue
                }
                if obj.expr is ast.IfGuardExpr {
                    continue
                }
                if obj.expr is ast.UnsafeExpr && obj.expr.expr is ast.CallExpr
                    && (obj.expr.expr as ast.CallExpr).is_method {
                    if left_var := scope.objects[obj.expr.expr.left.str()] {
                        if func := g.table.find_method(g.table.final_sym(left_var.typ),
                            obj.expr.expr.name)
                        {
                            if func.attrs.contains('reused') && left_var is ast.Var
                                && left_var.expr is ast.CastExpr {
                                if left_var.expr.expr.is_literal() {
                                    continue
                                }
                            }
                        }
                    }
                }
                g.autofree_variable(obj)
            }
            else {}
        }
    }
    for g.autofree_scope_stmts.len > 0 {
        g.write(g.autofree_scope_stmts.pop())
    }
    // Free all vars in parent scopes as well:
    // ```
    // s := ...
    // if ... {
    // s.free()
    // return
    // }
    // ```
    // if scope.parent != unsafe { nil } && line_nr > 0 {
    if free_parent_scopes && scope.parent != unsafe { nil } && !scope.detached_from_parent
        && (stop_pos == -1 || scope.parent.start_pos >= stop_pos) {
        g.trace_autofree('// af parent scope:')
        g.autofree_scope_vars2(scope.parent, start_pos, end_pos, line_nr, true, stop_pos)
    }
}

fn (mut g Gen) autofree_variable(v ast.Var) {
    // filter out invalid variables
    if v.typ == 0 {
        return
    }
    sym := g.table.sym(v.typ)
    // if v.name.contains('output2') {
    if g.is_autofree {
        // eprintln('   > var name: ${v.name:-20s} | is_arg: ${v.is_arg.str():6} | var type: ${int(v.typ):8} | type_name: ${sym.name:-33s}')
    }
    // }
    base_typ := v.typ.set_nr_muls(0).clear_option_and_result()
    if g.type_has_unresolved_generic_parts(base_typ) {
        g.print_autofree_var(v, 'unresolved generic type')
        return
    }
    mut free_fn := g.styp(base_typ) + '_free'
    if sym.kind == .array {
        free_fn = g.get_free_method(base_typ)
        g.autofree_var_call(free_fn, v)
        return
    }
    if sym.kind == .map {
        free_fn = g.get_free_method(base_typ)
        g.autofree_var_call(free_fn, v)
        return
    }
    if sym.kind == .string {
        // Don't free simple string literals.
        match v.expr {
            ast.StringLiteral {
                g.print_autofree_var(v, 'string literal')
                g.trace_autofree('// str literal')
            }
            else {
                // NOTE/TODO: assign_stmt multi returns variables have no expr
                // since the type comes from the called fns return type
                /*
                f := v.name[0]
                if
                    //!(f >= `a` && f <= `d`) {
                    //f != `c` {
                    v.name!='cvar_name' {
                    t := typeof(v.expr)
                return '// other ' + t + '\n'
                }
                */
            }
        }

        g.autofree_var_call('builtin__string_free', v)
        return
    }
    if sym.is_builtin() {
        free_fn = 'builtin__${free_fn}'
    }
    // Free user reference types
    is_user_ref := v.typ.is_ptr() && sym.name.after('.')[0].is_capital()
    // if g.pref.experimental && v.typ.is_ptr() && sym.name.after('.')[0].is_capital() {
    if is_user_ref {
        if g.pref.experimental {
            g.autofree_var_call('free', v)
        } else {
            g.print_autofree_var(v, 'user reference type, use -experimental to autofree those')
        }
    }
    if sym.has_method('free') {
        g.autofree_var_call(free_fn, v)
    }
}

fn (mut g Gen) autofree_var_call(free_fn_name string, v ast.Var) {
    if v.is_arg {
        // fn args should not be autofreed
        return
    }
    if v.is_used && v.is_autofree_tmp {
        // tmp expr vars do not need to be freed again here
        return
    }
    if g.is_builtin_mod {
        return
    }
    if !g.needs_scope_cleanup() {
        return
    }
    // if v.is_autofree_tmp && !g.doing_autofree_tmp {
    // return
    // }
    if v.name.contains('expr_write_string_1_') {
        // TODO: remove this temporary hack
        return
    }
    mut af := strings.new_builder(128)
    if v.typ.is_ptr() && v.typ.idx() != ast.u8_type_idx {
        if !v.is_auto_heap && !g.table.sym(v.typ).has_method('free') {
            return
        }
        af.write_string('\t')
        if v.typ.share() == .shared_t {
            af.write_string(free_fn_name.replace_each(['__shared__', '']))
        } else {
            af.write_string(free_fn_name)
        }
        af.write_string('(')
        if v.typ.has_flag(.option) {
            base_type := g.base_type(v.typ)
            af.write_string('(${base_type}*)')
        }
        if v.typ.share() == .shared_t {
            af.write_string('&')
        }
        af.write_string(strings.repeat(`*`, v.typ.nr_muls() - 1)) // dereference if it is a pointer to a pointer
        af.write_string(c_name(v.name))
        if v.typ.share() == .shared_t {
            af.write_string('->val')
        }
        if v.typ.has_flag(.option) {
            af.write_string('.data)')
        }

        af.writeln('); // autofreed ptr var')
    } else {
        if v.typ == ast.error_type && !v.is_autofree_tmp {
            return
        }
        if v.is_auto_heap {
            af.writeln('\t${free_fn_name}(${c_name(v.name)}); // autofreed heap var ${g.cur_mod.name} ${g.is_builtin_mod}')
        } else if v.typ.has_flag(.option) {
            base_type := g.base_type(v.typ)
            af.writeln('\tif (${c_name(v.name)}.state != 2) {')
            af.writeln('\t\t${free_fn_name}((${base_type}*)${c_name(v.name)}.data); // autofreed option var ${g.cur_mod.name} ${g.is_builtin_mod}')
            af.writeln('\t}')
        } else if v.typ.idx() != ast.u8_type_idx {
            af.writeln('\t${free_fn_name}(&${c_name(v.name)}); // autofreed var ${g.cur_mod.name} ${g.is_builtin_mod}')
        }
    }
    g.autofree_scope_stmts << af.str()
}

fn (mut g Gen) detect_used_var_on_return(expr ast.Expr) {
    match expr {
        ast.Ident {
            g.returned_var_names[expr.name] = true
        }
        ast.StructInit {
            for field_expr in expr.init_fields {
                g.detect_used_var_on_return(field_expr.expr)
            }
        }
        else {}
    }
}

fn selector_root_name(expr ast.SelectorExpr) ?string {
    mut root_expr := expr.expr
    for root_expr is ast.SelectorExpr {
        root_expr = root_expr.expr
    }
    if root_expr is ast.Ident {
        return root_expr.name
    }
    return none
}

fn (mut g Gen) selector_return_preserves_owner(expr ast.SelectorExpr) bool {
    if expr.typ == 0 {
        return false
    }
    if expr.typ.is_any_kind_of_pointer() {
        return true
    }
    base_typ := expr.typ.set_nr_muls(0).clear_option_and_result()
    if base_typ == 0 || g.type_has_unresolved_generic_parts(base_typ) {
        return false
    }
    unwrapped_typ := g.unwrap_generic(base_typ)
    sym := g.table.sym(unwrapped_typ)
    if sym.has_method('free') {
        return true
    }
    unaliased_typ :=
        g.table.fully_unaliased_type(unwrapped_typ).set_nr_muls(0).clear_option_and_result()
    if unaliased_typ == 0 || g.type_has_unresolved_generic_parts(unaliased_typ) {
        return false
    }
    final_sym := g.table.final_sym(unaliased_typ)
    return final_sym.kind in [.array, .map, .string, .struct, .sum_type, .interface]
        || final_sym.has_method('free')
}

fn (mut g Gen) collect_returned_var_names(expr ast.Expr, mut names map[string]bool, mut selector_owner_names map[string]bool) {
    match expr {
        ast.Ident {
            names[expr.name] = true
        }
        ast.SelectorExpr {
            if g.selector_return_preserves_owner(expr) {
                if root_name := selector_root_name(expr) {
                    selector_owner_names[root_name] = true
                }
            }
        }
        ast.StructInit {
            for field_expr in expr.init_fields {
                g.collect_returned_var_names(field_expr.expr, mut names, mut selector_owner_names)
            }
        }
        else {}
    }
}

fn (mut g Gen) returned_var_names_from_return(node ast.Return) (map[string]bool, map[string]bool) {
    mut names := map[string]bool{}
    mut selector_owner_names := map[string]bool{}
    for expr in node.exprs {
        g.collect_returned_var_names(expr, mut names, mut selector_owner_names)
    }
    return names, selector_owner_names
}