import time
import uuid
import logging
import os
import threading
from typing import Callable, Optional
from fastapi import Request, Response
from starlette.middleware.base import BaseHTTPMiddleware
from app.core.security import current_user_var
from app.core.config import settings
import json
import jwt
from datetime import timezone
from starlette.types import ASGIApp, Receive, Scope, Send
from starlette.datastructures import Headers
from fastapi.responses import JSONResponse
import db
from sqlmodel import Session
from app.models.user import User

logger = logging.getLogger(__name__)

# Thread-safe in-memory cache for user authentication details
_user_auth_cache = {}
_cache_lock = threading.Lock()
CACHE_TTL = 30.0  # Cache user details for 30 seconds

def get_cached_user_info(user_id: int):
    now = time.time()
    with _cache_lock:
        entry = _user_auth_cache.get(user_id)
        if entry and entry["expires_at"] > now:
            return entry["data"]
    return None

def set_cached_user_info(user_id: int, data: dict):
    now = time.time()
    with _cache_lock:
        _user_auth_cache[user_id] = {
            "expires_at": now + CACHE_TTL,
            "data": data
        }

def invalidate_user_cache(user_id: int):
    with _cache_lock:
        _user_auth_cache.pop(user_id, None)

ERR_AUTH_REQUIRED = "Authentication is required. Please log in to continue."


class SecurityHeaders:
    """Security headers helper"""
    
    @staticmethod
    def add_security_headers(response: Response) -> Response:
        """Add security headers to response"""
        response.headers["X-Content-Type-Options"] = "nosniff"
        response.headers["X-Frame-Options"] = "DENY"
        response.headers["X-XSS-Protection"] = "1; mode=block"
        response.headers["Strict-Transport-Security"] = "max-age=31536000; includeSubDomains"
        response.headers["Content-Security-Policy"] = "default-src 'self'"
        response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin"
        return response


class RequestLoggingMiddleware(BaseHTTPMiddleware):
    """Log all requests with timing and correlation IDs"""
    
    async def dispatch(self, request: Request, call_next: Callable) -> Response:
        correlation_id = str(uuid.uuid4())
        request.state.correlation_id = correlation_id
        
        start_time = time.time()
        
        logger.info(
            "Request started",
            extra={
                "correlation_id": correlation_id,
                "method": request.method,
                "url": str(request.url),
                "client_ip": request.client.host if request.client else None,
                "user_agent": request.headers.get("user-agent"),
            }
        )
        
        response = await call_next(request)
        
        duration = time.time() - start_time
        
        logger.info(
            "Request completed",
            extra={
                "correlation_id": correlation_id,
                "status_code": response.status_code,
                "duration_ms": round(duration * 1000, 2),
            }
        )
        
        response.headers["X-Correlation-ID"] = correlation_id
        
        return response


class SecurityMiddleware(BaseHTTPMiddleware):
    """Add security headers and basic security checks"""
    
    async def dispatch(self, request: Request, call_next: Callable) -> Response:
        if self._is_suspicious_request(request):
            logger.warning(
                "Suspicious request detected",
                extra={
                    "method": request.method,
                    "url": str(request.url),
                    "client_ip": request.client.host if request.client else None,
                }
            )
        
        response = await call_next(request)
        response = SecurityHeaders.add_security_headers(response)
        
        return response
    
    def _is_suspicious_request(self, request: Request) -> bool:
        """Basic suspicious request detection"""
        url_path = request.url.path.lower()
        
        suspicious_patterns = [
            "script", "alert", "javascript:", "vbscript:",
            "onload", "onerror", "onclick", "eval(",
            "union", "select", "drop", "delete", "insert",
            "../", "..\\", "/etc/passwd", "/proc/",
        ]
        
        for pattern in suspicious_patterns:
            if pattern in url_path:
                return True
        
        for key, value in request.query_params.items():
            value_lower = str(value).lower()
            for pattern in suspicious_patterns:
                if pattern in value_lower:
                    return True
        
        return False


class PerformanceMonitoringMiddleware(BaseHTTPMiddleware):
    """Monitor API performance and log slow requests"""
    
    async def dispatch(self, request: Request, call_next: Callable) -> Response:
        start_time = time.time()
        
        response = await call_next(request)
        
        duration = time.time() - start_time
        
        if duration > 2.0:
            logger.warning(
                "Slow request detected",
                extra={
                    "method": request.method,
                    "url": str(request.url),
                    "duration_ms": round(duration * 1000, 2),
                    "status_code": response.status_code,
                }
            )
        
        response.headers["X-Response-Time"] = f"{round(duration * 1000, 2)}ms"
        
        return response


