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

import v2.ast

fn (mut g Gen) try_gen_orm_create_call(c_name string, call_args []ast.Expr) bool {
    if call_args.len != 3 || !c_name.ends_with('__create') {
        return false
    }
    if !orm_table_can_emit(call_args[1]) || !orm_table_fields_array_can_emit(call_args[2]) {
        return false
    }
    g.sb.write_string('${c_name}(')
    g.gen_call_arg(c_name, 0, call_args[0])
    g.sb.write_string(', ')
    g.write_orm_table_c_expr(call_args[1])
    g.sb.write_string(', ')
    g.write_orm_table_fields_array_c_expr(call_args[2])
    g.sb.write_string(')')
    if c_name != '' {
        g.mark_called_fn_name(c_name)
    }
    return true
}

fn (mut g Gen) try_gen_orm_create_call_expr(node ast.CallExpr) bool {
    if !orm_create_call_can_emit(node) {
        return false
    }
    lhs := node.lhs as ast.SelectorExpr
    name := g.orm_create_call_name(node) or { return false }
    call_args := [
        lhs.lhs,
        node.args[0],
        node.args[1],
    ]
    return g.try_gen_orm_create_call(name, call_args)
}

fn orm_create_call_can_emit(node ast.CallExpr) bool {
    if node.args.len != 2 || node.lhs !is ast.SelectorExpr {
        return false
    }
    lhs := node.lhs as ast.SelectorExpr
    return lhs.rhs.name == 'create' && orm_table_can_emit(node.args[0])
        && orm_table_fields_array_can_emit(node.args[1])
}

fn (mut g Gen) orm_create_call_name(node ast.CallExpr) ?string {
    if node.lhs !is ast.SelectorExpr {
        return none
    }
    lhs := node.lhs as ast.SelectorExpr
    method_name := sanitize_fn_ident(lhs.rhs.name)
    mut name := g.resolve_call_name(node.lhs, node.args.len)
    if name != '' {
        return name
    }
    mut base_type := g.method_receiver_base_type(lhs.lhs)
    if base_type == '' {
        base_type = g.get_expr_type(lhs.lhs).trim_space().trim_right('*')
    }
    if base_type == '' {
        base_type = g.receiver_local_base_type(lhs.lhs)
    }
    if name == '' && base_type != '' {
        if embedded := g.resolve_method_on_embedded_receiver(base_type, method_name) {
            name = embedded.method_c_name
        }
    }
    if name == '' && base_type != '' {
        name = '${base_type}__${method_name}'
    }
    if name == '' {
        return none
    }
    return name
}

fn (mut g Gen) orm_create_call_result_type(node ast.CallExpr) ?string {
    if !orm_create_call_can_emit(node) {
        return none
    }
    name := g.orm_create_call_name(node) or { return none }
    if ret := g.fn_return_types[name] {
        return ret
    }
    return none
}

fn orm_table_can_emit(expr ast.Expr) bool {
    init := orm_init_expr(expr) or { return false }
    name_expr := orm_init_field_value(init, 'name') or { return false }
    attrs_expr := orm_init_field_value(init, 'attrs') or { return false }
    return orm_string_value(name_expr) != none && orm_vattribute_array_can_emit(attrs_expr)
}

fn orm_table_fields_array_can_emit(expr ast.Expr) bool {
    arr := orm_array_init_expr(expr) or { return false }
    for field_expr in arr.exprs {
        if !orm_table_field_can_emit(field_expr) {
            return false
        }
    }
    return true
}

fn orm_table_field_can_emit(expr ast.Expr) bool {
    init := orm_init_expr(expr) or { return false }
    name_expr := orm_init_field_value(init, 'name') or { return false }
    typ_expr := orm_init_field_value(init, 'typ') or { return false }
    nullable_expr := orm_init_field_value(init, 'nullable') or { return false }
    default_val_expr := orm_init_field_value(init, 'default_val') or { return false }
    attrs_expr := orm_init_field_value(init, 'attrs') or { return false }
    is_arr_expr := orm_init_field_value(init, 'is_arr') or { return false }
    return orm_string_value(name_expr) != none && orm_number_c_expr(typ_expr) != none
        && orm_bool_c_expr(nullable_expr) != none && orm_string_value(default_val_expr) != none
        && orm_vattribute_array_can_emit(attrs_expr) && orm_bool_c_expr(is_arr_expr) != none
}

