const std = @import("std");
const logger = @import("../logger.zig");
const toml_lexer = @import("./toml_lexer.zig");
const Lexer = toml_lexer.Lexer;
const importRecord = @import("../import_record.zig");
const js_ast = @import("../js_ast.zig");
const options = @import("../options.zig");

const fs = @import("../fs.zig");
const bun = @import("../global.zig");
const string = bun.string;
const Output = bun.Output;
const Global = bun.Global;
const Environment = bun.Environment;
const strings = bun.strings;
const MutableString = bun.MutableString;
const stringZ = bun.stringZ;
const default_allocator = bun.default_allocator;
const C = bun.C;
const expect = std.testing.expect;
const ImportKind = importRecord.ImportKind;
const BindingNodeIndex = js_ast.BindingNodeIndex;

const StmtNodeIndex = js_ast.StmtNodeIndex;
const ExprNodeIndex = js_ast.ExprNodeIndex;
const ExprNodeList = js_ast.ExprNodeList;
const StmtNodeList = js_ast.StmtNodeList;
const BindingNodeList = js_ast.BindingNodeList;
const assert = std.debug.assert;

const LocRef = js_ast.LocRef;
const S = js_ast.S;
const B = js_ast.B;
const G = js_ast.G;
const T = toml_lexer.T;
const E = js_ast.E;
const Stmt = js_ast.Stmt;
const Expr = js_ast.Expr;
const Binding = js_ast.Binding;
const Symbol = js_ast.Symbol;
const Level = js_ast.Op.Level;
const Op = js_ast.Op;
const Scope = js_ast.Scope;
const locModuleScope = logger.Loc.Empty;

const LEXER_DEBUGGER_WORKAROUND = false;
const IdentityContext = @import("../identity_context.zig").IdentityContext;

const HashMapPool = struct {
    const HashMap = std.HashMap(u64, void, IdentityContext, 80);
    const LinkedList = std.SinglyLinkedList(HashMap);
    threadlocal var list: LinkedList = undefined;
    threadlocal var loaded: bool = false;

    pub fn get(_: std.mem.Allocator) *LinkedList.Node {
        if (loaded) {
            if (list.popFirst()) |node| {
                node.data.clearRetainingCapacity();
                return node;
            }
        }

        var new_node = default_allocator.create(LinkedList.Node) catch unreachable;
        new_node.* = LinkedList.Node{ .data = HashMap.initContext(default_allocator, IdentityContext{}) };
        return new_node;
    }

    pub fn release(node: *LinkedList.Node) void {
        if (loaded) {
            list.prepend(node);
            return;
        }

        list = LinkedList{ .first = node };
        loaded = true;
    }
};

