#include <catch2/catch_test_macros.hpp>
#include "../src/tracer.hpp"
#include <filesystem>
#include <fstream>
#include <regex>

TEST_CASE("Tracer object construction", "[tracer]") {
    // Simply verify we can create a Tracer object
    Tracer tracer;
    // If we get here, construction succeeded
    REQUIRE(true);
}

TEST_CASE("Tracer handles different variable sizes", "[tracer]") {
    // This test verifies that the Tracer can be created and configured
    // for different variable sizes without crashing
    Tracer tracer1, tracer2, tracer3, tracer4;

    // These would be used with 1, 2, 4, 8 byte variables
    // We can't easily test the actual watching without a real process,
    // but we can verify the objects are created successfully
    REQUIRE(true);
}

// Test helper to check if a file contains expected patterns
bool file_contains_pattern(const std::string& filepath, const std::string& pattern) {
    if (!std::filesystem::exists(filepath)) {
        return false;
    }

    std::ifstream file(filepath);
    if (!file.is_open()) {
        return false;
    }

    std::string line;
    std::regex regex_pattern(pattern);

    while (std::getline(file, line)) {
        if (std::regex_search(line, regex_pattern)) {
            return true;
        }
    }

    return false;
}

TEST_CASE("Tracer can read /proc/pid/maps format", "[tracer]") {
    // Test that we can parse a typical /proc/pid/maps entry
    // This tests the format expected by get_load_address

    // Create a temporary maps file with typical content
    std::string test_maps_content =
        "555555554000-555555555000 r--p 00000000 08:01 1234 /usr/bin/test_prog\n"
        "555555555000-555555556000 r-xp 00001000 08:01 1234 /usr/bin/test_prog\n"
        "555555556000-555555557000 r--p 00002000 08:01 1234 /usr/bin/test_prog\n"
        "555555557000-555555558000 rw-p 00002000 08:01 1234 /usr/bin/test_prog\n";

    std::ofstream temp_file("/tmp/test_maps");
    temp_file << test_maps_content;
    temp_file.close();

    // Verify the file was created
    REQUIRE(std::filesystem::exists("/tmp/test_maps"));

    // The format should have addresses in hex
    REQUIRE(file_contains_pattern("/tmp/test_maps", "^[0-9a-f]+-[0-9a-f]+"));

    // Clean up
    std::filesystem::remove("/tmp/test_maps");
}

TEST_CASE("Test binaries exist and have required variables", "[integration]") {
    SECTION("test_access binary") {
        if (std::filesystem::exists("./test_access")) {
            // Binary exists
            REQUIRE(true);
        } else {
            WARN("test_access binary not found");
        }
    }

    SECTION("test_with_args binary") {
        if (std::filesystem::exists("./test_with_args")) {
            // Binary exists
            REQUIRE(true);
        } else {
            WARN("test_with_args binary not found");
        }
    }
}