package gudusoft.gsqlparser.resolver2.iterative;

import java.util.ArrayList;
import java.util.List;

/**
 * Detects when iterative resolution has converged.
 *
 * <p>Convergence is reached when one of these conditions is met:
 * 1. No progress in current pass (no new columns resolved)
 * 2. All columns are resolved
 * 3. Maximum iterations reached
 * 4. No change in last N passes (stable state)
 * 5. Progress rate falls below threshold
 *
 * <p>The detector uses multiple strategies to avoid:
 * - Infinite loops (max iterations)
 * - Premature stopping (stable state detection)
 * - Wasted iterations (progress rate threshold)
 *
 * <p>Example:
 * <pre>
 * Pass 1: 10 columns resolved -> continue
 * Pass 2: 5 columns resolved  -> continue
 * Pass 3: 2 columns resolved  -> continue
 * Pass 4: 0 columns resolved  -> CONVERGED (no progress)
 * </pre>
 */
public class ConvergenceDetector {

    /** Maximum number of iterations allowed */
    private final int maxIterations;

    /** Number of stable passes required to declare convergence */
    private final int stablePasses;

    /** Minimum progress rate to continue (0.0 - 1.0) */
    private final double minProgressRate;

    /** History of passes */
    private final List<ResolutionPass> passHistory;

    public ConvergenceDetector() {
        this(10, 2, 0.01);
    }

    public ConvergenceDetector(int maxIterations, int stablePasses, double minProgressRate) {
        this.maxIterations = maxIterations;
        this.stablePasses = stablePasses;
        this.minProgressRate = minProgressRate;
        this.passHistory = new ArrayList<>();
    }

    /**
     * Record a completed pass.
     *
     * @param pass the completed pass
     */
    public void recordPass(ResolutionPass pass) {
        passHistory.add(pass);
    }

    /**
     * Check if resolution has converged.
     *
     * @return convergence result with reason
     */
    public ConvergenceResult checkConvergence() {
        if (passHistory.isEmpty()) {
            return new ConvergenceResult(false, null);
        }

        ResolutionPass lastPass = passHistory.get(passHistory.size() - 1);

        // Check 1: Maximum iterations reached
        if (lastPass.getPassNumber() >= maxIterations) {
            return new ConvergenceResult(
                true,
                "Maximum iterations reached (" + maxIterations + ")"
            );
        }

        // Check 2: No progress in last pass
        if (!lastPass.madeProgress()) {
            return new ConvergenceResult(
                true,
                "No progress in pass " + lastPass.getPassNumber()
            );
        }

        // Check 3: All columns resolved (100% resolution)
        if (lastPass.getAfterStats() != null) {
            int total = lastPass.getAfterStats().getTotalReferences();
            int resolved = lastPass.getAfterStats().getExactMatches();
            if (total > 0 && resolved == total) {
                return new ConvergenceResult(
                    true,
                    "All columns resolved (" + resolved + "/" + total + ")"
                );
            }
        }

        // Check 4: Stable state (no progress in last N passes)
        if (passHistory.size() >= stablePasses) {
            boolean allStable = true;
            for (int i = passHistory.size() - stablePasses; i < passHistory.size(); i++) {
                if (passHistory.get(i).madeProgress()) {
                    allStable = false;
                    break;
                }
            }
            if (allStable) {
                return new ConvergenceResult(
                    true,
                    "Stable state (no progress in last " + stablePasses + " passes)"
                );
            }
        }

        // Check 5: Progress rate too low
        if (passHistory.size() >= 3) {
            double progressRate = calculateProgressRate();
            if (progressRate < minProgressRate) {
                return new ConvergenceResult(
                    true,
                    String.format("Progress rate too low (%.2f%% < %.2f%%)",
                        progressRate * 100, minProgressRate * 100)
                );
            }
        }

        // Not converged yet
        return new ConvergenceResult(false, null);
    }

    /**
     * Calculate the progress rate over recent passes.
     * Returns ratio of columns resolved / total columns.
     */
    private double calculateProgressRate() {
        if (passHistory.isEmpty()) {
            return 0.0;
        }

        ResolutionPass lastPass = passHistory.get(passHistory.size() - 1);
        if (lastPass.getAfterStats() == null) {
            return 0.0;
        }

        int totalReferences = lastPass.getAfterStats().getTotalReferences();
        if (totalReferences == 0) {
            return 1.0;  // No columns to resolve
        }

        int resolved = lastPass.getColumnsResolvedInPass();
        return (double) resolved / totalReferences;
    }

    /**
     * Get the total number of passes so far.
     *
     * @return pass count
     */
    public int getPassCount() {
        return passHistory.size();
    }

    /**
     * Get the pass history.
     *
     * @return list of all passes
     */
    public List<ResolutionPass> getPassHistory() {
        return new ArrayList<>(passHistory);
    }

    /**
     * Get statistics about the iteration process.
     *
     * @return statistics summary
     */
    public String getStatistics() {
        if (passHistory.isEmpty()) {
            return "No passes yet";
        }

        int totalResolved = 0;
        int totalInferences = 0;
        long totalTime = 0;

        for (ResolutionPass pass : passHistory) {
            totalResolved += pass.getColumnsResolvedInPass();
            totalInferences += pass.getNewInferences();
            totalTime += pass.getTimeTaken();
        }

        return String.format(
            "Iterations: %d, Resolved: %d, Inferences: %d, Time: %dms",
            passHistory.size(), totalResolved, totalInferences, totalTime
        );
    }

    /**
     * Result of convergence check.
     */
    public static class ConvergenceResult {
        private final boolean converged;
        private final String reason;

        public ConvergenceResult(boolean converged, String reason) {
            this.converged = converged;
            this.reason = reason;
        }

        public boolean hasConverged() {
            return converged;
        }

        public String getReason() {
            return reason;
        }

        @Override
        public String toString() {
            return converged ? "Converged: " + reason : "Not converged";
        }
    }
}