import time
from collections import defaultdict
from typing import Callable
from fastapi import Request, Response
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import JSONResponse
from core.logging import get_logger

logger = get_logger(__name__)


class RateLimiter:
    """
    In-app sliding window rate limiter with per-route policies and in-memory thread-safe tracking.
    Protects against credential stuffing, brute force, and layer-7 DDoS attacks.
    """

    def __init__(self):
        # Maps key -> list of timestamp floats
        self._requests: dict[str, list[float]] = defaultdict(list)
        # Custom route policies: (path_prefix, max_requests, window_seconds)
        self.policies = [
            ("/api/v1/auth/login", 10, 60),
            ("/api/v1/auth/register", 10, 60),
            ("/api/v1/billing/checkout/verify", 15, 60),
            ("/api/v1/ai/agents/", 30, 60),
            ("/api/v1/", 120, 60),  # General API default
        ]

    TRUSTED_PROXIES = {"127.0.0.1", "::1", "localhost", "nginx"}

    def _get_client_identifier(self, request: Request) -> str:
        direct_ip = request.client.host if request.client else "127.0.0.1"
        forwarded = request.headers.get("X-Forwarded-For")
        # Only trust X-Forwarded-For if request originates from trusted proxy / localhost
        if forwarded and (direct_ip in self.TRUSTED_PROXIES or direct_ip.startswith("172.") or direct_ip.startswith("10.")):
            ip = forwarded.split(",")[0].strip()
        else:
            ip = direct_ip
        return ip

    def _get_policy(self, path: str) -> tuple[int, int] | None:
        if path.startswith("/api/v1/health") or path.startswith("/docs") or path.startswith("/openapi.json"):
            return None  # Exempt from rate limits

        for prefix, limit, window in self.policies:
            if path.startswith(prefix):
                return limit, window

        return None

    def is_rate_limited(self, ip: str, path: str) -> tuple[bool, int, int, int]:
        """
        Returns (is_limited, limit, remaining, retry_after_seconds).
        Cleans expired keys automatically to prevent unbounded memory growth.
        """
        policy = self._get_policy(path)
        if policy is None:
            return False, 9999, 9999, 0

        limit, window = policy
        now = time.time()
        key = f"{ip}:{path}"

        # Clean expired timestamps outside the sliding window
        window_start = now - window
        timestamps = [t for t in self._requests.get(key, []) if t > window_start]

        if len(timestamps) >= limit:
            oldest = timestamps[0]
            retry_after = max(1, int(oldest + window - now))
            self._requests[key] = timestamps
            return True, limit, 0, retry_after

        # Record this request
        timestamps.append(now)
        self._requests[key] = timestamps
        remaining = max(0, limit - len(timestamps))

        # Periodic cleanup of completely expired keys to prevent memory leak
        if len(self._requests) > 2000:
            expired_keys = [k for k, v in self._requests.items() if not v or v[-1] <= window_start]
            for ek in expired_keys:
                self._requests.pop(ek, None)

        return False, limit, remaining, 0

    def reset(self):
        self._requests.clear()


# Global singleton
rate_limiter = RateLimiter()


class RateLimitMiddleware(BaseHTTPMiddleware):
    """FastAPI Middleware to enforce in-app rate limits."""

    async def dispatch(self, request: Request, call_next: Callable) -> Response:
        ip = rate_limiter._get_client_identifier(request)
        path = request.url.path

        is_limited, limit, remaining, retry_after = rate_limiter.is_rate_limited(ip, path)

        if is_limited:
            logger.warning(
                "rate_limit_exceeded",
                ip=ip,
                path=path,
                retry_after=retry_after,
            )
            response = JSONResponse(
                status_code=429,
                content={
                    "success": False,
                    "error": "RATE_LIMIT_EXCEEDED",
                    "message": f"Rate limit exceeded. Try again in {retry_after} seconds.",
                    "details": {
                        "limit": limit,
                        "retry_after": retry_after,
                    },
                },
            )
            response.headers["Retry-After"] = str(retry_after)
            response.headers["X-RateLimit-Limit"] = str(limit)
            response.headers["X-RateLimit-Remaining"] = "0"
            return response

        response = await call_next(request)
        if limit < 9000:
            response.headers["X-RateLimit-Limit"] = str(limit)
            response.headers["X-RateLimit-Remaining"] = str(remaining)

        return response
