module checker

import v.ast

enum RootMutationVisibility {
    none
    direct
    private_path
    public_path
}

@[inline]
fn is_visible_root_mutation(vis RootMutationVisibility) bool {
    return vis in [.direct, .public_path]
}

fn (mut c Checker) visible_param_mutation_cache_key(func ast.Fn, param_idx int) string {
    return '${func.fkey()}|${param_idx}'
}

fn (mut c Checker) fn_has_visible_mutation_for_param(func ast.Fn, param_idx int) bool {
    if param_idx < 0 || param_idx >= func.params.len || !func.params[param_idx].is_mut {
        return false
    }
    cache_key := c.visible_param_mutation_cache_key(func, param_idx)
    if cache_key in c.visible_param_mutation_cache {
        return c.visible_param_mutation_cache[cache_key]
    }
    if cache_key in c.visible_param_mutation_in_progress {
        return true
    }
    if func.source_fn == unsafe { nil } || func.no_body || func.language != .v {
        c.visible_param_mutation_cache[cache_key] = true
        return true
    }
    fn_decl := unsafe { &ast.FnDecl(func.source_fn) }
    if fn_decl == unsafe { nil } || param_idx >= fn_decl.params.len {
        c.visible_param_mutation_cache[cache_key] = true
        return true
    }
    c.visible_param_mutation_in_progress[cache_key] = true
    res := c.fn_decl_has_visible_mutation_for_param(fn_decl, param_idx)
    c.visible_param_mutation_in_progress.delete(cache_key)
    c.visible_param_mutation_cache[cache_key] = res
    return res
}

fn (mut c Checker) fn_decl_has_visible_mutation_for_param(fn_decl &ast.FnDecl, param_idx int) bool {
    if param_idx < 0 || param_idx >= fn_decl.params.len || !fn_decl.params[param_idx].is_mut {
        return false
    }
    root_name := fn_decl.params[param_idx].name
    root_type := fn_decl.params[param_idx].typ
    for stmt in fn_decl.stmts {
        if c.stmt_has_visible_mutation(stmt, root_name, root_type) {
            return true
        }
    }
    return false
}

fn (mut c Checker) stmt_has_visible_mutation(stmt ast.Stmt, root_name string, root_type ast.Type) bool {
    match stmt {
        ast.FnDecl {
            return false
        }
        ast.ExprStmt {
            return c.expr_has_visible_mutation(stmt.expr, root_name, root_type)
        }
        ast.AssignStmt {
            for left_expr in stmt.left {
                if is_visible_root_mutation(c.expr_mutation_visibility(left_expr, root_name,
                    root_type))
                {
                    return true
                }
            }
            if c.assign_stmt_aliases_visible_state(stmt, root_name, root_type) {
                return true
            }
        }
        else {}
    }

    return c.node_children_have_visible_mutation(ast.Node(stmt), root_name, root_type)
}

fn (mut c Checker) expr_has_visible_mutation(expr ast.Expr, root_name string, root_type ast.Type) bool {
    match expr {
        ast.AnonFn, ast.LambdaExpr {
            return false
        }
        ast.CallExpr {
            if c.call_has_visible_root_mutation(expr, root_name, root_type) {
                return true
            }
        }
        ast.PrefixExpr {
            if expr.op == .amp
                && is_visible_root_mutation(c.expr_mutation_visibility(expr.right, root_name, root_type)) {
                return true
            }
        }
        ast.PostfixExpr {
            if is_visible_root_mutation(c.expr_mutation_visibility(expr.expr, root_name, root_type)) {
                return true
            }
        }
        ast.InfixExpr {
            if expr.op == .left_shift
                && is_visible_root_mutation(c.expr_mutation_visibility(expr.left, root_name, root_type)) {
                return true
            }
        }
        else {}
    }

    return c.node_children_have_visible_mutation(ast.Node(expr), root_name, root_type)
}

fn (mut c Checker) node_children_have_visible_mutation(node ast.Node, root_name string, root_type ast.Type) bool {
    for child in node.children() {
        match child {
            ast.Expr {
                if c.expr_has_visible_mutation(child, root_name, root_type) {
                    return true
                }
            }
            ast.Stmt {
                if child is ast.FnDecl {
                    continue
                }
                if c.stmt_has_visible_mutation(child, root_name, root_type) {
                    return true
                }
            }
            ast.CallArg {
                if c.expr_has_visible_mutation(child.expr, root_name, root_type) {
                    return true
                }
            }
            ast.IfBranch {
                if c.expr_has_visible_mutation(child.cond, root_name, root_type) {
                    return true
                }
                for stmt in child.stmts {
                    if c.stmt_has_visible_mutation(stmt, root_name, root_type) {
                        return true
                    }
                }
            }
            ast.MatchBranch {
                for branch_expr in child.exprs {
                    if c.expr_has_visible_mutation(branch_expr, root_name, root_type) {
                        return true
                    }
                }
                for stmt in child.stmts {
                    if c.stmt_has_visible_mutation(stmt, root_name, root_type) {
                        return true
                    }
                }
            }
            ast.SelectBranch {
                if c.stmt_has_visible_mutation(child.stmt, root_name, root_type) {
                    return true
                }
                for stmt in child.stmts {
                    if c.stmt_has_visible_mutation(stmt, root_name, root_type) {
                        return true
                    }
                }
            }
            else {}
        }
    }
    return false
}

