#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "commit_request.hpp"
#include <doctest/doctest.h>

TEST_CASE("CommitRequest basic parsing") {
  CommitRequest request;

  SUBCASE("Simple commit request") {
    std::string json = R"({
            "request_id": "test123",
            "leader_id": "leader456",
            "read_version": 12345
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.request_id().has_value());
    REQUIRE(request.request_id().value() == "test123");
    REQUIRE(request.leader_id() == "leader456");
    REQUIRE(request.read_version() == 12345);
  }

  SUBCASE("With preconditions") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "point_read",
                    "version": 12340,
                    "key": "dGVzdA=="
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.preconditions().size() == 1);
    REQUIRE(request.preconditions()[0].type == Precondition::Type::PointRead);
    REQUIRE(request.preconditions()[0].version == 12340);
    REQUIRE(request.preconditions()[0].begin == "test"); // "dGVzdA==" decoded
    REQUIRE(request.preconditions()[0].end == "");
  }

  SUBCASE("With operations") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "write",
                    "key": "dGVzdA==",
                    "value": "dmFsdWU="
                },
                {
                    "type": "delete",
                    "key": "dGVzdDI="
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.operations().size() == 2);

    REQUIRE(request.operations()[0].type == Operation::Type::Write);
    REQUIRE(request.operations()[0].param1 == "test");  // key
    REQUIRE(request.operations()[0].param2 == "value"); // value

    REQUIRE(request.operations()[1].type == Operation::Type::Delete);
    REQUIRE(request.operations()[1].param1 == "test2"); // key
    REQUIRE(request.operations()[1].param2 == "");      // unused for delete
  }

  SUBCASE("Invalid JSON") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": "not_a_number"
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Missing required leader_id") {
    std::string json = R"({
            "request_id": "test123",
            "read_version": 12345
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE_FALSE(request.is_parse_complete());
  }

  SUBCASE("Missing required read_version") {
    std::string json = R"({
            "request_id": "test123",
            "leader_id": "leader456"
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE_FALSE(request.is_parse_complete());
  }

  SUBCASE("Empty leader_id") {
    std::string json = R"({
            "request_id": "test123",
            "leader_id": "",
            "read_version": 12345
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE_FALSE(request.is_parse_complete());
  }

  SUBCASE("Missing both leader_id and read_version") {
    std::string json = R"({
            "request_id": "test123"
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE_FALSE(request.is_parse_complete());
  }

  SUBCASE("request_id is optional") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
    REQUIRE_FALSE(request.request_id().has_value());
    REQUIRE(request.leader_id() == "leader456");
    REQUIRE(request.read_version() == 12345);
  }
}

TEST_CASE("CommitRequest precondition and operation validation") {
  CommitRequest request;

  SUBCASE("Valid point_read precondition") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "point_read",
                    "key": "dGVzdA=="
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Invalid point_read precondition - missing key") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "point_read"
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Valid point_read precondition - empty key") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "point_read",
                    "key": ""
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Valid range_read precondition") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "range_read",
                    "version": 12340,
                    "begin": "dGVzdA==",
                    "end": "dGVzdFo="
                }
            ]
        })";

    bool parse_result =
        request.parse_json(const_cast<char *>(json.data()), json.size());
    INFO("Parse result: " << parse_result);
    INFO("Parse complete: " << request.is_parse_complete());
    INFO("Parse error: " << request.has_parse_error());
    const char *error_msg = request.get_parse_error();
    INFO("Parse error message: " << (error_msg ? std::string(error_msg)
                                               : "none"));
    INFO("Leader ID: '" << request.leader_id() << "'");
    INFO("Read version: " << request.read_version());

    REQUIRE(parse_result);
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Valid range_read precondition - empty begin/end") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "range_read",
                    "begin": "",
                    "end": ""
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Invalid range_read precondition - missing begin") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "range_read",
                    "end": "dGVzdFo="
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Invalid range_read precondition - missing end") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "preconditions": [
                {
                    "type": "range_read",
                    "begin": "dGVzdA=="
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Valid write operation") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "write",
                    "key": "dGVzdA==",
                    "value": "dmFsdWU="
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Valid write operation - empty key and value") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "write",
                    "key": "",
                    "value": ""
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Invalid write operation - missing key") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "write",
                    "value": "dmFsdWU="
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Invalid write operation - missing value") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "write",
                    "key": "dGVzdA=="
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Valid delete operation") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "delete",
                    "key": "dGVzdA=="
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Invalid delete operation - missing key") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "delete"
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Valid range_delete operation") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "range_delete",
                    "begin": "dGVzdA==",
                    "end": "dGVzdFo="
                }
            ]
        })";

    REQUIRE(request.parse_json(const_cast<char *>(json.data()), json.size()));
    REQUIRE(request.is_parse_complete());
  }

  SUBCASE("Invalid range_delete operation - missing begin") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "range_delete",
                    "end": "dGVzdFo="
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Invalid range_delete operation - missing end") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "range_delete",
                    "begin": "dGVzdA=="
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }

  SUBCASE("Mixed valid and invalid operations") {
    std::string json = R"({
            "leader_id": "leader456",
            "read_version": 12345,
            "operations": [
                {
                    "type": "write",
                    "key": "dGVzdA==",
                    "value": "dmFsdWU="
                },
                {
                    "type": "delete"
                }
            ]
        })";

    REQUIRE_FALSE(
        request.parse_json(const_cast<char *>(json.data()), json.size()));
  }
}

