import "@std/debug"
import "@std/mem"
import "@std/enums/enummap"

test import "@std/enums/enummap"
test import "@std/arraylist"
test import "@std/hashmap"
test import "@std/strmap"

import "@source/strpool"
import "@source/lexer"
import "@source/parser"
import "@source/ast"

test import "@source/strpool"
test import "@source/lexer"


program ::
    `# literals
    `x int :: 123.9
    `y :: "hello"

main proc() void {
    strpool.strings = strpool.init(mem.c_allocator)
    defer strpool.deinit(&strpool.strings)

    debug.print("PROGRAM::[[\n{}\n]]\n\n", {program})

    scan_state := lexer.init(mem.c_allocator)
    defer lexer.deinit(&scan_state)

    lexer.scan(&scan_state, program) catch |err| {
        debug.print("failed to scan: {}\n", {err})
        return
    }

    debug.print("TOKENS::[[\n", {})
    for scan_state.tokens.items |token| {
        debug.print("{}\n", {token.kind})
    }
    debug.print("]]\n\n", {})

    debug.print("TOKENS::DIAGNOSTICS::[[\n", {})
    for scan_state.diagnostics.items |diagnostic| {
        details :: enummap.get(&lexer.error_msg_map, diagnostic.code)
        debug.print("{}: {}\n", {details?.name, details?.message})
    }
    debug.print("]]\n\n", {})

    parse_state := parser.init(mem.c_allocator)
    defer parser.deinit(&parse_state)
    parser.parse(&parse_state, scan_state.tokens.items) catch |err| {
        debug.print("failed to parse: {}\n", {err})
        return
    }

    debug.print("AST::[[\n", {})
    for parse_state.nodes.items |node, id| {
        token :: scan_state.tokens.items[node.main_token]

        end :: if (token.kind == .int or token.kind == .float) lbl: {
            res :: lexer.scan_number(token.start, program) catch {
                yield :lbl token.start
            }
            yield :lbl res.end
        } else if (token.kind == .string) lbl: {
            res :: lexer.scan_string(token.start, program) catch {
                yield :lbl token.start
            }
            yield :lbl res.end
        } else token.start

        debug.print("{} (id = {}): {}\n", {
            node.kind,
            id,
            program[token.start..end],
            #node.data0,
            #node.data1,
        })
    }
    debug.print("]]\n\n", {})

    debug.print("AST Render::[[\n", {})
    literal :: ast.render_literal(
        &parse_state.nodes.items[1],
        scan_state.tokens.items,
        program,
    ) catch "<invalid>"
    
    debug.print("generated literal: {}\n", { literal })
    debug.print("]]\n", {})
}