/**
 * @fileoverview Adaptive timing controller for respawn idle detection.
 *
 * Extracted from respawn-controller.ts for modularity. Tracks historical timing
 * data and adjusts the completion confirm timeout dynamically based on the 75th
 * percentile of recent idle detection durations.
 *
 * @module respawn-adaptive-timing
 */
/**
 * Manages adaptive timing for respawn idle detection.
 *
 * Uses historical idle detection durations to calculate an optimal completion
 * confirm timeout. The timeout is based on the 75th percentile of recent
 * durations with a 20% safety buffer, clamped to configured bounds.
 */
export class RespawnAdaptiveTiming {
    config;
    timingHistory;
    constructor(config) {
        this.config = config;
        this.timingHistory = {
            recentIdleDetectionMs: [],
            recentCycleDurationMs: [],
            adaptiveCompletionConfirmMs: 10000, // Start with default
            sampleCount: 0,
            maxSamples: 20, // Keep last 20 samples for rolling average
            lastUpdatedAt: Date.now(),
        };
    }
    /**
     * Record timing data from a completed cycle for adaptive adjustments.
     *
     * @param idleDetectionMs - Time spent detecting idle
     * @param cycleDurationMs - Total cycle duration
     */
    recordTimingData(idleDetectionMs, cycleDurationMs) {
        const history = this.timingHistory;
        // Add to rolling windows
        history.recentIdleDetectionMs.push(idleDetectionMs);
        history.recentCycleDurationMs.push(cycleDurationMs);
        // Trim to max samples
        if (history.recentIdleDetectionMs.length > history.maxSamples) {
            history.recentIdleDetectionMs.shift();
        }
        if (history.recentCycleDurationMs.length > history.maxSamples) {
            history.recentCycleDurationMs.shift();
        }
        history.sampleCount = history.recentIdleDetectionMs.length;
        history.lastUpdatedAt = Date.now();
        // Recalculate adaptive timing
        this.updateAdaptiveTiming();
    }
    /**
     * Get the current adaptive completion confirm timeout.
     * Returns the calculated value, or the default if not enough samples.
     *
     * @returns Completion confirm timeout in milliseconds
     */
    getAdaptiveCompletionConfirmMs() {
        return this.timingHistory.adaptiveCompletionConfirmMs;
    }
    /**
     * Get the current timing history for monitoring.
     * @returns Copy of timing history
     */
    getTimingHistory() {
        return { ...this.timingHistory };
    }
    /**
     * Reset all timing history.
     */
    reset() {
        this.timingHistory = {
            recentIdleDetectionMs: [],
            recentCycleDurationMs: [],
            adaptiveCompletionConfirmMs: 10000,
            sampleCount: 0,
            maxSamples: 20,
            lastUpdatedAt: Date.now(),
        };
    }
    /**
     * Recalculate the adaptive completion confirm timeout based on historical data.
     * Uses the 75th percentile of recent idle detection times as the new timeout,
     * with a 20% buffer for safety.
     */
    updateAdaptiveTiming() {
        const history = this.timingHistory;
        const minMs = this.config.adaptiveMinConfirmMs;
        const maxMs = this.config.adaptiveMaxConfirmMs;
        if (history.recentIdleDetectionMs.length < 5)
            return;
        // Sort for percentile calculation
        const sorted = [...history.recentIdleDetectionMs].sort((a, b) => a - b);
        // Use 75th percentile with 20% buffer
        const p75Index = Math.floor(sorted.length * 0.75);
        const p75Value = sorted[p75Index];
        const withBuffer = Math.round(p75Value * 1.2);
        // Clamp to configured bounds
        const clamped = Math.max(minMs, Math.min(maxMs, withBuffer));
        history.adaptiveCompletionConfirmMs = clamped;
    }
}
//# sourceMappingURL=respawn-adaptive-timing.js.map