class ErrorHandlingMiddleware(BaseHTTPMiddleware):
    """Global error handling and logging"""
    
    async def dispatch(self, request: Request, call_next: Callable) -> Response:
        try:
            response = await call_next(request)
            return response
        except Exception as e:
            correlation_id = getattr(request.state, 'correlation_id', 'unknown')
            
            logger.error(
                "Unhandled exception",
                extra={
                    "correlation_id": correlation_id,
                    "method": request.method,
                    "url": str(request.url),
                    "error": str(e),
                    "error_type": type(e).__name__,
                },
                exc_info=True
            )
            
            return JSONResponse(
                status_code=500,
                content={
                    "error": "Internal server error",
                    "correlation_id": correlation_id,
                    "message": "An unexpected error occurred. Please try again later."
                }
            )


class JWTAuthenticationMiddleware:
    def __init__(self, app: ASGIApp):
        self.app = app

    def _is_path_protected(self, path: str, method: str, headers: Headers) -> bool:
        if not path.startswith(("/api/", "/health-insurance")):
            return False
            
        public_paths = [
            "/api/auth/login",
            "/api/auth/register",
            "/api/auth/forgot-password",
            "/api/auth/reset-password",
            "/api/auth/refresh-token",
            "/api/v1/auth/signin",
            "/api/v1/auth/signup",
            "/api/v1/auth/forgot-password",
            "/api/v1/auth/reset-password",
            "/api/v1/dashboard",
            "/api/v1/save-referral-source",
            "/docs",
            "/openapi.json",
            "/redoc",
            "/health",
            "/db-test",
        ]
        
        if path == "/":
            return False
        for p in public_paths:
            if path == p or path.startswith(p + "/"):
                return False

        if method == "POST" or (method == "GET" and path.endswith("/download-pdf")):
            auth_header = headers.get("Authorization")
            if not auth_header or not auth_header.startswith("Bearer "):
                return False

        return True

    def _verify_token_payload(self, token: str) -> tuple[Optional[int], Optional[str], Optional[str], Optional[JSONResponse]]:
        try:
            secret_key = os.getenv("JWT_SECRET", "super_secret_insurance_border_key")
            payload = jwt.decode(token, secret_key, algorithms=["HS256"])
        except (jwt.ExpiredSignatureError, jwt.InvalidTokenError):
            return None, None, None, JSONResponse(
                status_code=401,
                content={"detail": ERR_AUTH_REQUIRED}
            )
            
        if payload.get("type") == "refresh":
            return None, None, None, JSONResponse(
                status_code=401,
                content={"detail": ERR_AUTH_REQUIRED}
            )
        
        user_id = payload.get("sub")
        role = payload.get("role", "customer")
        email = payload.get("email")
        
        if not user_id:
            return None, None, None, JSONResponse(
                status_code=401,
                content={"detail": ERR_AUTH_REQUIRED}
            )
        
        user_id_int = int(user_id)
        user_info = get_cached_user_info(user_id_int)
        if user_info is None:
            with Session(db.engine) as session:
                db_user = session.get(User, user_id_int)
                if not db_user:
                    return None, None, None, JSONResponse(
                        status_code=401,
                        content={"detail": ERR_AUTH_REQUIRED}
                    )
                
                password_changed_at_ts = None
                if db_user.password_changed_at:
                    password_changed_at_ts = db_user.password_changed_at.replace(tzinfo=timezone.utc).timestamp()
                
                user_info = {
                    "password_changed_at_timestamp": password_changed_at_ts
                }
                set_cached_user_info(user_id_int, user_info)
        
        iat = payload.get("iat")
        if iat and user_info["password_changed_at_timestamp"] is not None and iat < user_info["password_changed_at_timestamp"]:
            return None, None, None, JSONResponse(
                status_code=401,
                content={"detail": ERR_AUTH_REQUIRED}
            )
        
        return user_id_int, role, email, None

    async def __call__(self, scope: Scope, receive: Receive, send: Send):
        if scope["type"] not in ("http", "websocket") or scope.get("method") == "OPTIONS":
            await self.app(scope, receive, send)
            return

        headers = Headers(scope=scope)
        path = scope["path"]
        method = scope.get("method", "GET")

        is_protected = self._is_path_protected(path, method, headers)
        is_auth_optional = (method == "POST") or path.endswith("/download-pdf")

        user_id = None
        role = None
        email = None

        if is_protected:
            auth_header = headers.get("Authorization")
            if not auth_header or not auth_header.startswith("Bearer "):
                if not is_auth_optional:
                    response = JSONResponse(
                        status_code=401,
                        content={"detail": ERR_AUTH_REQUIRED}
                    )
                    await response(scope, receive, send)
                    return
            else:
                token = auth_header.split(" ")[1]
                user_id, role, email, err_response = self._verify_token_payload(token)
                if err_response:
                    await err_response(scope, receive, send)
                    return

        # Populate request.state via scope["state"]
        if "state" not in scope:
            scope["state"] = {}
        scope["state"]["user_id"] = user_id
        scope["state"]["role"] = role
        scope["state"]["email"] = email

        token_token = None
        if user_id:
            token_token = current_user_var.set({
                "user_id": user_id,
                "role": role,
                "email": email
            })
            
        try:
            await self.app(scope, receive, send)
        finally:
            if token_token:
                current_user_var.reset(token_token)