// Unit tests for the brace-block reader. Every sample is hand-written.
#include <string>

#include "canon.h"
#include "mars/parse/blocks.h"
#include "test_main.h"

using namespace mars::parse;

namespace {

Document must_parse(std::string_view text, Options o = {}) {
    auto r = parse_blocks(text, o);
    if (!r.ok()) {
        std::printf("  unexpected parse error line %d: %s\n", r.error().line, r.error().message.c_str());
        CHECK(r.ok());
        return Document{};
    }
    return std::move(r).value();
}

std::string canon_of(std::string_view text, Options o = {}) {
    return canon::blocks_json(must_parse(text, o).root);
}

}  // namespace

TEST(basic_block_pairs_and_nesting) {
    Document d = must_parse(
        "weapon\n{\n\tname @WEAPON_X\n\tcost 50\n\tbank { mount { node N1 } }\n}\n");
    CHECK_EQ(d.root.entries.size(), std::size_t{1});
    const Node* w = d.root.first_block("weapon");
    CHECK(w != nullptr);
    CHECK_EQ(w->name, "weapon");
    CHECK_EQ(*w->first_value("name"), "@WEAPON_X");   // @TOKEN preserved verbatim
    CHECK_EQ(*w->first_value("cost"), "50");           // numbers kept as text
    const Node* mount = w->first_block("bank")->first_block("mount");
    CHECK(mount != nullptr);
    CHECK_EQ(*mount->first_value("node"), "N1");
    CHECK(d.warnings.empty());
    CHECK_EQ(canon_of("weapon { name @X cost 50 bank { mount { node N1 } } }"),
             R"({"weapon":{"bank":{"mount":{"node":"N1"}},"cost":50,"name":"@X"}})");
}

TEST(quoted_values_keep_spaces_backslashes_and_slashes) {
    Document d = must_parse(
        "a \"hello world\"\n"
        "b \"C:\\path\\to\\file.X\"\n"
        "c \"http://x//y\" // real comment\n"
        "d \"\"\n");
    CHECK_EQ(*d.root.first_value("a"), "hello world");
    CHECK_EQ(*d.root.first_value("b"), "C:\\path\\to\\file.X");
    CHECK_EQ(*d.root.first_value("c"), "http://x//y");
    CHECK_EQ(*d.root.first_value("d"), "");
    CHECK(d.root.first("a")->quoted);
    CHECK(d.root.first("d")->quoted);
    CHECK_EQ(d.root.entries.size(), std::size_t{4});
}

