import time
import asyncio
import threading
import logging
from typing import Callable, Any
from .config import RATE_LIMIT_RPM, MIN_REQUEST_INTERVAL

logger = logging.getLogger("ocr.rate_limiter")

class SafeGeminiRateLimiter:
    """
    Sliding-window rate limiter ensuring requests per minute never exceed the Gemini Free Tier.
    Thread-safe and async-safe with automatic 429 exponential backoff.
    """
    def __init__(self, max_rpm: int = RATE_LIMIT_RPM, min_interval_sec: float = MIN_REQUEST_INTERVAL):
        self.max_rpm = max_rpm
        self.min_interval_sec = min_interval_sec
        self.timestamps = []
        self.last_request_time = 0.0
        self._sync_lock = threading.Lock()
        self._async_lock = asyncio.Lock()

    def _calculate_sleep(self) -> float:
        now = time.time()
        # Remove timestamps older than 60s
        self.timestamps = [t for t in self.timestamps if now - t < 60.0]

        sleep_needed = 0.0

        # Minimum interval enforcement
        elapsed_since_last = now - self.last_request_time
        if elapsed_since_last < self.min_interval_sec:
            sleep_needed = max(sleep_needed, self.min_interval_sec - elapsed_since_last)

        # Quota window enforcement
        if len(self.timestamps) >= self.max_rpm:
            oldest = self.timestamps[0]
            quota_sleep = 60.0 - (now - oldest) + 0.2
            sleep_needed = max(sleep_needed, quota_sleep)

        return sleep_needed

    def wait_sync(self):
        with self._sync_lock:
            sleep_needed = self._calculate_sleep()
            if sleep_needed > 0:
                logger.info(f"[RATE LIMIT] Pausing {sleep_needed:.2f}s to respect Gemini Free Tier ({len(self.timestamps)}/{self.max_rpm} RPM)...")
                time.sleep(sleep_needed)

            now = time.time()
            self.last_request_time = now
            self.timestamps.append(now)

    async def wait_async(self):
        async with self._async_lock:
            sleep_needed = self._calculate_sleep()
            if sleep_needed > 0:
                logger.info(f"[RATE LIMIT] Async pause {sleep_needed:.2f}s to respect Gemini Free Tier ({len(self.timestamps)}/{self.max_rpm} RPM)...")
                await asyncio.sleep(sleep_needed)

            now = time.time()
            self.last_request_time = now
            self.timestamps.append(now)

# One rate limiter per pipeline step: each step uses its own API key, so its own quota
rate_limiters = {stage: SafeGeminiRateLimiter() for stage in ("ocr", "extract", "merge")}


def execute_with_retry(fn: Callable[..., Any], stage: str, max_retries: int = 4, initial_backoff: float = 12.0) -> Any:
    """Executes a Gemini API call of one pipeline step ("ocr", "extract", "merge") with that step's rate
    limiting and exponential backoff on 429 Resource Exhausted. A used-up DAILY quota is not retried."""
    backoff = initial_backoff
    for attempt in range(1, max_retries + 1):
        try:
            rate_limiters[stage].wait_sync()
            return fn()
        except Exception as e:
            err_msg = str(e).lower()
            is_rate_limit = ("429" in err_msg or "resource_exhausted" in err_msg or "quota" in err_msg)
            if is_rate_limit and "perday" in err_msg.replace("_", "").replace(" ", ""):
                logger.error(f"[DAILY QUOTA] The {stage} API key has used up its daily quota: {e}")
                raise
            if is_rate_limit and attempt < max_retries:
                logger.warning(f"[RATE LIMIT EXCEEDED] 429 returned on attempt {attempt}/{max_retries}. Backing off for {backoff:.1f}s: {e}")
                time.sleep(backoff)
                backoff *= 1.8
            elif attempt < max_retries:
                logger.warning(f"[API ERROR] Attempt {attempt}/{max_retries} failed: {e}. Retrying in 4s...")
                time.sleep(4.0)
            else:
                logger.error(f"[API FAILURE] All {max_retries} attempts failed: {e}")
                raise e
