"""
API endpoints для получения AI заключений от GigaAM API
"""
from fastapi import APIRouter, HTTPException
from pydantic import BaseModel
from typing import Optional, List, Dict, Any
from apiApp.database import get_db_session
from apiApp.database.Audio import Audio
from apiApp.database.AiConclusion import AiConclusion
from datetime import datetime
import logging
import uuid

logger = logging.getLogger(__name__)
ai_conclusion_router = APIRouter()


class AiConclusionRequest(BaseModel):
    """Модель запроса для сохранения AI заключения"""
    filename: str
    transcription: str
    corrected_transcription: str
    analysis: Dict[str, Any]
    segments: Optional[List[Dict[str, Any]]] = []
    processing_time_seconds: Optional[float] = 0


class AiConclusionResponse(BaseModel):
    """Модель ответа"""
    success: bool
    message: Optional[str] = None
    audio_id: Optional[str] = None
    filename: Optional[str] = None
    error: Optional[str] = None


@ai_conclusion_router.post("/conclusion/save", response_model=AiConclusionResponse)
async def save_ai_conclusion(request: AiConclusionRequest):
    """
    Сохраняет AI заключение от GigaAM API

    **Параметры:**
    - **filename**: Имя файла (например, "in-xxx.wav")
    - **transcription**: Исходная транскрибация
    - **corrected_transcription**: Исправленная транскрибация
    - **analysis**: Результат анализа (sentiment, topics, summary)
    - **segments**: Сегменты диалога (опционально)
    - **processing_time_seconds**: Время обработки (опционально)
    """
    try:
        logger.info(f"📥 Получено AI заключение для файла: {request.filename}")

        with get_db_session() as db:
            # Находим аудио файл по имени
            audio = db.query(Audio).filter(Audio.filename == request.filename).first()

            if not audio:
                logger.warning(f"⚠️ Файл {request.filename} не найден в БД")
                raise HTTPException(
                    status_code=404,
                    detail=f'Файл {request.filename} не найден'
                )

            # Проверяем, есть ли уже заключение
            existing_conclusion = db.query(AiConclusion).filter(
                AiConclusion.audio_id == audio.id
            ).first()

            conclusion_data = {
                "transcription": request.transcription,
                "ai_transcription": request.corrected_transcription,
                "conclusion": request.analysis,
                "segments": request.segments,
                "processing_time_seconds": request.processing_time_seconds
            }

            if existing_conclusion:
                # Обновляем существующее заключение
                logger.info(f"🔄 Обновление существующего заключения для {request.filename}")
                existing_conclusion.conclusion = conclusion_data
                existing_conclusion.end_date = datetime.utcnow()
            else:
                # Создаём новое заключение
                logger.info(f"✅ Создание нового заключения для {request.filename}")
                new_conclusion = AiConclusion(
                    audio_id=audio.id,
                    conclusion=conclusion_data,
                    index_date=datetime.utcnow()
                )
                db.add(new_conclusion)

            db.commit()
            logger.info(f"✅ Заключение сохранено для {request.filename}")

            return AiConclusionResponse(
                success=True,
                message='Заключение сохранено',
                audio_id=str(audio.id),
                filename=request.filename
            )

    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"❌ Ошибка при сохранении заключения: {e}")
        raise HTTPException(
            status_code=500,
            detail=str(e)
        )