// 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.token
import v2.types

fn (mut t Transformer) transform_sql_expr(expr ast.SqlExpr) ast.Expr {
    if !expr.is_create {
        return ast.Expr(ast.SqlExpr{
            expr:       t.transform_expr(expr.expr)
            table_name: expr.table_name
            is_count:   expr.is_count
            is_create:  expr.is_create
            pos:        expr.pos
        })
    }
    if lowered := t.lower_sql_create_expr(expr) {
        return lowered
    }
    return ast.Expr(ast.SqlExpr{
        expr:       t.transform_expr(expr.expr)
        table_name: expr.table_name
        is_count:   expr.is_count
        is_create:  expr.is_create
        pos:        expr.pos
    })
}

fn (mut t Transformer) lower_sql_create_expr(expr ast.SqlExpr) ?ast.Expr {
    table := t.lookup_sql_table_struct(expr.table_name) or { return none }
    call_pos := t.next_synth_pos()
    call := ast.Expr(ast.CallExpr{
        lhs:  ast.Expr(ast.SelectorExpr{
            lhs: expr.expr
            rhs: ast.Ident{
                name: 'create'
                pos:  call_pos
            }
            pos: call_pos
        })
        args: [
            t.sql_orm_table_expr(table.name, expr.pos),
            t.sql_orm_table_fields_expr(table.fields, expr.pos),
        ]
        pos:  call_pos
    })
    t.register_synth_type(call_pos, types.Type(types.ResultType{
        base_type: types.Type(types.void_)
    }))
    return t.transform_expr(call)
}

fn (t &Transformer) lookup_sql_table_struct(name string) ?types.Struct {
    if typ := t.lookup_type(name) {
        base := t.sql_unwrap_alias_pointer_type(typ)
        if base is types.Struct {
            return base
        }
    }
    return t.lookup_struct_type_any_module(name)
}

fn (t &Transformer) sql_unwrap_alias_pointer_type(typ types.Type) types.Type {
    mut cur := typ
    for {
        match cur {
            types.Alias {
                cur = cur.base_type
                continue
            }
            types.Pointer {
                cur = cur.base_type
                continue
            }
            else {}
        }

        break
    }
    return cur
}

fn (mut t Transformer) sql_orm_table_expr(type_name string, pos token.Pos) ast.Expr {
    init_pos := t.next_synth_pos()
    return ast.Expr(ast.InitExpr{
        typ:    t.sql_orm_type_expr('Table', pos)
        fields: [
            ast.FieldInit{
                name:  'name'
                value: t.sql_string_expr(type_name.to_lower(), pos)
            },
            ast.FieldInit{
                name:  'attrs'
                value: t.sql_vattribute_array_expr([], pos)
            },
        ]
        pos:    init_pos
    })
}

fn (mut t Transformer) sql_orm_table_fields_expr(fields []types.Field, pos token.Pos) ast.Expr {
    mut exprs := []ast.Expr{cap: fields.len}
    for field in fields {
        if field_expr := t.sql_orm_table_field_expr(field, pos) {
            exprs << field_expr
        }
    }
    array_pos := t.next_synth_pos()
    return ast.Expr(ast.ArrayInitExpr{
        typ:   ast.Expr(ast.Type(ast.ArrayType{
            elem_type: t.sql_orm_type_expr('TableField', pos)
        }))
        exprs: exprs
        pos:   array_pos
    })
}

fn (mut t Transformer) sql_orm_table_field_expr(field types.Field, pos token.Pos) ?ast.Expr {
    if sql_field_is_skipped(field.attributes) {
        return none
    }
    field_type, nullable, is_arr := t.sql_field_storage_type(field.typ)
    init_pos := t.next_synth_pos()
    return ast.Expr(ast.InitExpr{
        typ:    t.sql_orm_type_expr('TableField', pos)
        fields: [
            ast.FieldInit{
                name:  'name'
                value: t.sql_string_expr(field.name, pos)
            },
            ast.FieldInit{
                name:  'typ'
                value: t.sql_orm_type_idx_expr(field_type, pos)
            },
            ast.FieldInit{
                name:  'nullable'
                value: t.sql_bool_expr(nullable, pos)
            },
            ast.FieldInit{
                name:  'default_val'
                value: t.sql_string_expr('', pos)
            },
            ast.FieldInit{
                name:  'attrs'
                value: t.sql_vattribute_array_expr(field.attributes, pos)
            },
            ast.FieldInit{
                name:  'is_arr'
                value: t.sql_bool_expr(is_arr, pos)
            },
        ]
        pos:    init_pos
    })
}