pub const TOML = struct {
    lexer: Lexer,
    log: *logger.Log,
    allocator: std.mem.Allocator,

    pub fn init(allocator: std.mem.Allocator, source_: logger.Source, log: *logger.Log) !TOML {
        return TOML{
            .lexer = try Lexer.init(log, source_, allocator),
            .allocator = allocator,
            .log = log,
        };
    }

    pub inline fn source(p: *const TOML) *const logger.Source {
        return &p.lexer.source;
    }

    pub fn e(_: *TOML, t: anytype, loc: logger.Loc) Expr {
        const Type = @TypeOf(t);
        if (@typeInfo(Type) == .Pointer) {
            return Expr.init(std.meta.Child(Type), t.*, loc);
        } else {
            return Expr.init(Type, t, loc);
        }
    }

    const Rope = js_ast.E.Object.Rope;

    pub fn parseKeySegment(p: *TOML) anyerror!?Expr {
        const loc = p.lexer.loc();

        switch (p.lexer.token) {
            .t_string_literal => {
                const str = p.lexer.toEString();
                try p.lexer.next();
                return p.e(str, loc);
            },
            .t_identifier => {
                const str = E.String{ .utf8 = p.lexer.identifier };
                try p.lexer.next();
                return p.e(str, loc);
            },
            .t_false => {
                try p.lexer.next();
                return p.e(
                    E.String{
                        .utf8 = "false",
                    },
                    loc,
                );
            },
            .t_true => {
                try p.lexer.next();
                return p.e(
                    E.String{
                        .utf8 = "true",
                    },
                    loc,
                );
            },
            // what we see as a number here could actually be a string
            .t_numeric_literal => {
                const literal = p.lexer.raw();
                try p.lexer.next();
                return p.e(E.String{ .utf8 = literal }, loc);
            },

            else => return null,
        }
    }

    pub fn parseKey(p: *TOML, allocator: std.mem.Allocator) anyerror!*Rope {
        var rope = try allocator.create(Rope);
        var head = rope;
        rope.* = .{
            .head = (try p.parseKeySegment()) orelse {
                try p.lexer.expectedString("key");
                return error.SyntaxError;
            },
            .next = null,
        };
        while (p.lexer.token == .t_dot) {
            try p.lexer.next();

            rope = try rope.append((try p.parseKeySegment()) orelse break, allocator);
        }

        return head;
    }

    pub fn parse(source_: *const logger.Source, log: *logger.Log, allocator: std.mem.Allocator) !Expr {
        switch (source_.contents.len) {
            // This is to be consisntent with how disabled JS files are handled
            0 => {
                return Expr{ .loc = logger.Loc{ .start = 0 }, .data = Expr.init(E.Object, E.Object{}, logger.Loc.Empty).data };
            },
            else => {},
        }

        var parser = try TOML.init(allocator, source_.*, log);

        return try parser.runParser();
    }

    fn runParser(p: *TOML) anyerror!Expr {
        var root = p.e(E.Object{}, p.lexer.loc());
        var head = root.data.e_object;

        var stack = std.heap.stackFallback(@sizeOf(Rope) * 6, p.allocator);
        var key_allocator = stack.get();

        while (true) {
            const loc = p.lexer.loc();
            switch (p.lexer.token) {
                .t_end_of_file => {
                    return root;
                },
                // child table
                .t_open_bracket => {
                    try p.lexer.next();
                    var key = try p.parseKey(key_allocator);

                    try p.lexer.expect(.t_close_bracket);
                    if (!p.lexer.has_newline_before) {
                        try p.lexer.expectedString("line break");
                    }

                    var parent_object = root.data.e_object.getOrPutObject(key, p.allocator) catch |err| {
                        switch (err) {
                            error.Clobber => {
                                try p.lexer.addDefaultError("Table already defined");
                                return error.SyntaxError;
                            },
                            else => return err,
                        }
                    };
                    head = parent_object.data.e_object;
                    stack.fixed_buffer_allocator.reset();
                },
                // child table array
                .t_open_bracket_double => {
                    try p.lexer.next();

                    var key = try p.parseKey(key_allocator);

                    try p.lexer.expect(.t_close_bracket_double);
                    if (!p.lexer.has_newline_before) {
                        try p.lexer.expectedString("line break");
                    }

                    var array = root.data.e_object.getOrPutArray(key, p.allocator) catch |err| {
                        switch (err) {
                            error.Clobber => {
                                try p.lexer.addDefaultError("Cannot overwrite table array");
                                return error.SyntaxError;
                            },
                            else => return err,
                        }
                    };
                    var new_head = p.e(E.Object{}, loc);
                    try array.data.e_array.push(p.allocator, new_head);
                    head = new_head.data.e_object;
                    stack.fixed_buffer_allocator.reset();
                },
                else => {
                    try p.parseAssignment(head, key_allocator);
                    stack.fixed_buffer_allocator.reset();
                },
            }
        }
    }

    pub fn parseAssignment(p: *TOML, obj: *E.Object, allocator: std.mem.Allocator) anyerror!void {
        p.lexer.allow_double_bracket = false;
        var rope = try p.parseKey(allocator);

        const is_array = p.lexer.token == .t_empty_array;
        if (is_array) {
            try p.lexer.next();
        }

        try p.lexer.expectAssignment();
        if (!is_array) {
            obj.setRope(rope, p.allocator, try p.parseValue()) catch |err| {
                switch (err) {
                    error.Clobber => {
                        try p.lexer.addDefaultError("Cannot redefine key");
                        return error.SyntaxError;
                    },
                    else => return err,
                }
            };
        } else {}
        p.lexer.allow_double_bracket = true;
    }

    pub fn parseValue(p: *TOML) anyerror!Expr {
        const loc = p.lexer.loc();

        p.lexer.allow_double_bracket = true;

        switch (p.lexer.token) {
            .t_false => {
                try p.lexer.next();

                return p.e(E.Boolean{
                    .value = false,
                }, loc);
            },
            .t_true => {
                try p.lexer.next();
                return p.e(E.Boolean{
                    .value = true,
                }, loc);
            },
            .t_string_literal => {
                var str: E.String = p.lexer.toEString();

                try p.lexer.next();
                return p.e(str, loc);
            },
            .t_identifier => {
                var str: E.String = E.String{ .utf8 = p.lexer.identifier };

                try p.lexer.next();
                return p.e(str, loc);
            },
            .t_numeric_literal => {
                const value = p.lexer.number;
                try p.lexer.next();
                return p.e(E.Number{ .value = value }, loc);
            },
            .t_minus => {
                try p.lexer.next();
                const value = p.lexer.number;

                try p.lexer.expect(.t_numeric_literal);
                return p.e(E.Number{ .value = -value }, loc);
            },
            .t_plus => {
                try p.lexer.next();
                const value = p.lexer.number;

                try p.lexer.expect(.t_numeric_literal);
                return p.e(E.Number{ .value = value }, loc);
            },
            .t_open_brace => {
                try p.lexer.next();
                var is_single_line = !p.lexer.has_newline_before;
                var properties = std.ArrayList(G.Property).init(p.allocator);
                var stack = std.heap.stackFallback(@sizeOf(Rope) * 6, p.allocator);
                var key_allocator = stack.get();
                var expr = p.e(E.Object{}, loc);
                var obj = expr.data.e_object;

                while (p.lexer.token != .t_close_brace) {
                    if (properties.items.len > 0) {
                        if (p.lexer.has_newline_before) {
                            is_single_line = false;
                        }
                        if (!try p.parseMaybeTrailingComma(.t_close_brace)) {
                            break;
                        }
                        if (p.lexer.has_newline_before) {
                            is_single_line = false;
                        }
                    }
                    try p.parseAssignment(obj, key_allocator);
                    p.lexer.allow_double_bracket = false;
                    stack.fixed_buffer_allocator.reset();
                }

                if (p.lexer.has_newline_before) {
                    is_single_line = false;
                }
                try p.lexer.expect(.t_close_brace);
                return expr;
            },
            .t_empty_array => {
                try p.lexer.next();
                p.lexer.allow_double_bracket = true;
                return p.e(E.Array{}, loc);
            },
            .t_open_bracket => {
                try p.lexer.next();
                var is_single_line = !p.lexer.has_newline_before;
                var array_ = p.e(E.Array{}, loc);
                var array = array_.data.e_array;
                const allocator = p.allocator;
                p.lexer.allow_double_bracket = false;

                while (p.lexer.token != .t_close_bracket) {
                    if (array.items.len > 0) {
                        if (p.lexer.has_newline_before) {
                            is_single_line = false;
                        }

                        if (!try p.parseMaybeTrailingComma(.t_close_bracket)) {
                            break;
                        }

                        if (p.lexer.has_newline_before) {
                            is_single_line = false;
                        }
                    }

                    array.push(allocator, try p.parseValue()) catch unreachable;
                }

                if (p.lexer.has_newline_before) {
                    is_single_line = false;
                }
                try p.lexer.expect(.t_close_bracket);
                p.lexer.allow_double_bracket = true;
                return array_;
            },
            else => {
                try p.lexer.unexpected();
                return error.SyntaxError;
            },
        }
    }

    pub fn parseMaybeTrailingComma(p: *TOML, closer: T) !bool {
        try p.lexer.expect(.t_comma);

        if (p.lexer.token == closer) {
            return false;
        }

        return true;
    }
};
option value='framework-agnostic-astro-components'>framework-agnostic-astro-components</option>
<option value='fryuni/db-pluggable-backend'>fryuni/db-pluggable-backend</option>
<option value='fryuni/test-route-setup-hook'>fryuni/test-route-setup-hook</option>
<option value='fryuni/tracing-hooks'>fryuni/tracing-hooks</option>
<option value='hippotastic/legitimate-bat'>hippotastic/legitimate-bat</option>
<option value='hoisted-script-ts'>hoisted-script-ts</option>
<option value='host-ssr-example-2'>host-ssr-example-2</option>
<option value='hostfornode'>hostfornode</option>
<option value='image-non-node'>image-non-node</option>
<option value='improve-base-handling'>improve-base-handling</option>
<option value='inline-hoisted-scripts-now'>inline-hoisted-scripts-now</option>
<option value='jn.convert-assertions-to-query-params'>jn.convert-assertions-to-query-params</option>
<option value='latest'>latest</option>
<option value='live-loaders'>live-loaders</option>
<option value='main'>main</option>
<option value='mandar1jn/ci-repo-check'>mandar1jn/ci-repo-check</option>
<option value='markdoc-embed-prototyping'>markdoc-embed-prototyping</option>
<option value='markdown'>markdown</option>
<option value='markdown-poc'>markdown-poc</option>
<option value='mdx-path'>mdx-path</option>
<option value='mk/render-slot-template-backup'>mk/render-slot-template-backup</option>
<option value='move-default-md-code-component'>move-default-md-code-component</option>
<option value='mt/lit-DSD'>mt/lit-DSD</option>
<option value='mt/lit-regen'>mt/lit-regen</option>
<option value='mt/parse-DSD'>mt/parse-DSD</option>
<option value='mt/router_refactoring'>mt/router_refactoring</option>
<option value='nate/new-blog-template'>nate/new-blog-template</option>
<option value='netlify-1'>netlify-1</option>
<option value='netlify-preview'>netlify-preview</option>
<option value='new-adapter-api'>new-adapter-api</option>
<option value='next'>next</option>
<option value='next-render'>next-render</option>
<option value='no-more-vite-postprocess'>no-more-vite-postprocess</option>
<option value='no-more-vite-postprocess2'>no-more-vite-postprocess2</option>
<option value='old-build'>old-build</option>
<option value='plt-1006/unified-and-mdx'>plt-1006/unified-and-mdx</option>
<option value='plt-1768-trailing-slash-object'>plt-1768-trailing-slash-object</option>
<option value='preact-shared-signals'>preact-shared-signals</option>
<option value='process-env-override'>process-env-override</option>
<option value='progress-log'>progress-log</option>
<option value='re-export-drivers'>re-export-drivers</option>
<option value='react-fast-refresh'>react-fast-refresh</option>
<option value='redirects-priority2'>redirects-priority2</option>
<option value='redirects-ssg-object'>redirects-ssg-object</option>
<option value='refactor-how-client-directives-work'>refactor-how-client-directives-work</option>
<option value='refactor/image-internals'>refactor/image-internals</option>
<option value='refactor/markdoc-renderer'>refactor/markdoc-renderer</option>
<option value='refactor/rendere-queue'>refactor/rendere-queue</option>
<option value='refactor/sitemap'>refactor/sitemap</option>
<option value='refactor/ssr-size'>refactor/ssr-size</option>
<option value='release/0.17'>release/0.17</option>
<option value='release/0.18'>release/0.18</option>
<option value='remote-cdn-link'>remote-cdn-link</option>
<option value='remove-fs-abstraction'>remove-fs-abstraction</option>
<option value='remove-start'>remove-start</option>
<option value='restart-on-lock'>restart-on-lock</option>
<option value='revert-13008-renovate/all-minor-patch'>revert-13008-renovate/all-minor-patch</option>
<option value='revert-lockfile'>revert-lockfile</option>
<option value='route-manifest-adapter'>route-manifest-adapter</option>
<option value='sarah11918-image-errors'>sarah11918-image-errors</option>
<option value='sarah11918-patch-2'>sarah11918-patch-2</option>
<option value='sb-tests2'>sb-tests2</option>
<option value='seroval'>seroval</option>
<option value='server-islands-children'>server-islands-children</option>
<option value='session-docs'>session-docs</option>
<option value='single-file-build-2'>single-file-build-2</option>
<option value='slash-404-hint'>slash-404-hint</option>
<option value='slot-bug-1'>slot-bug-1</option>
<option value='solid-ecosystem-pkg'>solid-ecosystem-pkg</option>
<option value='spike/app-setup'>spike/app-setup</option>
<option value='spike/autonav'>spike/autonav</option>
<option value='spike/codehike'>spike/codehike</option>
<option value='spike/context'>spike/context</option>
<option value='spike/csr'>spike/csr</option>
<option value='spike/default-content'>spike/default-content</option>
<option value='spike/incremental'>spike/incremental</option>
<option value='spike/incremental-ii'>spike/incremental-ii</option>
<option value='spike/markdown-wasm'>spike/markdown-wasm</option>
<option value='spike/render'>spike/render</option>
<option value='spike/streaming'>spike/streaming</option>
<option value='spike/svg'>spike/svg</option>
<option value='sqlite-test'>sqlite-test</option>
<option value='squeal'>squeal</option>
<option value='ssr-redirect'>ssr-redirect</option>
<option value='stream-buffer'>stream-buffer</option>
<option value='streaming'>streaming</option>
<option value='telemetry-audit-1'>telemetry-audit-1</option>
<option value='test/new-integrations-demo'>test/new-integrations-demo</option>
<option value='test/new-ssr-demo'>test/new-ssr-demo</option>
<option value='top-level-exports-integrations'>top-level-exports-integrations</option>
<option value='ts-in-hoisted-script'>ts-in-hoisted-script</option>
<option value='ts-no-err'>ts-no-err</option>
<option value='upd-vite-vendored'>upd-vite-vendored</option>
<option value='upgrade-deps'>upgrade-deps</option>
<option value='v1-beta'>v1-beta</option>
<option value='vercel-test'>vercel-test</option>
<option value='vite-fork'>vite-fork</option>
<option value='vscode-astro-global'>vscode-astro-global</option>
<option value='vt-follow-redirects'>vt-follow-redirects</option>
<option value='warn-exp-flag'>warn-exp-flag</option>
<option value='win'>win</option>
<option value='windows-tests-beta'>windows-tests-beta</option>
<option value='wip-assets'>wip-assets</option>
<option value='wip-component-api-2'>wip-component-api-2</option>
<option value='wip-docs-components'>wip-docs-components</option>
<option value='wip-docs-reference-gen'>wip-docs-reference-gen</option>
<option value='wip-fetch-cache'>wip-fetch-cache</option>
<option value='wip-fun-flags'>wip-fun-flags</option>
<option value='wip-icons'>wip-icons</option>
<option value='wip-logging'>wip-logging</option>
<option value='wip-logging-saved'>wip-logging-saved</option>
<option value='wip-mdc'>wip-mdc</option>
<option value='wip-mdx-to-astro-js'>wip-mdx-to-astro-js</option>
<option value='wip-preview-command-integrations'>wip-preview-command-integrations</option>
<option value='wip-setup-content'>wip-setup-content</option>
<option value='wip-smoke'>wip-smoke</option>
<option value='wip-speed-up-markdown'>wip-speed-up-markdown</option>
<option value='wip-stage'>wip-stage</option>
<option value='wip/react-19-test'>wip/react-19-test</option>
</select> <input type='submit' value='switch'/></form></td></tr>
<tr><td class='sub'>Unnamed repository; edit this file 'description' to name the repository.</td><td class='sub right'></td></tr></table>
<table class='tabs'><tr><td>
<a href='/ansg191/astro/about/?h=fix-s-island-fallback'>about</a><a href='/ansg191/astro/?h=fix-s-island-fallback'>summary</a><a href='/ansg191/astro/refs/?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21'>refs</a><a class='active' href='/ansg191/astro/log/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;follow=1'>log</a><a href='/ansg191/astro/tree/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21'>tree</a><a href='/ansg191/astro/commit/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>commit</a><a href='/ansg191/astro/diff/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>diff</a></td><td class='form'><form class='right' method='get' action='/ansg191/astro/log/packages/astro/components/Debug.astro'>
<input type='hidden' name='h' value='fix-s-island-fallback'/><input type='hidden' name='id' value='6fe1b0279fce5a7a0e90ff79746ea0b641da3e21'/><select name='qt'>
<option value='grep'>log msg</option>
<option value='author'>author</option>
<option value='committer'>committer</option>
<option value='range'>range</option>
</select>
<input class='txt' type='search' size='10' name='q' value=''/>
<input type='submit' value='search'/>
</form>
</td></tr></table>
<div class='path'>path: <a href='/ansg191/astro/log/?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>root</a>/<a href='/ansg191/astro/log/packages?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>packages</a>/<a href='/ansg191/astro/log/packages/astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>astro</a>/<a href='/ansg191/astro/log/packages/astro/components?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>components</a>/<a href='/ansg191/astro/log/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;follow=1'>Debug.astro</a> (<a href='/ansg191/astro/log/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21'>unfollow</a>)</div><div class='content'><table class='list nowrap'><tr class='nohover'><th class='left'>Age</th><th class='left'>Commit message (<a href='/ansg191/astro/log/packages/astro/components/Debug.astro?h=fix-s-island-fallback&amp;id=6fe1b0279fce5a7a0e90ff79746ea0b641da3e21&amp;showmsg=1&amp;follow=1'>Expand</a>)</th><th class='left'>Author</th><th class='left'>Files</th><th class='left'>Lines</th></tr>
<tr><td><span title='2022-01-31 16:13:22 -0600'>2022-01-31</span></td><td><a href='/ansg191/astro/commit/yarn.lock?h=fix-s-island-fallback&amp;id=618a16f59d4037cff1665110f0ed111a96a96437&amp;follow=1'>Deprecate unescaped HTML inside of expressions (#2489)</a></td><td><img src='//www.gravatar.com/avatar/0ddf46bee0fb93b8d73cb82456ee5b28?s=13&amp;d=retro' width='13' height='13' alt='Gravatar' /> Nate Moore
</td><td>9</td><td><span class='deletions'>-31</span>/<span class='insertions'>+74</span></td></tr>