TEST_CASE("CommitRequest memory management") {
  CommitRequest request;

  std::string json = R"({
        "request_id": "test123",
        "leader_id": "leader456",
        "read_version": 12345,
        "operations": [
            {
                "type": "write",
                "key": "dGVzdA==",
                "value": "dmFsdWU="
            }
        ]
    })";

  REQUIRE(request.parse_json(json.data(), json.size()));

  // Check that arena allocation worked
  REQUIRE(request.total_allocated() > 0);
  REQUIRE(request.used_bytes() > 0);

  // Test reset
  request.reset();
  REQUIRE(request.request_id().has_value() == false);
  REQUIRE(request.leader_id().empty());
  REQUIRE(request.read_version() == 0);
  REQUIRE(request.operations().empty());
}

TEST_CASE("CommitRequest streaming parsing") {
  CommitRequest request;

  SUBCASE("Simple streaming parse") {
    std::string json = R"({
            "request_id": "test123",
            "leader_id": "leader456",
            "read_version": 12345
        })";

    REQUIRE(request.begin_streaming_parse());

    // Parse in small chunks to simulate network reception
    std::string mutable_json = json;
    size_t chunk_size = 10;
    size_t offset = 0;

    CommitRequest::ParseStatus status = CommitRequest::ParseStatus::Incomplete;

    while (offset < mutable_json.size() &&
           status == CommitRequest::ParseStatus::Incomplete) {
      size_t len = std::min(chunk_size, mutable_json.size() - offset);
      status = request.parse_chunk(mutable_json.data() + offset, len);
      offset += len;
    }

    if (status == CommitRequest::ParseStatus::Incomplete) {
      status = request.finish_streaming_parse();
    }

    REQUIRE(status == CommitRequest::ParseStatus::Complete);
    REQUIRE(request.is_parse_complete());
    REQUIRE_FALSE(request.has_parse_error());

    REQUIRE(request.request_id().has_value());
    REQUIRE(request.request_id().value() == "test123");
    REQUIRE(request.leader_id() == "leader456");
    REQUIRE(request.read_version() == 12345);
  }

  SUBCASE("Streaming parse with complex data") {
    std::string json = R"({
            "request_id": "streaming-test",
            "leader_id": "leader789",
            "read_version": 98765,
            "preconditions": [
                {
                    "type": "point_read",
                    "version": 98764,
                    "key": "dGVzdEtleQ=="
                }
            ],
            "operations": [
                {
                    "type": "write",
                    "key": "dGVzdEtleQ==",
                    "value": "dGVzdFZhbHVl"
                },
                {
                    "type": "delete",
                    "key": "ZGVsZXRlS2V5"
                }
            ]
        })";

    REQUIRE(request.begin_streaming_parse());

    // Parse one character at a time to really stress test streaming
    std::string mutable_json = json;
    CommitRequest::ParseStatus status = CommitRequest::ParseStatus::Incomplete;

    for (size_t i = 0; i < mutable_json.size() &&
                       status == CommitRequest::ParseStatus::Incomplete;
         ++i) {
      status = request.parse_chunk(mutable_json.data() + i, 1);
    }

    if (status == CommitRequest::ParseStatus::Incomplete) {
      status = request.finish_streaming_parse();
    }

    REQUIRE(status == CommitRequest::ParseStatus::Complete);
    REQUIRE(request.is_parse_complete());

    REQUIRE(request.request_id().value() == "streaming-test");
    REQUIRE(request.leader_id() == "leader789");
    REQUIRE(request.read_version() == 98765);
    REQUIRE(request.preconditions().size() == 1);
    REQUIRE(request.operations().size() == 2);

    // Verify precondition was parsed correctly
    REQUIRE(request.preconditions()[0].type == Precondition::Type::PointRead);
    REQUIRE(request.preconditions()[0].version == 98764);
    REQUIRE(request.preconditions()[0].begin ==
            "testKey"); // key stored in begin for point_read
    REQUIRE(request.preconditions()[0].end == "");

    // Verify operations were parsed correctly
    REQUIRE(request.operations()[0].type == Operation::Type::Write);
    REQUIRE(request.operations()[0].param1 == "testKey");   // key
    REQUIRE(request.operations()[0].param2 == "testValue"); // value

    REQUIRE(request.operations()[1].type == Operation::Type::Delete);
    REQUIRE(request.operations()[1].param1 == "deleteKey"); // key
    REQUIRE(request.operations()[1].param2 == "");          // unused for delete
  }

  SUBCASE("Streaming parse error handling") {
    std::string invalid_json = R"({
            "leader_id": "leader456",
            "read_version": "invalid_number"
        })";

    REQUIRE(request.begin_streaming_parse());

    std::string mutable_json = invalid_json;
    CommitRequest::ParseStatus status =
        request.parse_chunk(mutable_json.data(), mutable_json.size());

    if (status == CommitRequest::ParseStatus::Incomplete) {
      status = request.finish_streaming_parse();
    }

    REQUIRE(status == CommitRequest::ParseStatus::Error);
    REQUIRE(request.has_parse_error());
    REQUIRE_FALSE(request.is_parse_complete());
  }

  SUBCASE("Complete document in single chunk") {
    std::string json = R"({"leader_id": "test", "read_version": 123})";

    REQUIRE(request.begin_streaming_parse());

    std::string mutable_json = json;
    CommitRequest::ParseStatus status =
        request.parse_chunk(mutable_json.data(), mutable_json.size());

    // Should still be incomplete (streaming parser doesn't know if more data is
    // coming)
    REQUIRE(status == CommitRequest::ParseStatus::Incomplete);

    // Signal end of input to complete parsing
    status = request.finish_streaming_parse();
    REQUIRE(status == CommitRequest::ParseStatus::Complete);
    REQUIRE(request.is_parse_complete());
    REQUIRE(request.leader_id() == "test");
    REQUIRE(request.read_version() == 123);
  }

  SUBCASE("Streaming parse missing required leader_id") {
    std::string json = R"({"request_id": "test", "read_version": 123})";

    REQUIRE(request.begin_streaming_parse());

    std::string mutable_json = json;
    CommitRequest::ParseStatus status =
        request.parse_chunk(mutable_json.data(), mutable_json.size());

    if (status == CommitRequest::ParseStatus::Incomplete) {
      status = request.finish_streaming_parse();
    }

    REQUIRE(status == CommitRequest::ParseStatus::Complete);
    REQUIRE_FALSE(request.is_parse_complete()); // Should fail validation
  }

  SUBCASE("Streaming parse missing required read_version") {
    std::string json = R"({"request_id": "test", "leader_id": "leader123"})";

    REQUIRE(request.begin_streaming_parse());

    std::string mutable_json = json;
    CommitRequest::ParseStatus status =
        request.parse_chunk(mutable_json.data(), mutable_json.size());

    if (status == CommitRequest::ParseStatus::Incomplete) {
      status = request.finish_streaming_parse();
    }

    REQUIRE(status == CommitRequest::ParseStatus::Complete);
    REQUIRE_FALSE(request.is_parse_complete()); // Should fail validation
  }
}