#include "commit_request.hpp"

#include <iostream>
#include <nanobench.h>
#include <nlohmann/json.hpp>
#include <string>

// Sample JSON strings for benchmarking - same as commit_request benchmark
const std::string SIMPLE_JSON = R"({
    "request_id": "simple-test",
    "leader_id": "leader123",
    "read_version": 12345
})";

const std::string MEDIUM_JSON = R"({
    "request_id": "medium-test",
    "leader_id": "leader456",
    "read_version": 98765,
    "preconditions": [
        {
            "type": "point_read",
            "version": 98764,
            "key": "dGVzdEtleQ=="
        },
        {
            "type": "range_read",
            "version": 98763,
            "begin": "cmFuZ2VTdGFydA==",
            "end": "cmFuZ2VFbmQ="
        }
    ],
    "operations": [
        {
            "type": "write",
            "key": "d3JpdGVLZXk=",
            "value": "d3JpdGVWYWx1ZQ=="
        },
        {
            "type": "delete",
            "key": "ZGVsZXRlS2V5"
        }
    ]
})";

const std::string COMPLEX_JSON = R"({
    "request_id": "complex-batch-operation-12345",
    "leader_id": "leader789abcdef",
    "read_version": 999999999,
    "preconditions": [
        {
            "type": "point_read",
            "version": 999999998,
            "key": "cHJlY29uZGl0aW9uS2V5MQ=="
        },
        {
            "type": "range_read",
            "version": 999999997,
            "begin": "cmFuZ2VQcmVjb25kaXRpb25CZWdpbg==",
            "end": "cmFuZ2VQcmVjb25kaXRpb25FbmQ="
        },
        {
            "type": "point_read",
            "version": 999999996,
            "key": "YW5vdGhlclByZWNvbmRpdGlvbktleQ=="
        }
    ],
    "operations": [
        {
            "type": "write",
            "key": "b3BlcmF0aW9uS2V5MQ==",
            "value": "bGFyZ2VPcGVyYXRpb25WYWx1ZVdpdGhMb3RzT2ZEYXRhSGVyZQ=="
        },
        {
            "type": "write",
            "key": "b3BlcmF0aW9uS2V5Mg==",
            "value": "YW5vdGhlckxhcmdlVmFsdWVXaXRoRXZlbk1vcmVEYXRh"
        },
        {
            "type": "delete",
            "key": "ZGVsZXRlT3BlcmF0aW9uS2V5"
        },
        {
            "type": "range_delete",
            "begin": "cmFuZ2VEZWxldGVTdGFydA==",
            "end": "cmFuZ2VEZWxldGVFbmQ="
        },
        {
            "type": "write",
            "key": "ZmluYWxPcGVyYXRpb25LZXk=",
            "value": "ZmluYWxPcGVyYXRpb25WYWx1ZVdpdGhMb25nZXJEYXRhRm9yVGVzdGluZw=="
        }
    ]
})";

// Generate a large JSON with many operations for stress testing
std::string generate_large_json(int num_operations) {
  std::string json = R"({
    "request_id": "large-batch-)" +
                     std::to_string(num_operations) + R"(",
    "leader_id": "stress-test-leader",
    "read_version": 1000000,
    "operations": [)";

  for (int i = 0; i < num_operations; ++i) {
    if (i > 0)
      json += ",";
    json += R"(
        {
            "type": "write",
            "key": ")" +
            std::string("key") + std::to_string(i) + R"(",
            "value": ")" +
            std::string("value") + std::to_string(i) + R"("
        })";
  }

  json += R"(
    ]
})";
  return json;
}

