src/landppt/api/global_master_template_api.py

"""
Global Master Template API endpoints
"""

import logging
from typing import List, Optional
from fastapi import APIRouter, HTTPException, Depends, Query, Request
from fastapi.responses import JSONResponse

from .models import (
    GlobalMasterTemplateCreate, GlobalMasterTemplateUpdate, GlobalMasterTemplateResponse,
    GlobalMasterTemplateDetailResponse, GlobalMasterTemplateGenerateRequest,
    TemplateSelectionRequest, TemplateSelectionResponse
)
from ..services.template.global_master_template_service import GlobalMasterTemplateService
from ..auth.middleware import get_current_user_required
from ..core.config import app_config
from ..database.database import AsyncSessionLocal
from ..services.credits_service import CreditsService

logger = logging.getLogger(__name__)

# Create router
router = APIRouter(prefix="/api/global-master-templates", tags=["Global Master Templates"])


def _template_service_for_user(
    user,
    *,
    allow_system_template_write: bool = False,
) -> GlobalMasterTemplateService:
    """Create a user-scoped template service instance."""
    return GlobalMasterTemplateService(
        user_id=user.id,
        allow_system_template_write=bool(
            allow_system_template_write and getattr(user, "is_admin", False)
        ),
    )


@router.post("/", response_model=GlobalMasterTemplateResponse)
async def create_template(
    template_data: GlobalMasterTemplateCreate,
    user=Depends(get_current_user_required),
):
    """Create a new global master template"""
    try:
        template_service = _template_service_for_user(user)
        payload = template_data.model_dump()
        if (payload.get("created_by") or "").strip().lower() == "user":
            payload["created_by"] = f"user:{user.id}"
        result = await template_service.create_template(payload)
        return GlobalMasterTemplateResponse(**result)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        logger.error(f"Failed to create template: {e}")
        raise HTTPException(status_code=500, detail="Failed to create template")


@router.get("/", response_model=dict)
async def get_all_templates(
    active_only: bool = Query(True, description="Only return active templates"),
    tags: Optional[str] = Query(None, description="Filter by tags (comma-separated)"),
    page: int = Query(1, ge=1, description="Page number (1-based)"),
    page_size: int = Query(6, ge=1, le=100, description="Number of items per page"),
    search: Optional[str] = Query(None, description="Search in template name and description"),
    user=Depends(get_current_user_required),
):
    """Get all global master templates with pagination"""
    try:
        template_service = _template_service_for_user(user)
        if tags:
            tag_list = [tag.strip() for tag in tags.split(",")]
            result = await template_service.get_templates_by_tags_paginated(
                tag_list, active_only, page, page_size, search
            )
        else:
            result = await template_service.get_all_templates_paginated(
                active_only, page, page_size, search
            )

        return {
            "templates": [GlobalMasterTemplateResponse(**template) for template in result["templates"]],
            "pagination": result["pagination"]
        }
    except Exception as e:
        logger.error(f"Failed to get templates: {e}")
        raise HTTPException(status_code=500, detail="Failed to get templates")