fn (t &Transformer) sql_field_storage_type(typ types.Type) (types.Type, bool, bool) {
    mut cur := typ
    mut nullable := false
    mut is_arr := false
    for {
        match cur {
            types.OptionType {
                nullable = true
                cur = cur.base_type
                continue
            }
            types.Alias {
                cur = cur.base_type
                continue
            }
            types.Pointer {
                cur = cur.base_type
                continue
            }
            types.Array {
                is_arr = true
                cur = cur.elem_type
                continue
            }
            else {}
        }

        break
    }
    return cur, nullable, is_arr
}

fn (mut t Transformer) sql_orm_type_idx_expr(typ types.Type, pos token.Pos) ast.Expr {
    type_name := t.type_to_c_name(typ)
    if type_name == 'time__Time' || type_name == 'time.Time' {
        return t.sql_int_expr(-2, pos)
    }
    match typ {
        types.Enum {
            return t.sql_int_expr(-3, pos)
        }
        types.String {
            return t.sql_int_expr(typeof_type_idx('string'), pos)
        }
        types.Primitive {
            return t.sql_int_expr(typeof_type_idx(type_name), pos)
        }
        else {}
    }

    if type_name == 'string' {
        return t.sql_int_expr(typeof_type_idx('string'), pos)
    }
    return t.sql_int_expr(typeof_type_idx(type_name), pos)
}

fn sql_field_is_skipped(attrs []ast.Attribute) bool {
    if attrs.has('skip') {
        return true
    }
    for attr in attrs {
        if attr.name == 'sql' && sql_attribute_value_string(attr.value) == '-' {
            return true
        }
    }
    return false
}

fn (mut t Transformer) sql_vattribute_array_expr(attrs []ast.Attribute, pos token.Pos) ast.Expr {
    mut exprs := []ast.Expr{cap: attrs.len}
    for attr in attrs {
        if attr_expr := t.sql_vattribute_expr(attr, pos) {
            exprs << attr_expr
        }
    }
    array_pos := t.next_synth_pos()
    elem_pos := t.next_synth_pos()
    return ast.Expr(ast.ArrayInitExpr{
        typ:   ast.Expr(ast.Type(ast.ArrayType{
            elem_type: ast.Expr(ast.Ident{
                name: 'VAttribute'
                pos:  elem_pos
            })
        }))
        exprs: exprs
        pos:   array_pos
    })
}

fn (mut t Transformer) sql_vattribute_expr(attr ast.Attribute, pos token.Pos) ?ast.Expr {
    mut name := attr.name
    mut has_arg := attr.name != ''
    mut arg := ''
    mut kind := 'AttributeKind__plain'
    if name == '' {
        name = sql_attribute_value_string(attr.value)
        has_arg = false
        _, kind = sql_attribute_arg_and_kind(attr.value)
        if kind != 'AttributeKind__string' {
            kind = 'AttributeKind__plain'
        }
    } else {
        arg, kind = sql_attribute_arg_and_kind(attr.value)
    }
    if name == '' {
        return none
    }
    init_pos := t.next_synth_pos()
    typ_pos := t.next_synth_pos()
    kind_pos := t.next_synth_pos()
    return ast.Expr(ast.InitExpr{
        typ:    ast.Expr(ast.Ident{
            name: 'VAttribute'
            pos:  typ_pos
        })
        fields: [
            ast.FieldInit{
                name:  'name'
                value: t.sql_string_expr(name, pos)
            },
            ast.FieldInit{
                name:  'has_arg'
                value: t.sql_bool_expr(has_arg, pos)
            },
            ast.FieldInit{
                name:  'arg'
                value: t.sql_string_expr(arg, pos)
            },
            ast.FieldInit{
                name:  'kind'
                value: ast.Expr(ast.Ident{
                    name: kind
                    pos:  kind_pos
                })
            },
        ]
        pos:    init_pos
    })
}

