from typing import List
from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession
from fastapi import APIRouter, Depends, HTTPException

from src.core.database import get_db
from src.models.empresas import Empresa
from src.core.auth import require_enterprise_or_front
from src.services.classificacao import ClassifierService
from src.crud.classificacao import crud as classifier_crud
from src.schemas.classificacao import (
    ClassifierSchema,
    ClassifierCreate,
    ClassifierUpdate
)

router = APIRouter(tags=["Classificação"])


@router.get(
    "/classificar",
    summary="Classificações",
    responses={
        200: {
            "description": (
                "Atividades classificadas recuperadas com sucesso."
            )},
        500: {
            "description": "Erro interno do servidor"},
    },
    response_model=List[ClassifierSchema],
)
async def get_classifiers(
    db: AsyncSession = Depends(get_db),
    auth: dict = Depends(require_enterprise_or_front),
):
    return await ClassifierService.get_classifiers(db)


@router.post(
    "/classificar",
    summary="Criar classificações",
    responses={
        201: {"description": "Classificações criadas com sucesso."},
        400: {"description": "Erro na criação das classificações."},
        500: {"description": "Erro interno do servidor"},
    },
    response_model=List[ClassifierSchema],
)
async def create_classificacoes(
    items: List[ClassifierCreate],
    db: AsyncSession = Depends(get_db),
    auth: dict = Depends(require_enterprise_or_front),
):
    empresas_nomes = {item.empresa for item in items}
    for nome in empresas_nomes:
        result = await db.execute(
            select(Empresa).where(Empresa.nomeFantasia == nome)
        )
        empresa = result.scalars().one_or_none()
        if not empresa:
            raise HTTPException(
                status_code=400,
                detail=f"Empresa '{nome}' não encontrada."
            )

    try:
        created = await classifier_crud.create_classifiers(db, items)
        return created
    except Exception as e:
        raise HTTPException(
            status_code=400,
            detail=f"Erro ao criar classificações: {str(e)}"
        )


@router.patch(
    "/classificar/{empresa}/{sistema}",
    summary="Atualizar classificação",
    responses={
        200: {"description": "Classificação atualizada com sucesso."},
        404: {"description": "Classificação não encontrada."},
        500: {"description": "Erro interno do servidor"},
    },
    response_model=ClassifierSchema,
)
async def update_classificacao(
    empresa: str,
    sistema: str,
    update_data: ClassifierUpdate,
    db: AsyncSession = Depends(get_db),
    auth: dict = Depends(require_enterprise_or_front),
):
    updated = await ClassifierService.update_classifier(
        db,
        empresa,
        sistema,
        update_data
    )
    if not updated:
        raise HTTPException(
            status_code=404,
            detail="Classificação não encontrada."
        )
    return updated