#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <functional>
#include <chrono>
#include <memory>
#include <cassert>

// Test framework utilities
namespace SaunaTest {

// Test result structure
struct TestResult {
    bool passed;
    std::string message;
    
    TestResult(bool p, const std::string& msg) : passed(p), message(msg) {}
};

// Test case structure
struct TestCase {
    std::string name;
    std::function<TestResult()> testFunc;
    
    TestCase(const std::string& n, std::function<TestResult()> f) 
        : name(n), testFunc(f) {}
};

// Test suite class
class TestSuite {
private:
    std::string name;
    std::vector<TestCase> testCases;
    int passedTests;
    int failedTests;
    
public:
    TestSuite(const std::string& suiteName) 
        : name(suiteName), passedTests(0), failedTests(0) {}
    
    void addTest(const std::string& testName, std::function<TestResult()> testFunc) {
        testCases.emplace_back(testName, testFunc);
    }
    
    bool runAll() {
        std::cout << "=== Running Test Suite: " << name << " ===" << std::endl;
        
        passedTests = 0;
        failedTests = 0;
        
        for (auto& test : testCases) {
            std::cout << "Running test: " << test.name << "... ";
            
            auto startTime = std::chrono::high_resolution_clock::now();
            TestResult result = test.testFunc();
            auto endTime = std::chrono::high_resolution_clock::now();
            
            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime).count();
            
            if (result.passed) {
                std::cout << "PASSED (" << duration << "ms)" << std::endl;
                passedTests++;
            } else {
                std::cout << "FAILED (" << duration << "ms)" << std::endl;
                std::cout << "  Error: " << result.message << std::endl;
                failedTests++;
            }
        }
        
        std::cout << "=== Test Suite Summary: " << name << " ===" << std::endl;
        std::cout << "  Total Tests: " << testCases.size() << std::endl;
        std::cout << "  Passed: " << passedTests << std::endl;
        std::cout << "  Failed: " << failedTests << std::endl;
        
        return failedTests == 0;
    }
    
    int getPassedCount() const { return passedTests; }
    int getFailedCount() const { return failedTests; }
};

// Assertion utilities
inline TestResult assertTrue(bool condition, const std::string& message = "Assertion failed") {
    return TestResult(condition, condition ? "Success" : message);
}

inline TestResult assertEqual(double expected, double actual, double epsilon = 0.0001, 
                             const std::string& message = "Values are not equal") {
    bool passed = std::abs(expected - actual) < epsilon;
    std::string msg = passed ? "Success" : 
                     (message + " (Expected: " + std::to_string(expected) + 
                      ", Actual: " + std::to_string(actual) + ")");
    return TestResult(passed, msg);
}

template<typename T>
inline TestResult assertEqual(const T& expected, const T& actual, 
                             const std::string& message = "Values are not equal") {
    bool passed = (expected == actual);
    std::string msg = passed ? "Success" : message;
    return TestResult(passed, msg);
}

// Performance measurement utilities
class PerformanceTimer {
private:
    std::chrono::high_resolution_clock::time_point startTime;
    std::string operationName;
    
public:
    PerformanceTimer(const std::string& name) : operationName(name) {
        startTime = std::chrono::high_resolution_clock::now();
    }
    
    ~PerformanceTimer() {
        auto endTime = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime).count();
        std::cout << operationName << " took " << duration << " microseconds" << std::endl;
    }
    
    double getElapsedMilliseconds() {
        auto endTime = std::chrono::high_resolution_clock::now();
        return std::chrono::duration_cast<std::chrono::microseconds>(endTime - startTime).count() / 1000.0;
    }
};

// Memory usage tracking
struct MemoryUsage {
    size_t currentUsage;
    size_t peakUsage;
};

// Simple memory tracker (platform-specific implementations would be needed for accurate tracking)
class MemoryTracker {
public:
    static MemoryUsage getCurrentMemoryUsage() {
        // This is a placeholder - actual implementation would use platform-specific APIs
        MemoryUsage usage = {0, 0};
        return usage;
    }
};

} // namespace SaunaTest