TEST(comments_are_stripped) {
    std::string s = canon_of("// leading\nx 1 // trailing\n//y 2\nz 3\n");
    CHECK_EQ(s, R"({"x":1,"z":3})");
    // '//' only starts a comment at a token boundary: glued to a bareword it is
    // part of the word (the reference reader behaves this way; the shipped data
    // never relies on either reading).
    CHECK_EQ(canon_of("z 3//glued\n"), R"({"z":"3//glued"})");
    CHECK_EQ(canon_of("z 3 //not glued\n"), R"({"z":3})");
}

TEST(repeated_keys_stay_in_order) {
    Document d = must_parse("t { requires A requires B other 1 requires C }");
    auto all = d.root.first_block("t")->all("requires");
    CHECK_EQ(all.size(), std::size_t{3});
    CHECK_EQ(all[0]->value, "A");
    CHECK_EQ(all[1]->value, "B");
    CHECK_EQ(all[2]->value, "C");
    CHECK_EQ(*d.root.first_block("t")->first_value("requires"), "A");
    CHECK_EQ(canon_of("t { requires A requires B other 1 requires C }"),
             R"({"t":{"other":1,"requires":["A","B","C"]}})");
}

TEST(keys_are_case_insensitive_but_case_is_kept) {
    Document d = must_parse("tech { Requires X requires Y Badge b }");
    const Node* t = d.root.first_block("TECH");
    CHECK(t != nullptr);
    CHECK_EQ(t->all("REQUIRES").size(), std::size_t{2});
    CHECK_EQ(t->first("badge")->key, "Badge");
    CHECK_EQ(canon_of("tech { Requires X requires Y }"), R"({"tech":{"requires":["X","Y"]}})");
}

TEST(bare_quoted_items_and_trailing_bareword) {
    Document d = must_parse("names { \"Sol\" \"Alpha Centauri\" }\nflags { on off }");
    auto items = d.root.first_block("names")->items();
    CHECK_EQ(items.size(), std::size_t{2});
    CHECK_EQ(std::string(items[1]), "Alpha Centauri");
    // "on off": 'on' takes 'off' as its value; nothing is left over.
    const Node* f = d.root.first_block("flags");
    CHECK_EQ(*f->first_value("on"), "off");
    // A lone word right before '}' is an item, not a key.
    Document e = must_parse("flags { a 1 solo }");
    CHECK_EQ(e.root.first_block("flags")->items().size(), std::size_t{1});
    CHECK_EQ(std::string(e.root.first_block("flags")->items()[0]), "solo");
    CHECK_EQ(canon_of("flags { a 1 solo }"), R"({"flags":{"_items":"solo","a":1}})");
    CHECK_EQ(canon_of("n { \"x\" \"y\" }"), R"({"n":{"_items":["x","y"]}})");
    // lone bareword at EOF, top level
    CHECK_EQ(canon_of("a 1 trailing"), R"({"_items":"trailing","a":1})");
}

TEST(option_scalar_and_block_share_a_key) {
    Document d = must_parse(
        "shipsection { option DRV_A option { option T1 option T2 } option DRV_B }");
    const Node* s = d.root.first_block("shipsection");
    auto all = s->all("option");
    CHECK_EQ(all.size(), std::size_t{3});
    CHECK(all[0]->is_pair());
    CHECK(all[1]->is_block());
    CHECK(all[2]->is_pair());
    CHECK_EQ(s->values("option").size(), std::size_t{2});
    CHECK_EQ(s->blocks("option").size(), std::size_t{1});
    CHECK_EQ(s->blocks("option")[0]->values("option").size(), std::size_t{2});
    CHECK_EQ(canon_of("s { option A option { option T1 option T2 } option B }"),
             R"({"s":{"option":["A",{"option":["T1","T2"]},"B"]}})");
}

TEST(tokenizer_is_not_line_based) {
    // block opens on the same line as a preceding pair; name glued to brace;
    // several entries per line; entries split across lines
    std::string s = canon_of(
        "bank { turretsize small   mount { node N }\n}\n"
        "weapon{ name\n\nX }\n"
        "a\n{\nb\n1\n}");
    CHECK_EQ(s, R"({"a":{"b":1},"bank":{"mount":{"node":"N"},"turretsize":"small"},"weapon":{"name":"X"}})");
}

TEST(braces_split_barewords) {
    CHECK_EQ(canon_of("a{b 1}c 2"), R"({"a":{"b":1},"c":2})");
}

TEST(quotes_split_barewords) {
    // abc"def" -> bareword abc, then quoted def (a pair abc="def")
    CHECK_EQ(canon_of("abc\"def\""), R"({"abc":"def"})");
}

TEST(eof_closes_open_blocks_lenient) {
    auto r = parse_blocks("shipsection {\n model M\n bank { mount { node N }\n");
    CHECK(r.ok());
    CHECK_EQ(r->warnings.size(), std::size_t{2});  // bank and shipsection both unclosed
    CHECK_EQ(r->warnings[0].line, 4);
    const Node* s = r->root.first_block("shipsection");
    CHECK(s != nullptr);
    CHECK_EQ(*s->first_value("model"), "M");
    CHECK_EQ(*s->first_block("bank")->first_block("mount")->first_value("node"), "N");
}

TEST(eof_inside_block_is_an_error_when_strict) {
    Options strict;
    strict.strict = true;
    auto r = parse_blocks("shipsection {\n model M\n", strict);
    CHECK(!r.ok());
    CHECK_EQ(r.error().line, 3);
}

TEST(stray_top_level_close_is_ignored_lenient) {
    auto r = parse_blocks("a { x 1 }\n}\nb { y 2 }\n");
    CHECK(r.ok());
    CHECK_EQ(r->warnings.size(), std::size_t{1});
    CHECK_EQ(r->warnings[0].line, 2);
    CHECK(r->root.first_block("a") != nullptr);
    CHECK(r->root.first_block("b") != nullptr);  // parsing continues after the stray brace
    CHECK_EQ(canon::blocks_json(r->root), R"({"a":{"x":1},"b":{"y":2}})");
}

TEST(stray_top_level_close_is_an_error_when_strict) {
    Options strict;
    strict.strict = true;
    auto r = parse_blocks("a { x 1 }\n}\n", strict);
    CHECK(!r.ok());
    CHECK_EQ(r.error().line, 2);
}

TEST(unterminated_string_is_always_an_error) {
    auto r = parse_blocks("a \"never closed\n b 1\n");
    CHECK(!r.ok());
    CHECK_EQ(r.error().line, 1);
    Options strict;
    strict.strict = true;
    CHECK(!parse_blocks("a \"never closed", strict).ok());
}

TEST(open_brace_without_name_is_always_an_error) {
    auto r = parse_blocks("a 1\n{ b 2 }");
    CHECK(!r.ok());
    CHECK_EQ(r.error().line, 2);
    // ... also when it follows a complete pair on the same line
    CHECK(!parse_blocks("a 1 { b 2 }").ok());
}

TEST(crlf_and_line_numbers) {
    Document d = must_parse("a 1\r\nb 2\r\n\r\nc { d 3 }\r\n");
    CHECK_EQ(d.root.first("a")->line, 1);
    CHECK_EQ(d.root.first("b")->line, 2);
    CHECK_EQ(d.root.first("c")->line, 4);
    CHECK_EQ(d.root.first_block("c")->first("d")->line, 4);
    CHECK_EQ(*d.root.first_value("b"), "2");  // no '\r' leaks into values
}

TEST(multiline_quoted_string_counts_lines) {
    Document d = must_parse("a \"line one\nline two\"\nb 2\n");
    CHECK_EQ(*d.root.first_value("a"), "line one\nline two");
    CHECK_EQ(d.root.first("b")->line, 3);
}

TEST(empty_and_comment_only_input) {
    Document d = must_parse("");
    CHECK(d.root.entries.empty());
    CHECK(d.warnings.empty());
    Document e = must_parse("  // nothing here\n\n");
    CHECK(e.root.entries.empty());
    CHECK_EQ(canon_of(""), "{}");
}

TEST(top_level_pairs_and_blocks_mix) {
    // scenario .txt shape: top-level pairs plus repeated player{} blocks
    std::string s = canon_of("name @S\nnumplayers \"8\"\nplayer { recommended 1 }\nplayer { recommended 2 }");
    CHECK_EQ(s, R"({"name":"@S","numplayers":"8","player":[{"recommended":1},{"recommended":2}]})");
}

TEST(numbers_are_typed_only_in_canonical_form_and_only_when_bare) {
    // The Node keeps raw text; the canonical form types barewords like the oracle
    std::string s = canon_of("i 7 f .5 e 7e+8 t TRUE q \"8\" n -.8 d 5.");
    CHECK_EQ(s, "{\"d\":\"\\u00015\",\"e\":\"\\u0001700000000\",\"f\":\"\\u00010.5\","
                "\"i\":7,\"n\":\"\\u0001-0.80000000000000004\",\"q\":\"8\",\"t\":true}");
}

TEST(high_bytes_pass_through) {
    std::string src = "a \"caf\xe9\"\nb na\xefve\n";
    Document d = must_parse(src);
    CHECK_EQ(*d.root.first_value("a"), "caf\xe9");
    CHECK_EQ(*d.root.first_value("b"), "na\xefve");
    CHECK_EQ(canon::blocks_json(d.root), R"({"a":"caf\u00e9","b":"na\u00efve"})");
}

TEST(deep_nesting_returns_to_the_right_parent) {
    Document d = must_parse("a { b { c { d 1 } e 2 } f 3 } g 4");
    const Node* a = d.root.first_block("a");
    CHECK_EQ(*a->first_block("b")->first_block("c")->first_value("d"), "1");
    CHECK_EQ(*a->first_block("b")->first_value("e"), "2");
    CHECK_EQ(*a->first_value("f"), "3");
    CHECK_EQ(*d.root.first_value("g"), "4");
    CHECK_EQ(a->first_block("b")->line, 1);
}

TEST(lookup_misses_return_null_or_empty) {
    Document d = must_parse("a 1");
    CHECK(d.root.first("zzz") == nullptr);
    CHECK(d.root.first_value("zzz") == nullptr);
    CHECK(d.root.first_block("a") == nullptr);   // a is a pair, not a block
    CHECK(d.root.all("zzz").empty());
    CHECK(!d.root.has("zzz"));
    CHECK(d.root.has("A"));
}