fn sql_attribute_arg_and_kind(expr ast.Expr) (string, string) {
    match expr {
        ast.StringLiteral {
            return sql_unquote_literal(expr.value), 'AttributeKind__string'
        }
        ast.BasicLiteral {
            if expr.kind in [.key_true, .key_false] {
                return expr.value, 'AttributeKind__bool'
            }
            return expr.value, 'AttributeKind__number'
        }
        ast.Ident {
            kind := if expr.name in sql_plain_attribute_args {
                'AttributeKind__plain'
            } else {
                'AttributeKind__string'
            }
            return expr.name, kind
        }
        ast.PrefixExpr {
            if expr.op == .minus && expr.expr is ast.BasicLiteral {
                inner := expr.expr as ast.BasicLiteral
                return '-' + inner.value, 'AttributeKind__number'
            }
        }
        else {}
    }

    return expr.name(), 'AttributeKind__plain'
}

fn sql_attribute_value_string(expr ast.Expr) string {
    match expr {
        ast.StringLiteral {
            return sql_unquote_literal(expr.value)
        }
        ast.BasicLiteral {
            return expr.value
        }
        ast.Ident {
            return expr.name
        }
        ast.PrefixExpr {
            if expr.op == .minus && expr.expr is ast.BasicLiteral {
                inner := expr.expr as ast.BasicLiteral
                return '-' + inner.value
            }
        }
        else {}
    }

    return expr.name()
}

fn sql_unquote_literal(raw string) string {
    if raw.len < 2 {
        return raw
    }
    first := raw[0]
    last := raw[raw.len - 1]
    if first == last && first in [`'`, `"`] {
        return raw[1..raw.len - 1]
    }
    return raw
}

const sql_plain_attribute_args = ['serial', 'i8', 'i16', 'int', 'i64', 'u8', 'u16', 'u32', 'u64',
    'f32', 'f64', 'bool', 'string']

fn (mut t Transformer) sql_orm_type_expr(name string, pos token.Pos) ast.Expr {
    _ = pos
    expr_pos := t.next_synth_pos()
    lhs_pos := t.next_synth_pos()
    rhs_pos := t.next_synth_pos()
    return ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'orm'
            pos:  lhs_pos
        })
        rhs: ast.Ident{
            name: name
            pos:  rhs_pos
        }
        pos: expr_pos
    })
}

fn (mut t Transformer) sql_orm_const_expr(name string, pos token.Pos) ast.Expr {
    _ = pos
    expr_pos := t.next_synth_pos()
    lhs_pos := t.next_synth_pos()
    rhs_pos := t.next_synth_pos()
    return ast.Expr(ast.SelectorExpr{
        lhs: ast.Expr(ast.Ident{
            name: 'orm'
            pos:  lhs_pos
        })
        rhs: ast.Ident{
            name: name
            pos:  rhs_pos
        }
        pos: expr_pos
    })
}

fn (mut t Transformer) sql_string_expr(value string, pos token.Pos) ast.Expr {
    _ = pos
    lit_pos := t.next_synth_pos()
    return ast.Expr(ast.StringLiteral{
        kind:  .v
        value: value
        pos:   lit_pos
    })
}

fn (mut t Transformer) sql_int_expr(value int, pos token.Pos) ast.Expr {
    _ = pos
    lit_pos := t.next_synth_pos()
    return ast.Expr(ast.BasicLiteral{
        kind:  .number
        value: value.str()
        pos:   lit_pos
    })
}

fn (mut t Transformer) sql_bool_expr(value bool, pos token.Pos) ast.Expr {
    _ = pos
    lit_pos := t.next_synth_pos()
    return ast.Expr(ast.BasicLiteral{
        kind:  if value { token.Token.key_true } else { token.Token.key_false }
        value: if value { 'true' } else { 'false' }
        pos:   lit_pos
    })
}