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

import v2.token

fn field_flags_ident_expr(name string) Expr {
    return Expr(Ident{
        name: name
    })
}

fn field_flags_int_expr() Expr {
    return field_flags_ident_expr('int')
}

fn make_field_flags_file() File {
    return File{
        name:  'field_flags.v'
        mod:   'field_flags'
        stmts: [
            Stmt(ModuleStmt{
                name: 'field_flags'
            }),
            Stmt(StructDecl{
                name:   'Config'
                fields: [
                    FieldDecl{
                        name:      'public_value'
                        typ:       field_flags_int_expr()
                        is_public: true
                    },
                    FieldDecl{
                        name:   'mutable_value'
                        typ:    field_flags_int_expr()
                        is_mut: true
                    },
                    FieldDecl{
                        name:          'module_mut_value'
                        typ:           field_flags_int_expr()
                        is_module_mut: true
                    },
                ]
            }),
            Stmt(InterfaceDecl{
                name:   'Runner'
                fields: [
                    FieldDecl{
                        name:                'run'
                        typ:                 field_flags_int_expr()
                        is_interface_method: true
                    },
                ]
            }),
        ]
    }
}

fn test_field_decl_flags_survive_flat_roundtrip() {
    mut b := new_flat_builder()
    b.append_file(make_field_flags_file())
    files := b.flat.to_files()
    assert files.len == 1
    assert files[0].stmts.len == 3
    assert files[0].stmts[1] is StructDecl
    struct_decl := files[0].stmts[1] as StructDecl
    assert struct_decl.fields.len == 3
    assert struct_decl.fields[0].is_public
    assert !struct_decl.fields[0].is_mut
    assert !struct_decl.fields[0].is_module_mut
    assert !struct_decl.fields[0].is_interface_method
    assert !struct_decl.fields[1].is_public
    assert struct_decl.fields[1].is_mut
    assert !struct_decl.fields[1].is_module_mut
    assert !struct_decl.fields[1].is_interface_method
    assert !struct_decl.fields[2].is_public
    assert !struct_decl.fields[2].is_mut
    assert struct_decl.fields[2].is_module_mut
    assert !struct_decl.fields[2].is_interface_method
    assert files[0].stmts[2] is InterfaceDecl
    interface_decl := files[0].stmts[2] as InterfaceDecl
    assert interface_decl.fields.len == 1
    assert !interface_decl.fields[0].is_public
    assert !interface_decl.fields[0].is_mut
    assert !interface_decl.fields[0].is_module_mut
    assert interface_decl.fields[0].is_interface_method
}

fn test_global_decl_public_flag_survives_flat_roundtrip() {
    mut b := new_flat_builder()
    b.append_file(File{
        name:  'global_decl_public.v'
        mod:   'field_flags'
        stmts: [
            Stmt(ModuleStmt{
                name: 'field_flags'
            }),
            Stmt(GlobalDecl{
                is_public: true
                fields:    [
                    FieldDecl{
                        name: 'counter'
                        typ:  field_flags_int_expr()
                    },
                ]
            }),
        ]
    })
    files := b.flat.to_files()
    assert files[0].stmts.len == 2
    assert files[0].stmts[1] is GlobalDecl
    global_decl := files[0].stmts[1] as GlobalDecl
    assert global_decl.is_public
    assert global_decl.fields.len == 1
}

fn test_emit_field_decl_by_ids_preserves_field_flags() {
    field := FieldDecl{
        name:      'global_counter'
        typ:       field_flags_int_expr()
        is_public: true
        is_mut:    true
    }
    mut b := new_flat_builder()
    b.append_file(File{
        name:  'direct_field_flags.v'
        mod:   'field_flags'
        stmts: [
            Stmt(ModuleStmt{
                name: 'field_flags'
            }),
        ]
    })
    typ_id := b.emit_expr(field.typ)
    value_id := b.emit_expr(field.value)
    attrs_id := b.emit_attribute_list(field.attributes)
    field_id := b.emit_field_decl_by_ids(field, typ_id, value_id, attrs_id)
    fields_id := b.emit_aux_list_from_ids([field_id])
    decl_attrs_id := b.emit_attribute_list([])
    global_id := b.emit_global_decl_by_ids(true, decl_attrs_id, fields_id)
    b.append_file_stmts(0, [global_id])
    files := b.flat.to_files()
    assert files[0].stmts.len == 2
    assert files[0].stmts[1] is GlobalDecl
    global_decl := files[0].stmts[1] as GlobalDecl
    assert global_decl.is_public
    assert global_decl.fields.len == 1
    assert global_decl.fields[0].is_public
    assert global_decl.fields[0].is_mut
    assert !global_decl.fields[0].is_module_mut
    assert !global_decl.fields[0].is_interface_method
}

fn field_flags_array_update_from_stmt(stmt Stmt) ArrayInitExpr {
    assert stmt is ExprStmt
    expr_stmt := stmt as ExprStmt
    assert expr_stmt.expr is ArrayInitExpr
    return expr_stmt.expr as ArrayInitExpr
}

fn test_array_init_update_expr_survives_flat_roundtrip() {
    mut b := new_flat_builder()
    b.append_file(File{
        name:  'array_update_expr.v'
        mod:   'field_flags'
        stmts: [
            Stmt(ModuleStmt{
                name: 'field_flags'
            }),
            Stmt(ExprStmt{
                expr: Expr(ArrayInitExpr{
                    typ:         field_flags_int_expr()
                    update_expr: field_flags_ident_expr('base')
                    exprs:       [
                        field_flags_ident_expr('item'),
                    ]
                })
            }),
        ]
    })
    files := b.flat.to_files()
    assert files[0].stmts.len == 2
    array_expr := field_flags_array_update_from_stmt(files[0].stmts[1])
    assert array_expr.update_expr is Ident
    assert (array_expr.update_expr as Ident).name == 'base'
    assert array_expr.exprs.len == 1
    assert array_expr.exprs[0] is Ident
    assert (array_expr.exprs[0] as Ident).name == 'item'
}

fn test_emit_array_init_expr_by_ids_preserves_update_expr() {
    mut b := new_flat_builder()
    b.append_file(File{
        name:  'direct_array_update_expr.v'
        mod:   'field_flags'
        stmts: [
            Stmt(ModuleStmt{
                name: 'field_flags'
            }),
        ]
    })
    typ_id := b.emit_expr(field_flags_int_expr())
    init_id := b.emit_expr(empty_expr)
    cap_id := b.emit_expr(empty_expr)
    len_id := b.emit_expr(empty_expr)
    update_expr_id := b.emit_expr(field_flags_ident_expr('base'))
    elem_id := b.emit_expr(field_flags_ident_expr('item'))
    array_id := b.emit_array_init_expr_by_ids(typ_id, init_id, cap_id, len_id, update_expr_id, [
        elem_id,
    ], token.Pos{})
    stmt_id := b.emit_expr_stmt_by_id(array_id)
    b.append_file_stmts(0, [stmt_id])
    files := b.flat.to_files()
    assert files[0].stmts.len == 2
    array_expr := field_flags_array_update_from_stmt(files[0].stmts[1])
    assert array_expr.update_expr is Ident
    assert (array_expr.update_expr as Ident).name == 'base'
    assert array_expr.exprs.len == 1
    assert array_expr.exprs[0] is Ident
    assert (array_expr.exprs[0] as Ident).name == 'item'
}