// Copyright (c) 2026 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 transformer

import v2.ast
import v2.types

// is_interface_var checks if a variable is an interface type by looking up its type in scope
fn (t &Transformer) is_interface_var(name string) bool {
    // Special case: 'err' in or-blocks is always IError interface
    if name == 'err' {
        return true
    }
    typ := t.lookup_var_type(name) or { return false }
    return typ is types.Interface
}

// is_interface_receiver checks if an expression's type is an interface type
fn (t &Transformer) is_interface_receiver(expr ast.Expr) bool {
    match expr {
        ast.Ident {
            return t.is_interface_var(expr.name)
        }
        ast.ParenExpr {
            return t.is_interface_receiver(expr.expr)
        }
        ast.ModifierExpr {
            return t.is_interface_receiver(expr.expr)
        }
        else {}
    }

    if typ := t.get_interface_receiver_type(expr) {
        base := t.unwrap_alias_and_pointer_type(typ)
        return base is types.Interface
    }
    return false
}

fn (t &Transformer) get_interface_receiver_type(expr ast.Expr) ?types.Type {
    if typ := t.get_expr_type(expr) {
        return typ
    }
    if typ := t.resolve_expr_type(expr) {
        return typ
    }
    if expr is ast.IndexExpr {
        if expr.expr is ast.RangeExpr {
            return none
        }
        if container_type := t.get_expr_type(expr.lhs) {
            base := t.unwrap_alias_and_pointer_type(container_type)
            if base is types.Array {
                return base.elem_type
            }
            if base is types.ArrayFixed {
                return base.elem_type
            }
            if base is types.Map {
                return base.value_type
            }
        }
    }
    return none
}

// is_interface_cast checks if an expression is an interface cast like Calculator(value)
fn (t &Transformer) is_interface_cast(expr ast.Expr) bool {
    if t.get_interface_cast_inner_expr(expr) != none {
        return true
    }
    return false
}

// get_expr_type_name returns the concrete type name for an expression using the type checker env
fn (t &Transformer) get_expr_type_name(expr ast.Expr) ?string {
    if typ := t.get_expr_type(expr) {
        name := t.type_to_c_name(typ)
        if name != '' {
            return name
        }
    }
    // For simple identifiers, try scope lookup
    if expr is ast.Ident {
        if typ := t.lookup_var_type(expr.name) {
            name := t.type_to_c_name(typ)
            if name != '' {
                return name
            }
        }
    }
    return none
}

