#pragma once

// Step 504: Performance Optimization
// Synthetic optimization harness for parse+annotate+route throughput and cache behavior.

#include <chrono>
#include <cmath>
#include <map>
#include <string>
#include <unordered_map>
#include <vector>

struct OptimizationTiming {
    double astSerializationMs = 0.0;
    double annotationBatchMs = 0.0;
    double contextAssemblyMs = 0.0;
    double compactGenerationMs = 0.0;
    double totalMs = 0.0;
};

struct PerformanceOptimizationReport {
    int functionCount = 0;
    OptimizationTiming baseline;
    OptimizationTiming optimized;
    double perFunctionMsOptimized = 0.0;
    int contextCacheHits = 0;
    int contextCacheMisses = 0;
    bool targetMet = false;         // <100ms/function
    bool memoryStable = false;      // synthetic no-growth check under sustained runs
    std::vector<std::string> notes;
};

class PerformanceOptimizationSuite {
public:
    static PerformanceOptimizationReport run(int functionCount = 120,
                                             int sustainedRuns = 10) {
        PerformanceOptimizationReport out;
        out.functionCount = functionCount < 1 ? 1 : functionCount;

        auto functions = syntheticFunctions(out.functionCount);

        out.baseline = measureBaseline(functions);
        out.optimized = measureOptimized(functions, &out.contextCacheHits, &out.contextCacheMisses);
        out.perFunctionMsOptimized =
            out.optimized.totalMs / static_cast<double>(out.functionCount);
        out.targetMet = out.perFunctionMsOptimized < 100.0;
        out.memoryStable = sustainedMemoryCheck(functions, sustainedRuns);

        out.notes.push_back("Hot-path timings captured for serialization/annotation/context/compact generation");
        out.notes.push_back(out.targetMet ? "Performance target met" : "Performance target not met");
        return out;
    }

private:
    static std::vector<std::string> syntheticFunctions(int count) {
        std::vector<std::string> out;
        out.reserve(static_cast<size_t>(count));
        for (int i = 0; i < count; ++i) {
            out.push_back("fn_" + std::to_string(i % 25) + "(arg_" + std::to_string(i) + ")");
        }
        return out;
    }

    static OptimizationTiming measureBaseline(const std::vector<std::string>& funcs) {
        OptimizationTiming t;

        t.astSerializationMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += serializeAstBaseline(f).size();
            }
            (void)sink;
        });

        t.annotationBatchMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += annotateBaseline(f).size();
            }
            (void)sink;
        });

        t.contextAssemblyMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += assembleContextBaseline(f).size();
            }
            (void)sink;
        });

        t.compactGenerationMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += generateCompactBaseline(f).size();
            }
            (void)sink;
        });

        t.totalMs = t.astSerializationMs + t.annotationBatchMs +
                    t.contextAssemblyMs + t.compactGenerationMs;
        return t;
    }

    static OptimizationTiming measureOptimized(const std::vector<std::string>& funcs,
                                               int* cacheHits,
                                               int* cacheMisses) {
        OptimizationTiming t;
        std::unordered_map<std::string, std::string> contextCache;
        contextCache.reserve(64);

        t.astSerializationMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += serializeAstOptimized(f).size();
            }
            (void)sink;
        });

        t.annotationBatchMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            auto batch = annotateBatchOptimized(funcs);
            for (const auto& a : batch) sink += a.size();
            (void)sink;
        });

        t.contextAssemblyMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += assembleContextOptimized(f, contextCache, cacheHits, cacheMisses).size();
            }
            (void)sink;
        });

        t.compactGenerationMs = measureMs([&]() {
            volatile std::size_t sink = 0;
            for (const auto& f : funcs) {
                sink += generateCompactOptimized(f).size();
            }
            (void)sink;
        });

        t.totalMs = t.astSerializationMs + t.annotationBatchMs +
                    t.contextAssemblyMs + t.compactGenerationMs;
        return t;
    }

    static bool sustainedMemoryCheck(const std::vector<std::string>& funcs, int runs) {
        std::unordered_map<std::string, std::string> cache;
        cache.reserve(64);
        std::size_t lastSize = 0;
        bool stable = true;

        for (int i = 0; i < runs; ++i) {
            for (const auto& f : funcs) {
                int h = 0, m = 0;
                (void)assembleContextOptimized(f, cache, &h, &m);
            }
            if (i > 0 && cache.size() != lastSize) stable = false;
            lastSize = cache.size();
        }
        return stable;
    }

    template <typename Fn>
    static double measureMs(Fn&& fn) {
        const auto start = std::chrono::steady_clock::now();
        fn();
        const auto end = std::chrono::steady_clock::now();
        return std::chrono::duration<double, std::milli>(end - start).count();
    }

    static std::string serializeAstBaseline(const std::string& fn) {
        std::string out;
        for (int i = 0; i < 6; ++i) out += "{\"node\":\"" + fn + "\"}";
        return out;
    }

    static std::string serializeAstOptimized(const std::string& fn) {
        return "{\"n\":\"" + fn + "\"}";
    }

    static std::string annotateBaseline(const std::string& fn) {
        return "@Intent(" + fn + ") @Complexity(medium) @ContextWidth(file)";
    }

    static std::vector<std::string> annotateBatchOptimized(const std::vector<std::string>& funcs) {
        std::vector<std::string> out;
        out.reserve(funcs.size());
        for (const auto& fn : funcs) {
            out.push_back("@Intent(" + fn + ") @Complexity(low)");
        }
        return out;
    }

    static std::string assembleContextBaseline(const std::string& fn) {
        return "module_graph::deps::contracts::history::" + fn + "::full";
    }

    static std::string assembleContextOptimized(const std::string& fn,
                                                std::unordered_map<std::string, std::string>& cache,
                                                int* cacheHits,
                                                int* cacheMisses) {
        const auto key = fn.substr(0, fn.find('('));
        auto it = cache.find(key);
        if (it != cache.end()) {
            if (cacheHits) ++(*cacheHits);
            return it->second;
        }
        if (cacheMisses) ++(*cacheMisses);
        auto value = "ctx::" + key + "::compact";
        cache[key] = value;
        return value;
    }

    static std::string generateCompactBaseline(const std::string& fn) {
        return "compact_ast(" + fn + ",with_extra_fields=true)";
    }

    static std::string generateCompactOptimized(const std::string& fn) {
        return "c(" + fn + ")";
    }
};