@router.put("/{template_id}", response_model=dict)
async def update_template(
    template_id: int,
    update_data: GlobalMasterTemplateUpdate,
    user=Depends(get_current_user_required),
):
    """Update a global master template"""
    try:
        template_service = _template_service_for_user(
            user,
            allow_system_template_write=True,
        )
        # Filter out None values
        update_dict = {k: v for k, v in update_data.model_dump().items() if v is not None}
        
        if not update_dict:
            raise HTTPException(status_code=400, detail="No update data provided")
        
        success = await template_service.update_template(template_id, update_dict)
        if not success:
            raise HTTPException(status_code=404, detail="Template not found")
        
        return {"success": True, "message": "Template updated successfully"}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to update template {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to update template")


@router.delete("/{template_id}", response_model=dict)
async def delete_template(template_id: int, user=Depends(get_current_user_required)):
    """Delete a global master template"""
    try:
        template_service = _template_service_for_user(
            user,
            allow_system_template_write=True,
        )
        success = await template_service.delete_template(template_id)
        if not success:
            raise HTTPException(status_code=404, detail="Template not found")
        
        return {"success": True, "message": "Template deleted successfully"}
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to delete template {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to delete template")


@router.post("/{template_id}/set-default", response_model=dict)
async def set_default_template(template_id: int, user=Depends(get_current_user_required)):
    """Set a template as the default template"""
    try:
        template_service = _template_service_for_user(
            user,
            allow_system_template_write=True,
        )
        success = await template_service.set_default_template(template_id)
        if not success:
            raise HTTPException(status_code=404, detail="Template not found")
        
        return {"success": True, "message": "Default template set successfully"}
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to set default template {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to set default template")


@router.get("/default/template", response_model=GlobalMasterTemplateDetailResponse)
async def get_default_template(user=Depends(get_current_user_required)):
    """Get the default global master template"""
    try:
        template_service = _template_service_for_user(user)
        template = await template_service.get_default_template()
        if not template:
            raise HTTPException(status_code=404, detail="No default template found")
        
        return GlobalMasterTemplateDetailResponse(**template)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to get default template: {e}")
        raise HTTPException(status_code=500, detail="Failed to get default template")


@router.get("/{template_id}", response_model=GlobalMasterTemplateDetailResponse)
async def get_template_by_id(template_id: int, user=Depends(get_current_user_required)):
    """Get a global master template by ID"""
    try:
        template_service = _template_service_for_user(user)
        template = await template_service.get_template_by_id(template_id)
        if not template:
            raise HTTPException(status_code=404, detail="Template not found")
        
        return GlobalMasterTemplateDetailResponse(**template)
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to get template {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to get template")


@router.post("/generate")
async def generate_template_with_ai(
    request: GlobalMasterTemplateGenerateRequest,
    user = Depends(get_current_user_required)
):
    """Generate a new template using AI (does not save to database)"""
    try:
        # Create service with user_id for proper landppt config handling
        user_template_service = GlobalMasterTemplateService(user_id=user.id)

        # Credits: only bill LandPPT official provider.
        provider_name = None
        if app_config.enable_credits_system:
            try:
                _, template_settings = await user_template_service._get_template_role_provider_async()
                provider_name = template_settings.get("provider")
            except Exception as e:
                logger.warning(f"Failed to resolve template provider for credits check: {e}")

            if (provider_name or "").strip().lower() == "landppt":
                async with AsyncSessionLocal() as session:
                    credits_service = CreditsService(session)
                    required = credits_service.get_operation_cost("template_generation", 1)
                    balance = await credits_service.get_balance(user.id)
                    if balance < required:
                        return {
                            "success": False,
                            "message": f"积分不足，模板生成需要{required}积分，当前余额{balance}积分",
                            "required": required,
                            "balance": balance,
                        }
        
        # 准备参考图片数据（支持多张）
        reference_images_data: list = []
        if request.reference_images:
            for img in request.reference_images:
                reference_images_data.append({
                    "filename": img.filename,
                    "data": img.data,
                    "size": img.size,
                    "type": img.type,
                })
        # Backward compat: single reference_image → list
        reference_image_data = None
        if request.reference_image:
            reference_image_data = {
                "filename": request.reference_image.filename,
                "data": request.reference_image.data,
                "size": request.reference_image.size,
                "type": request.reference_image.type,
            }
            if not reference_images_data:
                reference_images_data = [reference_image_data]
        reference_pptx_data = None
        if getattr(request, "reference_pptx", None):
            reference_pptx_data = {
                "filename": request.reference_pptx.filename,
                "data": request.reference_pptx.data,
                "size": request.reference_pptx.size,
                "type": request.reference_pptx.type,
            }

        # 使用AI生成服务（不保存到数据库）
        result = await user_template_service.generate_template_with_ai(
            prompt=request.prompt,
            template_name=request.template_name,
            description=request.description,
            tags=request.tags,
            generation_mode=request.generation_mode,
            reference_image=reference_image_data,
            reference_images=reference_images_data or None,
            reference_pptx=reference_pptx_data,
        )

        # Deduct credits after successful generation.
        if app_config.enable_credits_system and (provider_name or "").strip().lower() == "landppt":
            try:
                async with AsyncSessionLocal() as session:
                    credits_service = CreditsService(session)
                    await credits_service.consume_credits(
                        user_id=user.id,
                        operation_type="template_generation",
                        quantity=1,
                        description="AI模板生成",
                        reference_id=f"global_master_template:{request.template_name or ''}".rstrip(":"),
                    )
            except Exception as e:
                logger.error(f"Failed to consume credits for template generation: {e}")

        return {
            "success": True,
            "message": "模板生成完成！",
            "data": result
        }

    except Exception as e:
        logger.error(f"Failed to generate template with AI: {e}")
        raise HTTPException(status_code=500, detail=str(e))


@router.post("/save-generated", response_model=GlobalMasterTemplateResponse)
async def save_generated_template(
    request: dict,
    user=Depends(get_current_user_required),
):
    """Save a generated template after user confirmation"""
    try:
        template_service = _template_service_for_user(user)
        # Extract template data from request
        template_data = {
            'template_name': request.get('template_name'),
            'description': request.get('description', ''),
            'html_template': request.get('html_template'),
            'tags': request.get('tags', []),
            'created_by': 'AI'
        }

        # Add timestamp to avoid name conflicts
        import time
        timestamp = int(time.time())
        template_data['template_name'] = f"{template_data['template_name']}_{timestamp}"

        result = await template_service.create_template(template_data)
        return GlobalMasterTemplateResponse(**result)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except Exception as e:
        logger.error(f"Failed to save generated template: {e}")
        raise HTTPException(status_code=500, detail="Failed to save template")


@router.post("/adjust-template")
async def adjust_template(
    payload: dict,
    user=Depends(get_current_user_required),
    http_request: Request = None,
):
    """Adjust a generated template based on user feedback"""
    from fastapi.responses import StreamingResponse
    import json

    user_template_service = GlobalMasterTemplateService(user_id=user.id)

    template_data = payload.get("template_data") or {}
    current_html = (
        payload.get("html_template")
        or template_data.get("html_template")
        or template_data.get("html")
    )
    adjustment_request = (
        payload.get("adjustment_request")
        or payload.get("adjustment")
        or template_data.get("adjustment_request")
    )
    template_name = (
        payload.get("template_name")
        or template_data.get("template_name")
        or "模板"
    )

    # Decide response mode:
    # - SSE when the client explicitly asks (`Accept: text/event-stream`) or `stream=true`.
    accept = ((http_request.headers.get("accept") if http_request else "") or "").lower()
    stream_flag = payload.get("stream")
    want_stream = ("text/event-stream" in accept) or bool(stream_flag)

    if not (isinstance(current_html, str) and current_html.strip()):
        if want_stream:
            async def _err():
                yield f"data: {json.dumps({'type': 'error', 'message': 'html_template is required'})}\n\n"
            return StreamingResponse(_err(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
        raise HTTPException(status_code=400, detail="html_template is required")

    if not (isinstance(adjustment_request, str) and adjustment_request.strip()):
        if want_stream:
            async def _err():
                yield f"data: {json.dumps({'type': 'error', 'message': 'adjustment_request is required'})}\n\n"
            return StreamingResponse(_err(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
        raise HTTPException(status_code=400, detail="adjustment_request is required")

    provider_name = None
    required = 0
    balance = 0
    if app_config.enable_credits_system:
        try:
            _, template_settings = await user_template_service._get_template_role_provider_async()
            provider_name = template_settings.get("provider")
        except Exception as e:
            logger.warning(f"Failed to resolve template provider for credits check: {e}")

        if (provider_name or "").strip().lower() == "landppt":
            async with AsyncSessionLocal() as session:
                credits_service = CreditsService(session)
                required = credits_service.get_operation_cost("template_generation", 1)
                balance = await credits_service.get_balance(user.id)
                if balance < required:
                    message = f"积分不足，模板调整需要{required}积分，当前余额{balance}积分"
                    if want_stream:
                        async def _err():
                            yield f"data: {json.dumps({'type': 'error', 'message': message, 'required': required, 'balance': balance})}\n\n"
                        return StreamingResponse(_err(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"})
                    return {"success": False, "message": message, "required": required, "balance": balance}

    if want_stream:
        async def adjust_stream():
            try:
                # Send initial status
                yield f"data: {json.dumps({'type': 'status', 'message': '正在分析调整需求...'})}\n\n"

                credits_consumed = False
                async for chunk in user_template_service.adjust_template_with_ai_stream(
                    current_html=current_html,
                    adjustment_request=adjustment_request,
                    template_name=template_name,
                ):
                    if (
                        app_config.enable_credits_system
                        and (provider_name or "").strip().lower() == "landppt"
                        and (chunk or {}).get("type") == "complete"
                        and not credits_consumed
                    ):
                        try:
                            async with AsyncSessionLocal() as session:
                                credits_service = CreditsService(session)
                                await credits_service.consume_credits(
                                    user_id=user.id,
                                    operation_type="template_generation",
                                    quantity=1,
                                    description="AI模板调整",
                                    reference_id=f"global_master_template_adjust:{template_name}".rstrip(":"),
                                )
                            credits_consumed = True
                        except Exception as e:
                            logger.error(f"Failed to consume credits for template adjustment: {e}")

                    yield f"data: {json.dumps(chunk)}\n\n"

            except Exception as e:
                logger.error(f"Failed to adjust template: {e}")
                yield f"data: {json.dumps({'type': 'error', 'message': str(e)})}\n\n"

        return StreamingResponse(
            adjust_stream(),
            media_type="text/event-stream",
            headers={
                "Cache-Control": "no-cache",
                "Connection": "keep-alive",
            },
        )

    # Default: return JSON (more compatible with `apiClient` callers).
    complete_event = None
    async for chunk in user_template_service.adjust_template_with_ai_stream(
        current_html=current_html,
        adjustment_request=adjustment_request,
        template_name=template_name,
    ):
        if (chunk or {}).get("type") == "error":
            raise HTTPException(status_code=500, detail=(chunk or {}).get("message") or "Template adjustment failed")
        if (chunk or {}).get("type") == "complete" and (chunk or {}).get("html_template"):
            complete_event = chunk
            break

    if not complete_event:
        raise HTTPException(status_code=500, detail="Template adjustment failed")

    if app_config.enable_credits_system and (provider_name or "").strip().lower() == "landppt":
        try:
            async with AsyncSessionLocal() as session:
                credits_service = CreditsService(session)
                await credits_service.consume_credits(
                    user_id=user.id,
                    operation_type="template_generation",
                    quantity=1,
                    description="AI模板调整",
                    reference_id=f"global_master_template_adjust:{template_name}".rstrip(":"),
                )
        except Exception as e:
            logger.error(f"Failed to consume credits for template adjustment: {e}")

    return {"success": True, "data": complete_event}


@router.post("/select", response_model=TemplateSelectionResponse)
async def select_template_for_project(
    request: TemplateSelectionRequest,
    user=Depends(get_current_user_required),
):
    """Select a template for PPT generation"""
    try:
        template_service = _template_service_for_user(user)
        if request.selected_template_id:
            # Get the selected template
            template = await template_service.get_template_by_id(request.selected_template_id)
            if not template:
                raise HTTPException(status_code=404, detail="Selected template not found")
            
            # Increment usage count
            await template_service.increment_template_usage(request.selected_template_id)
            
            return TemplateSelectionResponse(
                success=True,
                message="Template selected successfully",
                selected_template=GlobalMasterTemplateResponse(**template)
            )
        else:
            # Use default template
            template = await template_service.get_default_template()
            if not template:
                raise HTTPException(status_code=404, detail="No default template found")
            
            # Increment usage count
            await template_service.increment_template_usage(template['id'])
            
            return TemplateSelectionResponse(
                success=True,
                message="Default template selected",
                selected_template=GlobalMasterTemplateResponse(**template)
            )
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to select template: {e}")
        raise HTTPException(status_code=500, detail="Failed to select template")


@router.post("/{template_id}/duplicate", response_model=GlobalMasterTemplateResponse)
async def duplicate_template(
    template_id: int,
    new_name: str = Query(..., description="New template name"),
    user=Depends(get_current_user_required),
):
    """Duplicate an existing template"""
    try:
        template_service = _template_service_for_user(user)
        # Get the original template
        original = await template_service.get_template_by_id(template_id)
        if not original:
            raise HTTPException(status_code=404, detail="Template not found")
        
        # Create duplicate data
        duplicate_data = {
            'template_name': new_name,
            'description': f"复制自: {original['template_name']}",
            'html_template': original['html_template'],
            'tags': original['tags'] + ['复制'],
            'created_by': 'duplicate'
        }
        
        result = await template_service.create_template(duplicate_data)
        return GlobalMasterTemplateResponse(**result)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to duplicate template {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to duplicate template")


@router.get("/{template_id}/preview", response_model=dict)
async def get_template_preview(template_id: int, user=Depends(get_current_user_required)):
    """Get template preview data"""
    try:
        template_service = _template_service_for_user(user)
        template = await template_service.get_template_by_id(template_id)
        if not template:
            raise HTTPException(status_code=404, detail="Template not found")
        
        return {
            "id": template['id'],
            "template_name": template['template_name'],
            "preview_image": template['preview_image'],
            "html_template": template['html_template']
        }
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to get template preview {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to get template preview")


# Add increment usage endpoint for internal use
@router.post("/{template_id}/increment-usage", response_model=dict)
async def increment_template_usage(template_id: int, user=Depends(get_current_user_required)):
    """Increment template usage count (internal use)"""
    try:
        template_service = _template_service_for_user(user)
        success = await template_service.increment_template_usage(template_id)
        if not success:
            raise HTTPException(status_code=404, detail="Template not found")
        
        return {"success": True, "message": "Usage count incremented"}
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Failed to increment usage for template {template_id}: {e}")
        raise HTTPException(status_code=500, detail="Failed to increment usage count")