from typing import List, Dict, Any

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.exc import SQLAlchemyError
from sqlalchemy.orm import Session

from app.api.schemas import (
    ChatRequest,
    ChatResponse,
    ConsultarEstoqueRequest,
    ValidarClienteVendaRequest,
    AvaliarVeiculoTrocaRequest,
    AgendarRevisaoRequest,
    CancelarPedidoRequest,
)
from app.db.database import SessionLocal
from app.services.orquestrador_service import OrquestradorService
from app.services.handlers import (
    consultar_estoque,
    validar_cliente_venda,
    avaliar_veiculo_troca,
    agendar_revisao,
    cancelar_pedido,
)

router = APIRouter()


def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


def _db_error_detail(exc: SQLAlchemyError) -> str:
    text = str(exc).lower()

    # Heuristica para identificar falhas no MySQL (base ficticia).
    mysql_markers = ("mysql", "pymysql", "(2003", "mock", "3306")
    if any(marker in text for marker in mysql_markers):
        return "Servico temporariamente indisponivel: banco MySQL (dados ficticios) inacessivel."

    # Heuristica para identificar falhas no PostgreSQL (tools).
    pg_markers = ("postgres", "psycopg", "postgresql", "5432", "tools")
    if any(marker in text for marker in pg_markers):
        return "Servico temporariamente indisponivel: banco PostgreSQL (tools) inacessivel."

    return "Servico temporariamente indisponivel: erro de acesso ao banco de dados."

'''
# Removido momentaniamente para teste do Vertex IA
@router.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest, db: Session = Depends(get_db)):
    service = OrquestradorService(db)
    result = await service.handle_message(
        message=request.message,
        user_id=request.user_id,
    )
    return ChatResponse(response=result)
'''
@router.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest, db: Session = Depends(get_db)):
    try:
        service = OrquestradorService(db)
        result = await service.handle_message(message=request.message)
        return ChatResponse(response=result)
    except SQLAlchemyError as exc:
        raise HTTPException(
            status_code=503,
            detail=_db_error_detail(exc),
        )
    except ValueError as exc:
        # Erros de configuracao de Vertex (regiao/projeto/modelo)
        raise HTTPException(status_code=500, detail=f"Configuracao invalida do Vertex AI: {exc}")
    except RuntimeError as exc:
        raise HTTPException(status_code=503, detail=f"Falha temporaria no LLM/Vertex AI: {exc}")


@router.post("/mock/consultar-estoque")
async def consultar_estoque_endpoint(
    body: ConsultarEstoqueRequest,
) -> List[Dict[str, Any]]:
    try:
        return await consultar_estoque(
            preco_max=body.preco_max,
            categoria=body.categoria,
            ordenar_preco=body.ordenar_preco,
            limite=body.limite,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=_db_error_detail(exc))


@router.post("/mock/validar-cliente-venda")
async def validar_cliente_venda_endpoint(
    body: ValidarClienteVendaRequest,
) -> Dict[str, Any]:
    try:
        return await validar_cliente_venda(
            cpf=body.cpf,
            valor_veiculo=body.valor_veiculo,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=_db_error_detail(exc))


@router.post("/mock/avaliar-veiculo-troca")
async def avaliar_veiculo_troca_endpoint(
    body: AvaliarVeiculoTrocaRequest,
) -> Dict[str, Any]:
    return await avaliar_veiculo_troca(
        modelo=body.modelo,
        ano=body.ano,
        km=body.km,
    )


@router.post("/mock/agendar-revisao")
async def agendar_revisao_endpoint(
    body: AgendarRevisaoRequest,
) -> Dict[str, Any]:
    try:
        return await agendar_revisao(
            placa=body.placa,
            data_hora=body.data_hora,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=_db_error_detail(exc))


@router.post("/mock/cancelar-pedido")
async def cancelar_pedido_endpoint(
    body: CancelarPedidoRequest,
) -> Dict[str, Any]:
    try:
        return await cancelar_pedido(
            numero_pedido=body.numero_pedido,
            motivo=body.motivo,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=_db_error_detail(exc))