package gudusoft.gsqlparser.resolver2.iterative;

import gudusoft.gsqlparser.resolver2.model.ResolutionStatistics;

/**
 * Adaptive resolution strategy that adjusts based on query complexity.
 *
 * <p>This strategy analyzes the resolution progress and adapts its behavior:
 * - If progress is good: Continue with current approach
 * - If progress stalls: Enable more aggressive techniques (inference, expansion)
 * - If query is complex: Use more iterations
 * - If query is simple: Use fewer iterations
 *
 * <p>Adaptation criteria:
 * - Resolution rate (% of columns resolved)
 * - Progress per pass (columns resolved in each iteration)
 * - Query complexity (number of CTEs, subqueries, etc.)
 *
 * <p>Example behavior:
 * <pre>
 * Simple query (SELECT a, b FROM t1):
 *   Pass 1: 100% resolved -> STOP (no need for more passes)
 *
 * Complex query (multiple nested CTEs):
 *   Pass 1: 30% resolved -> continue
 *   Pass 2: 60% resolved -> enable inference
 *   Pass 3: 85% resolved -> enable aggressive expansion
 *   Pass 4: 95% resolved -> final cleanup
 * </pre>
 */
public class AdaptiveResolutionStrategy implements ResolutionStrategy {

    /** Threshold for "good" progress rate */
    private static final double GOOD_PROGRESS_THRESHOLD = 0.2;  // 20% per pass

    /** Threshold for "slow" progress rate */
    private static final double SLOW_PROGRESS_THRESHOLD = 0.05;  // 5% per pass

    /** Current adaptive state */
    private AdaptiveState currentState;

    /** Previous resolution rate */
    private double previousResolutionRate;

    /** Number of consecutive slow passes */
    private int slowPassCount;

    public AdaptiveResolutionStrategy() {
        this.currentState = AdaptiveState.CONSERVATIVE;
        this.previousResolutionRate = 0.0;
        this.slowPassCount = 0;
    }

    @Override
    public String getName() {
        return "Adaptive";
    }

    @Override
    public boolean shouldPerformInference(int passNumber, ResolutionStatistics previousStats) {
        // Always enable inference in aggressive mode
        if (currentState == AdaptiveState.AGGRESSIVE) {
            return true;
        }

        // Enable inference from pass 2 in normal mode
        if (currentState == AdaptiveState.NORMAL && passNumber >= 2) {
            return true;
        }

        // Conservative mode: only if progress is slow
        if (currentState == AdaptiveState.CONSERVATIVE) {
            return slowPassCount >= 2;
        }

        return false;
    }

    @Override
    public boolean shouldExpandStars(int passNumber, ResolutionStatistics previousStats) {
        // Expand stars based on state
        switch (currentState) {
            case AGGRESSIVE:
                return passNumber >= 1;  // Expand immediately
            case NORMAL:
                return passNumber >= 2;  // Expand from pass 2
            case CONSERVATIVE:
                return passNumber >= 3;  // Wait until pass 3
            default:
                return passNumber >= 2;
        }
    }

    @Override
    public boolean shouldPushDownColumns(int passNumber, ResolutionStatistics previousStats) {
        // Push-down is expensive, so enable it strategically
        switch (currentState) {
            case AGGRESSIVE:
                return passNumber >= 2;  // Enable early in aggressive mode
            case NORMAL:
                return passNumber >= 3;  // Enable later in normal mode
            case CONSERVATIVE:
                return passNumber >= 4;  // Enable late in conservative mode
            default:
                return passNumber >= 3;
        }
    }

    @Override
    public void preparePass(int passNumber, ResolutionStatistics previousStats) {
        if (previousStats == null || passNumber == 1) {
            // First pass: start conservative
            currentState = AdaptiveState.CONSERVATIVE;
            return;
        }

        // Calculate progress metrics
        int total = previousStats.getTotalReferences();
        int resolved = previousStats.getExactMatches();

        double resolutionRate = total > 0 ? (double) resolved / total : 0.0;
        double progressRate = resolutionRate - previousResolutionRate;

        // Adapt state based on progress
        if (progressRate >= GOOD_PROGRESS_THRESHOLD) {
            // Good progress: stay in or move to normal mode
            if (currentState == AdaptiveState.CONSERVATIVE) {
                currentState = AdaptiveState.NORMAL;
            }
            slowPassCount = 0;
        } else if (progressRate <= SLOW_PROGRESS_THRESHOLD) {
            // Slow progress: become more aggressive
            slowPassCount++;
            if (slowPassCount >= 2) {
                if (currentState == AdaptiveState.CONSERVATIVE) {
                    currentState = AdaptiveState.NORMAL;
                } else if (currentState == AdaptiveState.NORMAL) {
                    currentState = AdaptiveState.AGGRESSIVE;
                }
            }
        } else {
            // Moderate progress: stay in normal mode
            if (currentState == AdaptiveState.CONSERVATIVE) {
                currentState = AdaptiveState.NORMAL;
            }
            slowPassCount = 0;
        }

        previousResolutionRate = resolutionRate;
    }

    @Override
    public String getDescription() {
        return "Adaptive resolution strategy. " +
               "Adjusts behavior based on resolution progress. " +
               "States: Conservative -> Normal -> Aggressive.";
    }

    /**
     * Get the current adaptive state.
     *
     * @return current state
     */
    public AdaptiveState getCurrentState() {
        return currentState;
    }

    @Override
    public String toString() {
        return getName() + " strategy (state: " + currentState + ")";
    }

    /**
     * Adaptive states.
     */
    public enum AdaptiveState {
        /** Conservative: minimal inference and expansion */
        CONSERVATIVE,

        /** Normal: standard inference and expansion */
        NORMAL,

        /** Aggressive: maximum inference and expansion */
        AGGRESSIVE
    }
}