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():
    """Fornece uma sessao de banco para a request e garante o fechamento."""
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()


def _db_error_detail(exc: SQLAlchemyError) -> str:
    """Converte erros de banco em mensagens amigaveis para a API."""
    text = str(exc).lower()

    # Heuristica para identificar falhas no MySQL de tools.
    tools_markers = ("tools", "tool")
    if any(marker in text for marker in tools_markers):
        return "Servico temporariamente indisponivel: banco MySQL (tools) inacessivel."

    # Heuristica para identificar falhas no MySQL (base ficticia).
    mysql_mock_markers = ("mock", "vehicles", "customers", "orders", "review_schedules")
    if any(marker in text for marker in mysql_mock_markers):
        return "Servico temporariamente indisponivel: banco MySQL (dados ficticios) inacessivel."

    mysql_generic_markers = ("mysql", "pymysql", "(2003", "3306")
    if any(marker in text for marker in mysql_generic_markers):
        return "Servico temporariamente indisponivel: banco MySQL 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)):
    """Processa mensagem do usuario via orquestrador e retorna resposta do chat."""
    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]]:
    """Consulta estoque de veiculos mock com filtros opcionais."""
    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]:
    """Valida elegibilidade de cliente para uma venda."""
    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]:
    """Avalia valor de troca de um veiculo com base em modelo, ano e quilometragem."""
    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]:
    """Agenda revisao para uma placa em data/hora informada."""
    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]:
    """Cancela pedido de venda existente registrando o motivo."""
    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))