fn (mut c Checker) expr_mutation_visibility(expr ast.Expr, root_name string, root_type ast.Type) RootMutationVisibility {
    mut reduced := expr
    reduced = reduced.remove_par()
    current := reduced
    if current is ast.Ident {
        return if current.name == root_name {
            .direct
        } else {
            .none
        }
    }
    if current is ast.SelectorExpr {
        mut parent_expr := current.expr
        parent_expr = parent_expr.remove_par()
        parent := parent_expr
        if parent is ast.Ident && parent.name == root_name {
            root_sym := c.table.final_sym(c.unwrap_generic(root_type))
            field := c.table.find_field_with_embeds(root_sym, current.field_name) or {
                return .public_path
            }
            return if field.is_pub { .public_path } else { .private_path }
        }
        return c.expr_mutation_visibility(parent, root_name, root_type)
    }
    if current is ast.IndexExpr {
        return c.expr_mutation_visibility(current.left, root_name, root_type)
    }
    if current is ast.PrefixExpr {
        return c.expr_mutation_visibility(current.right, root_name, root_type)
    }
    if current is ast.PostfixExpr {
        return c.expr_mutation_visibility(current.expr, root_name, root_type)
    }
    if current is ast.CastExpr {
        return c.expr_mutation_visibility(current.expr, root_name, root_type)
    }
    if current is ast.CallExpr {
        if current.is_method {
            return c.expr_mutation_visibility(current.left, root_name, root_type)
        }
    }
    return .none
}

fn (mut c Checker) call_has_visible_root_mutation(node ast.CallExpr, root_name string, root_type ast.Type) bool {
    mut called_fn := ast.Fn{}
    mut has_called_fn := false
    if func := c.find_called_fn(node) {
        called_fn = func
        has_called_fn = true
    }
    if node.is_method {
        left_vis := c.expr_mutation_visibility(node.left, root_name, root_type)
        if has_called_fn {
            if called_fn.params.len > 0 && called_fn.params[0].is_mut {
                match left_vis {
                    .direct {
                        if c.fn_has_visible_mutation_for_param(called_fn, 0) {
                            return true
                        }
                    }
                    .public_path {
                        return true
                    }
                    else {}
                }
            }
        } else if is_visible_root_mutation(left_vis) {
            return true
        }
    }
    if !has_called_fn {
        for arg in node.args {
            if arg.is_mut
                && is_visible_root_mutation(c.expr_mutation_visibility(arg.expr, root_name, root_type)) {
                return true
            }
        }
        return false
    }
    for i, arg in node.args {
        if !arg.is_mut {
            continue
        }
        param_idx := c.call_arg_param_index(called_fn, i)
        arg_vis := c.expr_mutation_visibility(arg.expr, root_name, root_type)
        if param_idx < 0 || param_idx >= called_fn.params.len {
            if is_visible_root_mutation(arg_vis) {
                return true
            }
            continue
        }
        if !called_fn.params[param_idx].is_mut {
            continue
        }
        match arg_vis {
            .direct {
                if c.fn_has_visible_mutation_for_param(called_fn, param_idx) {
                    return true
                }
            }
            .public_path {
                return true
            }
            else {}
        }
    }
    return false
}

fn (mut c Checker) find_called_fn(node ast.CallExpr) ?ast.Fn {
    if node.is_method {
        mut candidate_types := []ast.Type{}
        for typ in [node.receiver_type, node.left_type, c.unwrap_generic(node.receiver_type),
            c.unwrap_generic(node.left_type)] {
            if typ != 0 && typ !in candidate_types {
                candidate_types << typ
            }
        }
        for typ in candidate_types {
            sym := c.table.sym(c.unwrap_generic(typ))
            if method := c.table.find_method(sym, node.name) {
                return method
            }
            if method := c.table.find_method_with_embeds(sym, node.name) {
                return method
            }
        }
        return none
    }
    return c.table.find_fn(node.name)
}

fn (c &Checker) call_arg_param_index(func ast.Fn, arg_idx int) int {
    offset := if func.is_method { 1 } else { 0 }
    if func.is_variadic && func.params.len > 0 && arg_idx + offset >= func.params.len - 1 {
        return func.params.len - 1
    }
    param_idx := arg_idx + offset
    if param_idx >= func.params.len {
        return -1
    }
    return param_idx
}

fn (mut c Checker) assign_stmt_aliases_visible_state(node ast.AssignStmt, root_name string, root_type ast.Type) bool {
    mut pair_count := node.left.len
    if node.right.len < pair_count {
        pair_count = node.right.len
    }
    for i in 0 .. pair_count {
        right_vis := c.expr_mutation_visibility(node.right[i], root_name, root_type)
        if !is_visible_root_mutation(right_vis) {
            continue
        }
        right_type := if i < node.right_types.len {
            node.right_types[i]
        } else {
            ast.no_type
        }
        if !c.type_may_share_mutable_storage(right_type) {
            continue
        }
        mut left_expr := node.left[i]
        left_expr = left_expr.remove_par()
        if left_expr is ast.Ident && left_expr.is_mut() {
            return true
        }
    }
    return false
}

fn (mut c Checker) type_may_share_mutable_storage(typ ast.Type) bool {
    if typ == 0 || typ == ast.no_type {
        return false
    }
    unwrapped := c.unwrap_generic(typ)
    if unwrapped.is_any_kind_of_pointer() || unwrapped.has_flag(.shared_f) {
        return true
    }
    return c.table.final_sym(unwrapped).kind in [.array, .map, .chan, .interface, .thread, .function]
}