import asyncio
import os
import time
from typing import Dict, Any, Optional, List

import httpx
from fastapi import Depends, FastAPI, HTTPException, Request
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from fastapi.openapi.utils import get_openapi
from pydantic import BaseModel, Field

from shared.config import settings
from services.user_service.schemas import UserCreate, UserLogin, UserResponse, UserUpdate, Token

# Импортируем схемы для экстренных контактов
class EmergencyContactBase(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    phone_number: str = Field(..., min_length=5, max_length=20)
    relationship: Optional[str] = Field(None, max_length=50)
    notes: Optional[str] = Field(None, max_length=500)


class EmergencyContactCreate(EmergencyContactBase):
    pass


class EmergencyContactUpdate(BaseModel):
    name: Optional[str] = Field(None, min_length=1, max_length=100)
    phone_number: Optional[str] = Field(None, min_length=5, max_length=20)
    relationship: Optional[str] = Field(None, max_length=50)
    notes: Optional[str] = Field(None, max_length=500)


class EmergencyContactResponse(EmergencyContactBase):
    id: int
    uuid: str
    user_id: int
    
    class Config:
        from_attributes = True

app = FastAPI(title="API Gateway", version="1.0.0", openapi_url="/api/openapi.json")

# CORS middleware
app.add_middleware(
    CORSMiddleware,
    allow_origins=settings.CORS_ORIGINS,
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Service registry
SERVICES = {
    "users": os.getenv("USER_SERVICE_URL", "http://localhost:8001"),
    "emergency": os.getenv("EMERGENCY_SERVICE_URL", "http://localhost:8002"),
    "location": os.getenv("LOCATION_SERVICE_URL", "http://localhost:8003"),
    "calendar": os.getenv("CALENDAR_SERVICE_URL", "http://localhost:8004"),
    "notifications": os.getenv("NOTIFICATION_SERVICE_URL", "http://localhost:8005"),
}

# Rate limiting (simple in-memory implementation)
request_counts: Dict[str, Dict[str, int]] = {}
RATE_LIMIT_REQUESTS = 100  # requests per minute
RATE_LIMIT_WINDOW = 60  # seconds


def get_client_ip(request: Request) -> str:
    """Get client IP address"""
    x_forwarded_for = request.headers.get("X-Forwarded-For")
    if x_forwarded_for:
        return x_forwarded_for.split(",")[0].strip()
    return request.client.host if request.client else "127.0.0.1"


def is_rate_limited(client_ip: str) -> bool:
    """Check if client is rate limited"""
    current_time = int(time.time())
    window_start = current_time - RATE_LIMIT_WINDOW

    if client_ip not in request_counts:
        request_counts[client_ip] = {}

    # Clean old entries
    request_counts[client_ip] = {
        timestamp: count
        for timestamp, count in request_counts[client_ip].items()
        if int(timestamp) > window_start
    }

    # Count requests in current window
    total_requests = sum(request_counts[client_ip].values())

    if total_requests >= RATE_LIMIT_REQUESTS:
        return True

    # Add current request
    timestamp_key = str(current_time)
    request_counts[client_ip][timestamp_key] = (
        request_counts[client_ip].get(timestamp_key, 0) + 1
    )

    return False


async def proxy_request(
    service_url: str,
    path: str,
    method: str,
    headers: dict,
    body: Optional[bytes] = None,
    params: Optional[dict] = None,
    user_create: Optional[UserCreate] = None,
    user_update: Optional[UserUpdate] = None,
    user_login: Optional[UserLogin] = None,
    emergency_contact_create: Optional[EmergencyContactCreate] = None,
    emergency_contact_update: Optional[EmergencyContactUpdate] = None
):
    """Proxy request to microservice"""
    url = f"{service_url}{path}"

    # Для отладки
    print(f"Proxy request to: {url}, method: {method}")
    
    if body:
        print(f"Request body: {body.decode('utf-8')[:100]}...")

    # Remove hop-by-hop headers
    filtered_headers = {
        k: v
        for k, v in headers.items()
        if k.lower()
        not in [
            "host",
            "connection",
            "upgrade",
            "proxy-connection",
            "proxy-authenticate",
            "proxy-authorization",
            "te",
            "trailers",
            "transfer-encoding",
        ]
    }

    async with httpx.AsyncClient(timeout=30.0) as client:
        try:
            response = await client.request(
                method=method,
                url=url,
                headers=filtered_headers,
                content=body,
                params=params,
            )
            
            # Для отладки
            print(f"Response status: {response.status_code}")
            if response.status_code >= 400:
                print(f"Error response: {response.text}")
            
            return response
        except httpx.TimeoutException:
            print(f"Timeout error for {url}")
            raise HTTPException(status_code=504, detail="Service timeout")
        except httpx.ConnectError:
            print(f"Connection error for {url}")
            raise HTTPException(status_code=503, detail="Service unavailable")
        except Exception as e:
            print(f"Proxy error for {url}: {str(e)}")
            raise HTTPException(status_code=500, detail=f"Proxy error: {str(e)}")


@app.middleware("http")
async def rate_limiting_middleware(request: Request, call_next):
    """Rate limiting middleware"""
    client_ip = get_client_ip(request)

    # Skip rate limiting for health checks
    if request.url.path.endswith("/health"):
        return await call_next(request)

    if is_rate_limited(client_ip):
        return JSONResponse(status_code=429, content={"detail": "Rate limit exceeded"})

    return await call_next(request)


# Authentication routes
@app.post("/api/v1/auth/register", response_model=UserResponse, tags=["Authentication"], summary="Register a new user")
async def register_user(user_create: UserCreate, request: Request):
    """Register a new user"""
    async with httpx.AsyncClient(timeout=30.0) as client:
        try:
            response = await client.post(
                f"{SERVICES['users']}/api/v1/auth/register",
                json=user_create.model_dump(),
                headers={
                    "Content-Type": "application/json",
                    "Accept": "application/json"
                }
            )
            
            if response.status_code == 200:
                return response.json()
            elif response.status_code == 400:
                # Handle specific registration errors
                try:
                    error_json = response.json()
                    error_detail = error_json.get("detail", "Registration failed")
                    if "Email already registered" in error_detail:
                        raise HTTPException(
                            status_code=400, 
                            detail=f"Email {user_create.email} is already registered. Please use a different email or try logging in."
                        )
                    elif "Username already taken" in error_detail:
                        raise HTTPException(
                            status_code=400,
                            detail=f"Username {user_create.username} is already taken. Please choose a different username."
                        )
                    else:
                        raise HTTPException(status_code=400, detail=error_detail)
                except ValueError:
                    # JSON parsing failed
                    raise HTTPException(
                        status_code=400, 
                        detail="Registration failed. Please check your input data."
                    )
            else:
                error_detail = "Registration failed"
                try:
                    error_json = response.json()
                    error_detail = error_json.get("detail", error_detail)
                except:
                    pass
                raise HTTPException(status_code=response.status_code, detail=error_detail)
                
        except HTTPException:
            raise
        except Exception as e:
            raise HTTPException(
                status_code=500, 
                detail=f"Registration service error: {str(e)}"
            )


@app.post("/api/v1/auth/login", response_model=Token, tags=["Authentication"], summary="Login user")
async def login_user(user_login: UserLogin, request: Request):
    """Login user"""
    client_ip = get_client_ip(request)
    print(f"Login request from {client_ip}: {user_login.model_dump(exclude={'password'})}")
    
    async with httpx.AsyncClient(timeout=30.0) as client:
        try:
            login_data = user_login.model_dump()
            print(f"Sending login data to user service: {login_data}")
            
            response = await client.post(
                f"{SERVICES['users']}/api/v1/auth/login",
                json=login_data,
                headers={
                    "Content-Type": "application/json",
                    "Accept": "application/json"
                }
            )
            
            print(f"User service response: status={response.status_code}")
            if response.status_code >= 400:
                print(f"Error response body: {response.text}")
            
            if response.status_code == 200:
                return response.json()
            elif response.status_code == 422:
                # Detailed handling for validation errors
                try:
                    error_json = response.json()
                    print(f"Validation error details: {error_json}")
                    # Return more detailed validation errors
                    if "detail" in error_json:
                        detail = error_json["detail"]
                        if isinstance(detail, list):
                            # FastAPI validation errors
                            formatted_errors = []
                            for error in detail:
                                field = error.get("loc", ["unknown"])[-1]
                                msg = error.get("msg", "Invalid value")
                                formatted_errors.append(f"{field}: {msg}")
                            raise HTTPException(
                                status_code=422, 
                                detail=f"Validation errors: {'; '.join(formatted_errors)}"
                            )
                        else:
                            raise HTTPException(status_code=422, detail=detail)
                    else:
                        raise HTTPException(status_code=422, detail="Invalid input data")
                except ValueError as ve:
                    print(f"JSON parse error: {ve}")
                    raise HTTPException(status_code=422, detail="Invalid request format")
            else:
                error_detail = response.text
                try:
                    error_json = response.json()
                    error_detail = error_json.get("detail", error_detail)
                except:
                    pass
                raise HTTPException(status_code=response.status_code, detail=error_detail)
                
        except HTTPException:
            raise
        except Exception as e:
            print(f"Login service error: {str(e)}")
            raise HTTPException(status_code=500, detail=f"Login error: {str(e)}")


# Utility endpoints
@app.get("/api/v1/auth/check-email", tags=["Authentication"], summary="Check if email is available")
async def check_email_availability(email: str):
    """Check if email is available for registration"""
    async with httpx.AsyncClient(timeout=10.0) as client:
        try:
            # Make request to user service to check if email exists
            response = await client.get(
                f"{SERVICES['users']}/api/v1/check-email",
                params={"email": email}
            )
            if response.status_code == 200:
                return response.json()
            else:
                return {"available": True, "message": "Email is available"}
        except Exception:
            return {"available": True, "message": "Unable to check availability"}


@app.get("/api/v1/auth/generate-test-data", tags=["Development"], summary="Generate test user data")
async def generate_test_user_data():
    """Generate unique test user data for development"""
    import random
    import string
    
    # Generate unique email with timestamp
    from datetime import datetime
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    random_suffix = ''.join(random.choices(string.ascii_lowercase + string.digits, k=4))
    
    return {
        "email": f"test_{timestamp}_{random_suffix}@example.com",
        "username": f"testuser_{timestamp}_{random_suffix}",
        "password": "TestPassword123!",
        "first_name": "Test",
        "last_name": "User",
        "phone": f"+123456{random.randint(1000, 9999)}"
    }


# User Service routes
@app.post("/api/v1/users/register", operation_id="user_register", response_model=UserResponse, tags=["Users"], summary="Register a new user")
@app.get("/api/v1/users/me", operation_id="user_me_get", response_model=UserResponse, tags=["Users"], summary="Get current user profile")
@app.patch("/api/v1/users/me", operation_id="user_me_patch", response_model=UserResponse, tags=["Users"], summary="Update user profile")
@app.put("/api/v1/users/me", operation_id="user_me_put", response_model=UserResponse, tags=["Users"], summary="Update user profile")
@app.get("/api/v1/users/me/emergency-contacts", operation_id="user_emergency_contacts_get", response_model=List[EmergencyContactResponse], tags=["Emergency Contacts"], summary="Get all emergency contacts")
@app.post("/api/v1/users/me/emergency-contacts", operation_id="user_emergency_contacts_post", response_model=EmergencyContactResponse, tags=["Emergency Contacts"], summary="Create a new emergency contact")
@app.get("/api/v1/users/me/emergency-contacts/{contact_id}", operation_id="user_emergency_contact_get", response_model=EmergencyContactResponse, tags=["Emergency Contacts"], summary="Get emergency contact by ID")
@app.delete("/api/v1/users/me/emergency-contacts/{contact_id}", operation_id="user_emergency_contact_delete", tags=["Emergency Contacts"], summary="Delete emergency contact")
@app.patch("/api/v1/users/me/emergency-contacts/{contact_id}", operation_id="user_emergency_contact_patch", response_model=EmergencyContactResponse, tags=["Emergency Contacts"], summary="Update emergency contact")
@app.get("/api/v1/users/dashboard", operation_id="user_dashboard_get", tags=["Users"])
@app.post("/api/v1/users/me/change-password", operation_id="user_change_password", tags=["Users"])
@app.get("/api/v1/profile", operation_id="user_profile_get", response_model=UserResponse, tags=["Users"])
@app.put("/api/v1/profile", operation_id="user_profile_update", response_model=UserResponse, tags=["Users"])
async def user_service_proxy(
    request: Request,
    user_create: Optional[UserCreate] = None,
    user_login: Optional[UserLogin] = None,
    user_update: Optional[UserUpdate] = None,
    emergency_contact_create: Optional[EmergencyContactCreate] = None,
    emergency_contact_update: Optional[EmergencyContactUpdate] = None
):
    """Proxy requests to User Service"""
    body = await request.body()
    print(f"User service proxy: {request.url.path}, method: {request.method}")
    try:
        response = await proxy_request(
            SERVICES["users"],
            request.url.path,
            request.method,
            dict(request.headers),
            body,
            dict(request.query_params),
            user_create=user_create,
            user_login=user_login,
            user_update=user_update,
            emergency_contact_create=emergency_contact_create,
            emergency_contact_update=emergency_contact_update
        )
        
        try:
            response_json = response.json()
            return JSONResponse(
                status_code=response.status_code,
                content=response_json,
                headers={
                    k: v
                    for k, v in response.headers.items()
                    if k.lower() not in ["content-length", "transfer-encoding"]
                },
            )
        except Exception as e:
            print(f"Error processing JSON response: {str(e)}")
            print(f"Response text: {response.text}")
            return JSONResponse(
                status_code=500,
                content={"detail": f"Error processing response: {str(e)}"},
            )
    except Exception as e:
        print(f"Error in user_service_proxy: {str(e)}")
        return JSONResponse(
            status_code=500,
            content={"detail": f"Proxy error: {str(e)}"},
        )


# Emergency Service routes
@app.api_route("/api/v1/emergency/alerts", methods=["POST"], operation_id="emergency_alerts_post")
@app.api_route("/api/v1/emergency/alerts", methods=["GET"], operation_id="emergency_alerts_get")
@app.api_route("/api/v1/emergency/alerts/my", methods=["GET"], operation_id="emergency_alerts_my_get")
@app.api_route("/api/v1/emergency/alerts/nearby", methods=["GET"], operation_id="emergency_alerts_nearby_get")
@app.api_route("/api/v1/emergency/alerts/{alert_id}", methods=["GET"], operation_id="emergency_alert_get")
@app.api_route("/api/v1/emergency/alerts/{alert_id}", methods=["PATCH"], operation_id="emergency_alert_patch")
@app.api_route("/api/v1/emergency/alerts/{alert_id}", methods=["DELETE"], operation_id="emergency_alert_delete")
@app.api_route("/api/v1/emergency/alerts/{alert_id}/cancel", methods=["PATCH"], operation_id="emergency_alert_cancel")
@app.api_route("/api/v1/emergency/reports", methods=["POST"], operation_id="emergency_reports_post")
@app.api_route("/api/v1/emergency/reports", methods=["GET"], operation_id="emergency_reports_get")
@app.api_route("/api/v1/emergency/reports/nearby", methods=["GET"], operation_id="emergency_reports_nearby_get")
@app.api_route("/api/v1/emergency/reports/{report_id}", methods=["GET"], operation_id="emergency_report_get")
@app.api_route("/api/v1/emergency/reports/{report_id}", methods=["PATCH"], operation_id="emergency_report_patch")
@app.api_route("/api/v1/emergency/reports/{report_id}", methods=["DELETE"], operation_id="emergency_report_delete")
async def emergency_service_proxy(request: Request):
    """Proxy requests to Emergency Service"""
    body = await request.body()
    response = await proxy_request(
        SERVICES["emergency"],
        request.url.path,
        request.method,
        dict(request.headers),
        body,
        dict(request.query_params),
    )
    return JSONResponse(
        status_code=response.status_code,
        content=response.json(),
        headers={
            k: v
            for k, v in response.headers.items()
            if k.lower() not in ["content-length", "transfer-encoding"]
        },
    )


# Location Service routes
@app.api_route("/api/v1/locations/update", methods=["POST"], operation_id="location_update_post")
@app.api_route("/api/v1/locations/last", methods=["GET"], operation_id="location_last_get")
@app.api_route("/api/v1/locations/history", methods=["GET"], operation_id="location_history_get")
@app.api_route("/api/v1/locations/users/nearby", methods=["GET"], operation_id="location_users_nearby_get")
@app.api_route("/api/v1/locations/safe-places", methods=["GET"], operation_id="location_safe_places_get")
@app.api_route("/api/v1/locations/safe-places", methods=["POST"], operation_id="location_safe_places_post")
@app.api_route("/api/v1/locations/safe-places/{place_id}", methods=["GET"], operation_id="location_safe_place_get")
@app.api_route("/api/v1/locations/safe-places/{place_id}", methods=["PATCH"], operation_id="location_safe_place_patch")
@app.api_route("/api/v1/locations/safe-places/{place_id}", methods=["DELETE"], operation_id="location_safe_place_delete")
async def location_service_proxy(request: Request):
    """Proxy requests to Location Service"""
    body = await request.body()
    response = await proxy_request(
        SERVICES["location"],
        request.url.path,
        request.method,
        dict(request.headers),
        body,
        dict(request.query_params),
    )
    return JSONResponse(
        status_code=response.status_code,
        content=response.json(),
        headers={
            k: v
            for k, v in response.headers.items()
            if k.lower() not in ["content-length", "transfer-encoding"]
        },
    )


# Calendar Service routes
@app.api_route("/api/v1/calendar/entries", methods=["GET"], operation_id="calendar_entries_get")
@app.api_route("/api/v1/calendar/entries", methods=["POST"], operation_id="calendar_entries_post")
@app.api_route("/api/v1/calendar/entries/{entry_id}", methods=["GET"], operation_id="calendar_entry_get")
@app.api_route("/api/v1/calendar/entries/{entry_id}", methods=["PUT"], operation_id="calendar_entry_put")
@app.api_route("/api/v1/calendar/entries/{entry_id}", methods=["DELETE"], operation_id="calendar_entry_delete")
@app.api_route("/api/v1/calendar/cycle-overview", methods=["GET"], operation_id="calendar_cycle_overview_get")
@app.api_route("/api/v1/calendar/insights", methods=["GET"], operation_id="calendar_insights_get")
@app.api_route("/api/v1/calendar/reminders", methods=["GET"], operation_id="calendar_reminders_get")
@app.api_route("/api/v1/calendar/reminders", methods=["POST"], operation_id="calendar_reminders_post")
@app.api_route("/api/v1/calendar/settings", methods=["GET"], operation_id="calendar_settings_get")
@app.api_route("/api/v1/calendar/settings", methods=["PUT"], operation_id="calendar_settings_put")
async def calendar_service_proxy(request: Request):
    """Proxy requests to Calendar Service"""
    body = await request.body()
    response = await proxy_request(
        SERVICES["calendar"],
        request.url.path,
        request.method,
        dict(request.headers),
        body,
        dict(request.query_params),
    )
    return JSONResponse(
        status_code=response.status_code,
        content=response.json(),
        headers={
            k: v
            for k, v in response.headers.items()
            if k.lower() not in ["content-length", "transfer-encoding"]
        },
    )


# Notification Service routes
@app.api_route("/api/v1/notifications/devices", methods=["GET"], operation_id="notifications_devices_get")
@app.api_route("/api/v1/notifications/devices", methods=["POST"], operation_id="notifications_devices_post")
@app.api_route("/api/v1/notifications/devices/{device_id}", methods=["DELETE"], operation_id="notifications_device_delete")
@app.api_route("/api/v1/notifications/devices/{device_id}", methods=["GET"], operation_id="notifications_device_get")
@app.api_route("/api/v1/notifications/preferences", methods=["GET"], operation_id="notifications_preferences_get")
@app.api_route("/api/v1/notifications/preferences", methods=["POST"], operation_id="notifications_preferences_post")
@app.api_route("/api/v1/notifications/test", methods=["POST"], operation_id="notifications_test_post")
@app.api_route("/api/v1/notifications/history", methods=["GET"], operation_id="notifications_history_get")
async def notification_service_proxy(request: Request):
    """Proxy requests to Notification Service"""
    body = await request.body()
    response = await proxy_request(
        SERVICES["notifications"],
        request.url.path,
        request.method,
        dict(request.headers),
        body,
        dict(request.query_params),
    )
    return JSONResponse(
        status_code=response.status_code,
        content=response.json(),
        headers={
            k: v
            for k, v in response.headers.items()
            if k.lower() not in ["content-length", "transfer-encoding"]
        },
    )


@app.get("/api/v1/health")
async def gateway_health_check():
    """Gateway health check"""
    return {"status": "healthy", "service": "api-gateway"}


@app.get("/api/v1/services-status")
async def check_services_status():
    """Check status of all microservices"""
    service_status = {}

    async def check_service(name: str, url: str):
        try:
            async with httpx.AsyncClient(timeout=5.0) as client:
                response = await client.get(f"{url}/api/v1/health")
                service_status[name] = {
                    "status": "healthy" if response.status_code == 200 else "unhealthy",
                    "response_time_ms": response.elapsed.total_seconds() * 1000,
                    "url": url,
                }
        except Exception as e:
            service_status[name] = {"status": "unhealthy", "error": str(e), "url": url}

    # Check all services concurrently
    tasks = [check_service(name, url) for name, url in SERVICES.items()]
    await asyncio.gather(*tasks)

    all_healthy = all(
        status["status"] == "healthy" for status in service_status.values()
    )

    return {
        "gateway_status": "healthy",
        "all_services_healthy": all_healthy,
        "services": service_status,
    }


@app.get("/")
async def root():
    """Root endpoint with API information"""
    return {
        "service": "Women Safety App API Gateway",
        "version": "1.0.0",
        "status": "running",
        "endpoints": {
            "auth": "/api/v1/auth/register, /api/v1/auth/login",
            "users": "/api/v1/users/me, /api/v1/users/dashboard",
            "emergency": "/api/v1/emergency/alerts, /api/v1/emergency/reports",
            "location": "/api/v1/locations/update, /api/v1/locations/safe-places",
            "calendar": "/api/v1/calendar/entries, /api/v1/calendar/cycle-overview",
            "notifications": "/api/v1/notifications/devices, /api/v1/notifications/history",
        },
        "docs": "/docs",
    }


# Переопределение схемы OpenAPI
def custom_openapi():
    if app.openapi_schema:
        return app.openapi_schema
    
    openapi_schema = get_openapi(
        title="Women's Safety App API Gateway",
        version="1.0.0",
        description="API Gateway для Women's Safety App с поддержкой микросервисной архитектуры",
        routes=app.routes,
    )
    
    # Добавление примеров запросов для маршрутов
    if "paths" in openapi_schema:
        if "/api/v1/auth/register" in openapi_schema["paths"]:
            request_example = {
                "username": "user123",
                "email": "user@example.com",
                "password": "Password123!",
                "full_name": "John Doe",
                "phone_number": "+7123456789"
            }
            path_item = openapi_schema["paths"]["/api/v1/auth/register"]
            for method in path_item:
                if "requestBody" in path_item[method]:
                    path_item[method]["requestBody"]["content"]["application/json"]["example"] = request_example
        
        if "/api/v1/auth/login" in openapi_schema["paths"]:
            login_example = {
                "username": "user123",
                "password": "Password123!"
            }
            path_item = openapi_schema["paths"]["/api/v1/auth/login"]
            for method in path_item:
                if "requestBody" in path_item[method]:
                    path_item[method]["requestBody"]["content"]["application/json"]["example"] = login_example
    
    app.openapi_schema = openapi_schema
    return app.openapi_schema

app.openapi = custom_openapi

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8000)