// Helper function to simulate validation work on nlohmann json object
bool validate_nlohmann_commit_request(const nlohmann::json &j) {
  try {
    // Basic structure validation
    if (!j.is_object())
      return false;

    // Check required fields
    if (j.contains("read_version") && !j["read_version"].is_number())
      return false;
    if (j.contains("leader_id") && !j["leader_id"].is_string())
      return false;
    if (j.contains("request_id") && !j["request_id"].is_string())
      return false;

    // Validate preconditions array
    if (j.contains("preconditions")) {
      if (!j["preconditions"].is_array())
        return false;
      for (const auto &precond : j["preconditions"]) {
        if (!precond.is_object())
          return false;
        if (!precond.contains("type") || !precond["type"].is_string())
          return false;
        if (!precond.contains("version") || !precond["version"].is_number())
          return false;

        std::string type = precond["type"];
        if (type == "point_read") {
          if (!precond.contains("key") || !precond["key"].is_string())
            return false;
        } else if (type == "range_read") {
          if (!precond.contains("begin") || !precond["begin"].is_string())
            return false;
          if (!precond.contains("end") || !precond["end"].is_string())
            return false;
        }
      }
    }

    // Validate operations array
    if (j.contains("operations")) {
      if (!j["operations"].is_array())
        return false;
      for (const auto &op : j["operations"]) {
        if (!op.is_object())
          return false;
        if (!op.contains("type") || !op["type"].is_string())
          return false;

        std::string type = op["type"];
        if (type == "write") {
          if (!op.contains("key") || !op["key"].is_string())
            return false;
          if (!op.contains("value") || !op["value"].is_string())
            return false;
        } else if (type == "delete") {
          if (!op.contains("key") || !op["key"].is_string())
            return false;
        } else if (type == "range_delete") {
          if (!op.contains("begin") || !op["begin"].is_string())
            return false;
          if (!op.contains("end") || !op["end"].is_string())
            return false;
        }
      }
    }

    return true;
  } catch (const std::exception &) {
    return false;
  }
}