fn (t &Transformer) get_interface_cast_concrete_type(expr ast.Expr) ?string {
    match expr {
        ast.ParenExpr {
            return t.get_interface_cast_concrete_type(expr.expr)
        }
        ast.CallOrCastExpr {
            if t.interface_type_expr_is_interface(expr.lhs) {
                if concrete := t.get_expr_type_name(expr.expr) {
                    return concrete
                }
            }
        }
        ast.CallExpr {
            if expr.args.len == 1 && t.interface_type_expr_is_interface(expr.lhs) {
                if concrete := t.get_expr_type_name(expr.args[0]) {
                    return concrete
                }
            }
        }
        ast.CastExpr {
            if t.interface_type_expr_is_interface(expr.typ) {
                if concrete := t.get_expr_type_name(expr.expr) {
                    return concrete
                }
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) get_interface_cast_inner_expr(expr ast.Expr) ?ast.Expr {
    match expr {
        ast.ParenExpr {
            return t.get_interface_cast_inner_expr(expr.expr)
        }
        ast.CallOrCastExpr {
            if t.interface_type_expr_is_interface(expr.lhs) {
                return expr.expr
            }
        }
        ast.CallExpr {
            if expr.args.len == 1 && t.interface_type_expr_is_interface(expr.lhs) {
                return expr.args[0]
            }
        }
        ast.CastExpr {
            if t.interface_type_expr_is_interface(expr.typ) {
                return expr.expr
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) interface_type_expr_is_interface(expr ast.Expr) bool {
    type_name := t.expr_to_type_name(expr)
    if type_name != '' {
        if typ := t.lookup_type(type_name) {
            return typ is types.Interface
        }
    }
    if expr is ast.Ident {
        mut scope := t.get_current_scope() or { return false }
        obj := scope.lookup_parent(expr.name, 0) or { return false }
        if obj is types.Type {
            return obj is types.Interface
        }
    }
    return false
}

fn (t &Transformer) get_interface_array_init_concrete_type(expr &ast.ArrayInitExpr) ?string {
    if !expr_array_has_valid_data(expr.exprs) {
        return none
    }
    mut concrete_type := ''
    for e in expr.exprs {
        concrete := t.get_interface_cast_concrete_type(e) or { return none }
        if concrete_type == '' {
            concrete_type = concrete
        } else if concrete_type != concrete {
            return none
        }
    }
    if concrete_type != '' {
        return concrete_type
    }
    return none
}

fn (t &Transformer) get_interface_array_expr_concrete_type(expr ast.Expr) ?string {
    match expr {
        ast.Ident {
            return t.get_interface_concrete_type(expr.name)
        }
        ast.ParenExpr {
            return t.get_interface_array_expr_concrete_type(expr.expr)
        }
        ast.ArrayInitExpr {
            return t.get_interface_array_init_concrete_type(&expr)
        }
        ast.CallExpr {
            if expr.lhs is ast.SelectorExpr {
                sel := expr.lhs as ast.SelectorExpr
                if sel.rhs.name in ['repeat', 'clone'] {
                    return t.get_interface_array_expr_concrete_type(sel.lhs)
                }
            }
        }
        ast.CallOrCastExpr {
            if expr.lhs is ast.SelectorExpr {
                sel := expr.lhs as ast.SelectorExpr
                if sel.rhs.name in ['repeat', 'clone'] {
                    return t.get_interface_array_expr_concrete_type(sel.lhs)
                }
            }
        }
        else {}
    }

    return none
}

fn (t &Transformer) get_interface_assignment_concrete_type(expr ast.Expr) ?string {
    if concrete := t.get_interface_cast_concrete_type(expr) {
        return concrete
    }
    if concrete := t.get_interface_array_expr_concrete_type(expr) {
        return concrete
    }
    if expr is ast.Ident {
        return t.get_interface_concrete_type(expr.name)
    }
    if expr is ast.ParenExpr {
        return t.get_interface_assignment_concrete_type(expr.expr)
    }
    return none
}

fn (t &Transformer) get_interface_concrete_type_for_expr(expr ast.Expr) ?string {
    match expr {
        ast.Ident {
            return t.get_interface_concrete_type(expr.name)
        }
        ast.ParenExpr {
            return t.get_interface_concrete_type_for_expr(expr.expr)
        }
        ast.ModifierExpr {
            return t.get_interface_concrete_type_for_expr(expr.expr)
        }
        ast.IndexExpr {
            return t.get_interface_array_expr_concrete_type(expr.lhs)
        }
        else {}
    }

    return none
}

fn (t &Transformer) get_native_default_interface_concrete_type(expr ast.Expr, method_name string) ?string {
    prng_methods := ['seed', 'u8', 'u16', 'u32', 'u64', 'block_size', 'free']
    if method_name !in prng_methods {
        return none
    }
    if t.cur_module == 'rand' {
        return 'wyrand__WyRandRNG'
    }
    receiver_type := t.get_interface_receiver_type(expr) or { return none }
    base := t.unwrap_alias_and_pointer_type(receiver_type)
    if base !is types.Interface {
        return none
    }
    iface_name := t.type_to_c_name(base)
    if iface_name !in ['PRNG', 'rand__PRNG'] {
        return none
    }
    return 'wyrand__WyRandRNG'
}

fn (mut t Transformer) native_interface_receiver_arg(expr ast.Expr, concrete string) ast.Expr {
    concrete_type := t.c_name_to_type(concrete) or { return expr }
    return t.native_interface_receiver_arg_with_type(expr, concrete_type)
}

fn (mut t Transformer) native_interface_receiver_arg_with_type(expr ast.Expr, concrete_type types.Type) ast.Expr {
    match expr {
        ast.IndexExpr {
            pos := t.next_synth_pos()
            t.register_synth_type(pos, concrete_type)
            return ast.Expr(ast.IndexExpr{
                lhs:      expr.lhs
                expr:     expr.expr
                is_gated: expr.is_gated
                pos:      pos
            })
        }
        ast.ParenExpr {
            return ast.Expr(ast.ParenExpr{
                expr: t.native_interface_receiver_arg_with_type(expr.expr, concrete_type)
                pos:  expr.pos
            })
        }
        ast.ModifierExpr {
            return ast.Expr(ast.ModifierExpr{
                kind: expr.kind
                expr: t.native_interface_receiver_arg_with_type(expr.expr, concrete_type)
                pos:  expr.pos
            })
        }
        else {}
    }

    return expr
}

// get_interface_concrete_type returns the concrete type name for an interface variable
// if it was tracked during interface cast lowering (native backend only)
fn (t &Transformer) get_interface_concrete_type(name string) ?string {
    if concrete := t.interface_concrete_types[name] {
        return concrete
    }
    return none
}