#include <catch2/catch_all.hpp>
#include "utils/command_parser.hpp"

TEST_CASE("Parser tests", "[parser]") {
  SECTION("Fixed word pattern") {
    Parser parser;
    bool callbackCalled = false;

    parser.AddRule(
        MakePattern({"command"}),
        [&callbackCalled](const std::vector<std::string>& args) { callbackCalled = true; });

    const char* argv1[] = {"./program", "command"};
    parser.Parse(2, const_cast<char**>(argv1));
    REQUIRE(callbackCalled);
  }

  SECTION("Any word pattern") {
    Parser parser;
    bool callbackCalled = false;

    parser.AddRule(
        MakePattern({"command", PatternType::AnyWord}),
        [&callbackCalled](const std::vector<std::string>& args) { callbackCalled = true; });

    const char* argv2[] = {"./program", "command", "any_word"};
    parser.Parse(3, const_cast<char**>(argv2));
    REQUIRE(callbackCalled);
  }

  SECTION("Any words pattern") {
    Parser parser;
    bool callbackCalled = false;

    parser.AddRule(
        MakePattern({"command", PatternType::AnyWords}),
        [&callbackCalled](const std::vector<std::string>& args) { callbackCalled = true; });

    const char* argv3[] = {"./program", "command", "word1", "word2", "word3"};
    parser.Parse(5, const_cast<char**>(argv3));
    REQUIRE(callbackCalled);
  }

  SECTION("Mixed pattern") {
    Parser parser;
    bool callbackCalled = false;

    parser.AddRule(
        MakePattern({"command", PatternType::AnyWord, "option", PatternType::AnyWords}),
        [&callbackCalled](const std::vector<std::string>& args) { callbackCalled = true; });

    const char* argv4[] = {"./program", "command", "any_word", "option", "word1", "word2", "word3"};
    parser.Parse(7, const_cast<char**>(argv4));
    REQUIRE(callbackCalled);
  }

  SECTION("Non-matching pattern") {
    Parser parser;
    bool callbackCalled = false;

    parser.AddRule(
        MakePattern({"command", "option", PatternType::AnyWords}),
        [&callbackCalled](const std::vector<std::string>& args) { callbackCalled = true; });

    const char* argv5[] = {"./program", "other_command", "option", "word1", "word2", "word3"};
    parser.Parse(6, const_cast<char**>(argv5));
    REQUIRE(!callbackCalled);
  }

  SECTION("Multiple rules with different matches") {
    Parser parser;
    bool callbackCalled1 = false;
    bool callbackCalled2 = false;

    parser.AddRule(
        MakePattern({"command1", PatternType::AnyWords}),
        [&callbackCalled1](const std::vector<std::string>& args) { callbackCalled1 = true; });

    parser.AddRule(
        MakePattern({"command2", PatternType::AnyWords}),
        [&callbackCalled2](const std::vector<std::string>& args) { callbackCalled2 = true; });

    const char* argv6[] = {"./program", "command1", "word1", "word2", "word3"};
    parser.Parse(5, const_cast<char**>(argv6));
    REQUIRE(callbackCalled1);
    REQUIRE(!callbackCalled2);
    const char* argv7[] = {"./program", "command2", "word1", "word2", "word3"};
    parser.Parse(5, const_cast<char**>(argv7));
    REQUIRE(callbackCalled2);
  }

  SECTION("No matching rule") {
    Parser parser;
    bool callbackCalled = false;

    parser.AddRule(
        MakePattern({"command", "option", PatternType::AnyWords}),
        [&callbackCalled](const std::vector<std::string>& args) { callbackCalled = true; });

    const char* argv8[] = {"./program", "other_command", "other_option", "word1", "word2", "word3"};
    parser.Parse(6, const_cast<char**>(argv8));
    REQUIRE(!callbackCalled);
  }
}