fn orm_vattribute_array_can_emit(expr ast.Expr) bool {
    arr := orm_array_init_expr(expr) or { return false }
    for attr_expr in arr.exprs {
        if !orm_vattribute_can_emit(attr_expr) {
            return false
        }
    }
    return true
}

fn orm_vattribute_can_emit(expr ast.Expr) bool {
    init := orm_init_expr(expr) or { return false }
    name_expr := orm_init_field_value(init, 'name') or { return false }
    has_arg_expr := orm_init_field_value(init, 'has_arg') or { return false }
    arg_expr := orm_init_field_value(init, 'arg') or { return false }
    kind_expr := orm_init_field_value(init, 'kind') or { return false }
    return orm_string_value(name_expr) != none && orm_bool_c_expr(has_arg_expr) != none
        && orm_string_value(arg_expr) != none && orm_ident_c_expr(kind_expr) != none
}

fn (mut g Gen) write_orm_table_c_expr(expr ast.Expr) {
    init := orm_init_expr(expr) or { return }
    name_expr := orm_init_field_value(init, 'name') or { return }
    attrs_expr := orm_init_field_value(init, 'attrs') or { return }
    g.sb.write_string('((orm__Table){.name = ')
    g.write_orm_v_string_c_expr(name_expr)
    g.sb.write_string(',.attrs = ')
    g.write_orm_vattribute_array_c_expr(attrs_expr)
    g.sb.write_string('})')
}

fn (mut g Gen) write_orm_table_fields_array_c_expr(expr ast.Expr) {
    arr := orm_array_init_expr(expr) or { return }
    g.sb.write_string('new_array_from_c_array(${arr.exprs.len}, ${arr.exprs.len}, sizeof(orm__TableField), ')
    if arr.exprs.len == 0 {
        g.sb.write_string('&(array){0})')
        return
    }
    g.sb.write_string('&(orm__TableField[${arr.exprs.len}]){')
    for i, field_expr in arr.exprs {
        if i > 0 {
            g.sb.write_string(', ')
        }
        g.write_orm_table_field_c_expr(field_expr)
    }
    g.sb.write_string('})')
}

fn (mut g Gen) write_orm_table_field_c_expr(expr ast.Expr) {
    init := orm_init_expr(expr) or { return }
    name_expr := orm_init_field_value(init, 'name') or { return }
    typ_expr := orm_init_field_value(init, 'typ') or { return }
    nullable_expr := orm_init_field_value(init, 'nullable') or { return }
    default_val_expr := orm_init_field_value(init, 'default_val') or { return }
    attrs_expr := orm_init_field_value(init, 'attrs') or { return }
    is_arr_expr := orm_init_field_value(init, 'is_arr') or { return }
    g.sb.write_string('((orm__TableField){.name = ')
    g.write_orm_v_string_c_expr(name_expr)
    g.sb.write_string(',.typ = ')
    g.sb.write_string(orm_number_c_expr(typ_expr) or { return })
    g.sb.write_string(',.nullable = ')
    g.sb.write_string(orm_bool_c_expr(nullable_expr) or { return })
    g.sb.write_string(',.default_val = ')
    g.write_orm_v_string_c_expr(default_val_expr)
    g.sb.write_string(',.attrs = ')
    g.write_orm_vattribute_array_c_expr(attrs_expr)
    g.sb.write_string(',.is_arr = ')
    g.sb.write_string(orm_bool_c_expr(is_arr_expr) or { return })
    g.sb.write_string('})')
}

fn (mut g Gen) write_orm_vattribute_array_c_expr(expr ast.Expr) {
    arr := orm_array_init_expr(expr) or { return }
    if arr.exprs.len == 0 {
        g.sb.write_string('new_array_from_c_array(0, 0, sizeof(VAttribute), &(array){0})')
        return
    }
    g.sb.write_string('new_array_from_c_array(${arr.exprs.len}, ${arr.exprs.len}, sizeof(VAttribute), &(VAttribute[${arr.exprs.len}]){')
    for i, attr_expr in arr.exprs {
        if i > 0 {
            g.sb.write_string(', ')
        }
        g.write_orm_vattribute_c_expr(attr_expr)
    }
    g.sb.write_string('})')
}

