"""
Feedback-related API endpoints.
"""

from typing import List, Dict, Any
from fastapi import APIRouter, HTTPException, Depends, status
from pydantic import BaseModel

from app.services.prompt_service import PromptService
from app.models.prompt import FeedbackWord, RateFeedbackWordsRequest, RateFeedbackWordsResponse

# Create router
router = APIRouter()

# Response models
class GenerateFeedbackWordsResponse(BaseModel):
    """Response model for generating feedback words."""
    theme_words: List[str]
    count: int = 6

class FeedbackQueuedWordsResponse(BaseModel):
    """Response model for queued feedback words."""
    queued_words: List[FeedbackWord]
    count: int

class FeedbackActiveWordsResponse(BaseModel):
    """Response model for active feedback words."""
    active_words: List[FeedbackWord]
    count: int

class FeedbackHistoricResponse(BaseModel):
    """Response model for full feedback history."""
    feedback_history: List[Dict[str, Any]]
    count: int

# Service dependency
async def get_prompt_service() -> PromptService:
    """Dependency to get PromptService instance."""
    return PromptService()

@router.get("/queued", response_model=FeedbackQueuedWordsResponse)
async def get_queued_feedback_words(
    prompt_service: PromptService = Depends(get_prompt_service)
):
    """
    Get queued feedback words (positions 0-5) for user weighting.

    Returns:
        List of queued feedback words with weights
    """
    try:
        # Get queued feedback words from PromptService
        queued_feedback_items = await prompt_service.get_feedback_queued_words()

        # Convert to FeedbackWord models
        queued_words = []
        for i, item in enumerate(queued_feedback_items):
            key = list(item.keys())[0]
            word = item[key]
            weight = item.get("weight", 3)  # Default weight is 3
            queued_words.append(FeedbackWord(key=key, word=word, weight=weight))

        return FeedbackQueuedWordsResponse(
            queued_words=queued_words,
            count=len(queued_words)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error getting queued feedback words: {str(e)}"
        )

@router.get("/active", response_model=FeedbackActiveWordsResponse)
async def get_active_feedback_words(
    prompt_service: PromptService = Depends(get_prompt_service)
):
    """
    Get active feedback words (positions 6-11) for prompt generation.

    Returns:
        List of active feedback words with weights
    """
    try:
        # Get active feedback words from PromptService
        active_feedback_items = await prompt_service.get_feedback_active_words()

        # Convert to FeedbackWord models
        active_words = []
        for i, item in enumerate(active_feedback_items):
            key = list(item.keys())[0]
            word = item[key]
            weight = item.get("weight", 3)  # Default weight is 3
            active_words.append(FeedbackWord(key=key, word=word, weight=weight))

        return FeedbackActiveWordsResponse(
            active_words=active_words,
            count=len(active_words)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error getting active feedback words: {str(e)}"
        )

@router.get("/generate", response_model=GenerateFeedbackWordsResponse)
async def generate_feedback_words(
    prompt_service: PromptService = Depends(get_prompt_service)
):
    """
    Generate 6 theme feedback words using AI.

    Returns:
        List of 6 theme words for feedback
    """
    try:
        theme_words = await prompt_service.generate_theme_feedback_words()

        if len(theme_words) != 6:
            raise HTTPException(
                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                detail=f"Expected 6 theme words, got {len(theme_words)}"
            )

        return GenerateFeedbackWordsResponse(
            theme_words=theme_words,
            count=len(theme_words)
        )
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=str(e)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error generating feedback words: {str(e)}"
        )

@router.post("/rate", response_model=RateFeedbackWordsResponse)
async def rate_feedback_words(
    request: RateFeedbackWordsRequest,
    prompt_service: PromptService = Depends(get_prompt_service)
):
    """
    Rate feedback words and update feedback system.

    Args:
        request: Dictionary of word to rating (0-6)

    Returns:
        Updated feedback words
    """
    try:
        feedback_words = await prompt_service.update_feedback_words(request.ratings)

        return RateFeedbackWordsResponse(
            feedback_words=feedback_words,
            added_to_history=True
        )
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=str(e)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error rating feedback words: {str(e)}"
        )

@router.get("/history", response_model=FeedbackHistoricResponse)
async def get_feedback_history(
    prompt_service: PromptService = Depends(get_prompt_service)
):
    """
    Get full feedback word history.

    Returns:
        Full feedback history with weights
    """
    try:
        feedback_historic = await prompt_service.get_feedback_historic()

        return FeedbackHistoricResponse(
            feedback_history=feedback_historic,
            count=len(feedback_historic)
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Error getting feedback history: {str(e)}"
        )