int main() {
  std::cout << "Parser Comparison Benchmarks\n";
  std::cout << "=============================\n\n";

  // Simple JSON comparison
  auto simple_bench = ankerl::nanobench::Bench()
                          .title("Simple JSON Parsing Comparison")
                          .unit("parse")
                          .warmup(100)
                          .minEpochIterations(1000);

  simple_bench.run("WeaselDB Parser", [&] {
    CommitRequest request;
    std::string mutable_json = SIMPLE_JSON;
    bool result = request.parse_json(mutable_json.data(), mutable_json.size());
    ankerl::nanobench::doNotOptimizeAway(result);
    ankerl::nanobench::doNotOptimizeAway(request.is_parse_complete());
  });

  simple_bench.run("nlohmann/json + validation", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(SIMPLE_JSON);
      bool result = validate_nlohmann_commit_request(j);
      ankerl::nanobench::doNotOptimizeAway(result);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  simple_bench.run("nlohmann/json (parse only)", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(SIMPLE_JSON);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  // Medium complexity JSON comparison
  auto medium_bench = ankerl::nanobench::Bench()
                          .title("Medium JSON Parsing Comparison")
                          .unit("parse")
                          .warmup(100)
                          .minEpochIterations(500);

  medium_bench.run("WeaselDB Parser", [&] {
    CommitRequest request;
    std::string mutable_json = MEDIUM_JSON;
    bool result = request.parse_json(mutable_json.data(), mutable_json.size());
    ankerl::nanobench::doNotOptimizeAway(result);
    ankerl::nanobench::doNotOptimizeAway(request.is_parse_complete());
  });

  medium_bench.run("nlohmann/json + validation", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(MEDIUM_JSON);
      bool result = validate_nlohmann_commit_request(j);
      ankerl::nanobench::doNotOptimizeAway(result);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  medium_bench.run("nlohmann/json (parse only)", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(MEDIUM_JSON);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  // Complex JSON comparison
  auto complex_bench = ankerl::nanobench::Bench()
                           .title("Complex JSON Parsing Comparison")
                           .unit("parse")
                           .warmup(100)
                           .minEpochIterations(200);

  complex_bench.run("WeaselDB Parser", [&] {
    CommitRequest request;
    std::string mutable_json = COMPLEX_JSON;
    bool result = request.parse_json(mutable_json.data(), mutable_json.size());
    ankerl::nanobench::doNotOptimizeAway(result);
    ankerl::nanobench::doNotOptimizeAway(request.is_parse_complete());
  });

  complex_bench.run("nlohmann/json + validation", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(COMPLEX_JSON);
      bool result = validate_nlohmann_commit_request(j);
      ankerl::nanobench::doNotOptimizeAway(result);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  complex_bench.run("nlohmann/json (parse only)", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(COMPLEX_JSON);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  // Large batch operations comparison
  auto large_bench = ankerl::nanobench::Bench()
                         .title("Large JSON Parsing Comparison")
                         .unit("parse")
                         .warmup(50)
                         .minEpochIterations(100);

  for (int num_ops : {50, 100, 500}) {
    std::string large_json = generate_large_json(num_ops);
    std::string bench_name = std::to_string(num_ops) + " operations";

    large_bench.run("WeaselDB Parser (" + bench_name + ")", [&] {
      CommitRequest request;
      std::string mutable_json = large_json;
      bool result =
          request.parse_json(mutable_json.data(), mutable_json.size());
      ankerl::nanobench::doNotOptimizeAway(result);
      ankerl::nanobench::doNotOptimizeAway(request.is_parse_complete());
    });

    large_bench.run("nlohmann/json + validation (" + bench_name + ")", [&] {
      try {
        nlohmann::json j = nlohmann::json::parse(large_json);
        bool result = validate_nlohmann_commit_request(j);
        ankerl::nanobench::doNotOptimizeAway(result);
        ankerl::nanobench::doNotOptimizeAway(j.size());
      } catch (const std::exception &) {
        ankerl::nanobench::doNotOptimizeAway(false);
      }
    });

    large_bench.run("nlohmann/json (parse only) (" + bench_name + ")", [&] {
      try {
        nlohmann::json j = nlohmann::json::parse(large_json);
        ankerl::nanobench::doNotOptimizeAway(j.size());
      } catch (const std::exception &) {
        ankerl::nanobench::doNotOptimizeAway(false);
      }
    });
  }

  // Memory efficiency comparison
  auto memory_bench = ankerl::nanobench::Bench()
                          .title("Memory Efficiency Comparison")
                          .unit("allocation")
                          .warmup(50)
                          .minEpochIterations(200);

  memory_bench.run("WeaselDB Parser (arena allocation)", [&] {
    CommitRequest request(4096); // 4KB arena
    std::string mutable_json = COMPLEX_JSON;
    bool result = request.parse_json(mutable_json.data(), mutable_json.size());
    ankerl::nanobench::doNotOptimizeAway(result);
    ankerl::nanobench::doNotOptimizeAway(request.total_allocated());
    ankerl::nanobench::doNotOptimizeAway(request.used_bytes());
  });

  memory_bench.run("nlohmann/json (standard allocation)", [&] {
    try {
      nlohmann::json j = nlohmann::json::parse(COMPLEX_JSON);
      bool result = validate_nlohmann_commit_request(j);
      ankerl::nanobench::doNotOptimizeAway(result);
      ankerl::nanobench::doNotOptimizeAway(j.size());
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  // Reset and reuse comparison
  auto reuse_bench = ankerl::nanobench::Bench()
                         .title("Reset and Reuse Comparison")
                         .unit("cycle")
                         .warmup(50)
                         .minEpochIterations(100);

  reuse_bench.run("WeaselDB Parser (reset)", [&] {
    static CommitRequest request;

    std::string mutable_json1 = SIMPLE_JSON;
    bool result1 =
        request.parse_json(mutable_json1.data(), mutable_json1.size());

    request.reset();

    std::string mutable_json2 = MEDIUM_JSON;
    bool result2 =
        request.parse_json(mutable_json2.data(), mutable_json2.size());

    ankerl::nanobench::doNotOptimizeAway(result1);
    ankerl::nanobench::doNotOptimizeAway(result2);
  });

  reuse_bench.run("nlohmann/json (new instance)", [&] {
    try {
      nlohmann::json j1 = nlohmann::json::parse(SIMPLE_JSON);
      bool result1 = validate_nlohmann_commit_request(j1);

      nlohmann::json j2 = nlohmann::json::parse(MEDIUM_JSON);
      bool result2 = validate_nlohmann_commit_request(j2);

      ankerl::nanobench::doNotOptimizeAway(result1);
      ankerl::nanobench::doNotOptimizeAway(result2);
    } catch (const std::exception &) {
      ankerl::nanobench::doNotOptimizeAway(false);
    }
  });

  std::cout << "\nBenchmark completed. The WeaselDB parser is optimized for:\n";
  std::cout << "- Arena-based memory allocation for reduced fragmentation\n";
  std::cout << "- Streaming parsing for network protocols\n";
  std::cout << "- Zero-copy string handling with string views\n";
  std::cout << "- Base64 decoding integrated into parsing pipeline\n";
  std::cout << "- Efficient reset and reuse for high-throughput scenarios\n";

  return 0;
}