"""
FastAPI routes for persona management.
Integrates persona generation and management into the main API.
"""

from fastapi import APIRouter, HTTPException, Query
from typing import Dict, Any, Optional

from api.persona import (
    generate_persona,
    get_user_personas,
    get_persona_details,
    get_platform_persona,
    update_persona,
    delete_persona,
    validate_persona_generation_readiness,
    generate_persona_preview,
    get_supported_platforms,
    PersonaGenerationRequest
)

from services.persona_replication_engine import PersonaReplicationEngine

# Create router
router = APIRouter(prefix="/api/personas", tags=["personas"])

@router.post("/generate")
async def generate_persona_endpoint(
    request: PersonaGenerationRequest,
    user_id: int = Query(1, description="User ID")
):
    """Generate a new writing persona from onboarding data."""
    return await generate_persona(user_id, request)

@router.get("/user/{user_id}")
async def get_user_personas_endpoint(user_id: int):
    """Get all personas for a user."""
    return await get_user_personas(user_id)

@router.get("/{persona_id}")
async def get_persona_details_endpoint(
    persona_id: int,
    user_id: int = Query(..., description="User ID")
):
    """Get detailed information about a specific persona."""
    return await get_persona_details(user_id, persona_id)

@router.get("/platform/{platform}")
async def get_platform_persona_endpoint(
    platform: str,
    user_id: int = Query(1, description="User ID")
):
    """Get persona adaptation for a specific platform."""
    return await get_platform_persona(user_id, platform)

@router.put("/{persona_id}")
async def update_persona_endpoint(
    persona_id: int,
    update_data: Dict[str, Any],
    user_id: int = Query(..., description="User ID")
):
    """Update an existing persona."""
    return await update_persona(user_id, persona_id, update_data)

@router.delete("/{persona_id}")
async def delete_persona_endpoint(
    persona_id: int,
    user_id: int = Query(..., description="User ID")
):
    """Delete a persona."""
    return await delete_persona(user_id, persona_id)

@router.get("/check/readiness")
async def check_persona_readiness_endpoint(
    user_id: int = Query(1, description="User ID")
):
    """Check if user has sufficient data for persona generation."""
    return await validate_persona_generation_readiness(user_id)

@router.get("/preview/generate")
async def generate_preview_endpoint(
    user_id: int = Query(1, description="User ID")
):
    """Generate a preview of the writing persona without saving."""
    return await generate_persona_preview(user_id)

@router.get("/platforms/supported")
async def get_supported_platforms_endpoint():
    """Get list of supported platforms for persona generation."""
    return await get_supported_platforms()

@router.post("/generate-content")
async def generate_content_with_persona_endpoint(
    request: Dict[str, Any]
):
    """Generate content using persona replication engine."""
    try:
        user_id = request.get("user_id", 1)
        platform = request.get("platform")
        content_request = request.get("content_request")
        content_type = request.get("content_type", "post")
        
        if not platform or not content_request:
            raise HTTPException(status_code=400, detail="Platform and content_request are required")
        
        engine = PersonaReplicationEngine()
        result = engine.generate_content_with_persona(
            user_id=user_id,
            platform=platform,
            content_request=content_request,
            content_type=content_type
        )
        
        return result
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Content generation failed: {str(e)}")

@router.get("/export/{platform}")
async def export_persona_prompt_endpoint(
    platform: str,
    user_id: int = Query(1, description="User ID")
):
    """Export hardened persona prompt for external use."""
    try:
        engine = PersonaReplicationEngine()
        export_package = engine.export_persona_for_external_use(user_id, platform)
        
        if "error" in export_package:
            raise HTTPException(status_code=400, detail=export_package["error"])
        
        return export_package
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Export failed: {str(e)}")

@router.post("/validate-content")
async def validate_content_endpoint(
    request: Dict[str, Any]
):
    """Validate content against persona constraints."""
    try:
        user_id = request.get("user_id", 1)
        platform = request.get("platform")
        content = request.get("content")
        
        if not platform or not content:
            raise HTTPException(status_code=400, detail="Platform and content are required")
        
        engine = PersonaReplicationEngine()
        persona_data = engine.persona_service.get_persona_for_platform(user_id, platform)
        
        if not persona_data:
            raise HTTPException(status_code=404, detail="No persona found for platform")
        
        validation_result = engine._validate_content_fidelity(content, persona_data, platform)
        
        return {
            "validation_result": validation_result,
            "persona_id": persona_data["core_persona"]["id"],
            "platform": platform
        }
        
    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Validation failed: {str(e)}")