fn (mut g Gen) write_orm_vattribute_c_expr(expr ast.Expr) {
    init := orm_init_expr(expr) or { return }
    name_expr := orm_init_field_value(init, 'name') or { return }
    has_arg_expr := orm_init_field_value(init, 'has_arg') or { return }
    arg_expr := orm_init_field_value(init, 'arg') or { return }
    kind_expr := orm_init_field_value(init, 'kind') or { return }
    g.sb.write_string('((VAttribute){.name = ')
    g.write_orm_v_string_c_expr(name_expr)
    g.sb.write_string(',.has_arg = ')
    g.sb.write_string(orm_bool_c_expr(has_arg_expr) or { return })
    g.sb.write_string(',.arg = ')
    g.write_orm_v_string_c_expr(arg_expr)
    g.sb.write_string(',.kind = ')
    g.sb.write_string(orm_ident_c_expr(kind_expr) or { return })
    g.sb.write_string('})')
}

fn orm_init_expr(expr ast.Expr) ?ast.InitExpr {
    match expr {
        ast.InitExpr {
            return expr
        }
        ast.ParenExpr {
            return orm_init_expr(expr.expr)
        }
        else {}
    }

    return none
}

fn orm_array_init_expr(expr ast.Expr) ?ast.ArrayInitExpr {
    match expr {
        ast.ArrayInitExpr {
            return expr
        }
        ast.CallExpr {
            name := orm_call_name(expr.lhs)
            if name in ['builtin__new_array_from_c_array_noscan', 'builtin__new_array_from_c_array', 'new_array_from_c_array']
                && expr.args.len >= 4 {
                return orm_array_init_expr(expr.args[3])
            }
        }
        ast.PrefixExpr {
            if expr.op == .amp {
                return orm_array_init_expr(expr.expr)
            }
        }
        ast.ParenExpr {
            return orm_array_init_expr(expr.expr)
        }
        else {}
    }

    return none
}

fn orm_call_name(lhs ast.Expr) string {
    match lhs {
        ast.Ident {
            return lhs.name
        }
        ast.SelectorExpr {
            if lhs.lhs is ast.Ident {
                left := lhs.lhs as ast.Ident
                return '${left.name}__${lhs.rhs.name}'
            }
        }
        else {}
    }

    return ''
}

fn orm_init_field_value(init ast.InitExpr, name string) ?ast.Expr {
    for field in init.fields {
        if field.name == name {
            return field.value
        }
    }
    return none
}

fn (mut g Gen) write_orm_v_string_c_expr(expr ast.Expr) {
    raw := orm_string_value(expr) or { return }
    g.sb.write_string(c_static_v_string_expr_from_c_literal(c_string_literal_content_to_c(raw)))
}

fn orm_string_value(expr ast.Expr) ?string {
    match expr {
        ast.StringLiteral {
            mut val := strip_literal_quotes(expr.value)
            if expr.kind == .raw {
                val = val.replace('\\', '\\\\')
            } else {
                val = process_line_continuations(val)
            }
            return val
        }
        ast.BasicLiteral {
            if expr.kind == .string {
                return process_line_continuations(strip_literal_quotes(expr.value))
            }
        }
        else {}
    }

    return none
}

fn orm_bool_c_expr(expr ast.Expr) ?string {
    match expr {
        ast.BasicLiteral {
            if expr.kind == .key_true || expr.value == 'true' {
                return 'true'
            }
            if expr.kind == .key_false || expr.value == 'false' {
                return 'false'
            }
        }
        ast.Ident {
            if expr.name == 'true' || expr.name == 'false' {
                return expr.name
            }
        }
        else {}
    }

    return none
}

fn orm_number_c_expr(expr ast.Expr) ?string {
    match expr {
        ast.BasicLiteral {
            return sanitize_c_number_literal(expr.value)
        }
        ast.PrefixExpr {
            if expr.op == .minus && expr.expr is ast.BasicLiteral {
                inner := expr.expr as ast.BasicLiteral
                return '-' + sanitize_c_number_literal(inner.value)
            }
        }
        else {}
    }

    return none
}

fn orm_ident_c_expr(expr ast.Expr) ?string {
    match expr {
        ast.Ident {
            return expr.name
        }
        ast.SelectorExpr {
            if expr.lhs is ast.Ident {
                left := expr.lhs as ast.Ident
                return '${left.name}__${expr.rhs.name}'
            }
        }
        else {}
    }

    return none
}