from typing import Any, Dict, List

from fastapi import APIRouter, HTTPException
from sqlalchemy.exc import SQLAlchemyError

from app.api.routes.dependencies import db_error_detail
from app.api.schemas import (
    AgendarRevisaoRequest,
    AvaliarVeiculoTrocaRequest,
    CancelarAgendamentoRevisaoRequest,
    CancelarPedidoRequest,
    ConsultarEstoqueRequest,
    EditarDataRevisaoRequest,
    HidratarClienteMockRequest,
    ListarAgendamentosRevisaoRequest,
    RealizarPedidoRequest,
    ValidarClienteVendaRequest,
)
from app.services.user.mock_customer_service import hydrate_mock_customer_from_cpf
from app.services.tools.handlers import (
    agendar_revisao,
    avaliar_veiculo_troca,
    cancelar_agendamento_revisao,
    cancelar_pedido,
    editar_data_revisao,
    listar_agendamentos_revisao,
    consultar_estoque,
    realizar_pedido,
    validar_cliente_venda,
)

router = APIRouter(prefix="/mock", tags=["Mock"])


@router.post("/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("/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("/hidratar-cliente-mock")
async def hidratar_cliente_mock_endpoint(
    body: HidratarClienteMockRequest,
) -> Dict[str, Any]:
    """Cria ou vincula um cliente mock a partir do CPF informado, simulando consulta externa."""
    try:
        return await hydrate_mock_customer_from_cpf(
            cpf=body.cpf,
            user_id=body.user_id,
        )
    except ValueError as exc:
        raise HTTPException(status_code=400, detail=str(exc))
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))


@router.post("/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("/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,
            modelo=body.modelo,
            ano=body.ano,
            km=body.km,
            revisao_previa_concessionaria=body.revisao_previa_concessionaria,
            user_id=body.user_id,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))


@router.post("/listar-agendamentos-revisao")
async def listar_agendamentos_revisao_endpoint(
    body: ListarAgendamentosRevisaoRequest,
) -> List[Dict[str, Any]]:
    """Lista os agendamentos de revisao do usuario autenticado."""
    try:
        return await listar_agendamentos_revisao(
            user_id=body.user_id,
            placa=body.placa,
            status=body.status,
            limite=body.limite,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))


@router.post("/cancelar-agendamento-revisao")
async def cancelar_agendamento_revisao_endpoint(
    body: CancelarAgendamentoRevisaoRequest,
) -> Dict[str, Any]:
    """Cancela agendamento de revisao usando o protocolo."""
    try:
        return await cancelar_agendamento_revisao(
            protocolo=body.protocolo,
            motivo=body.motivo,
            user_id=body.user_id,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))


@router.post("/editar-data-revisao")
async def editar_data_revisao_endpoint(
    body: EditarDataRevisaoRequest,
) -> Dict[str, Any]:
    """Edita data e hora de um agendamento de revisao existente."""
    try:
        return await editar_data_revisao(
            protocolo=body.protocolo,
            nova_data_hora=body.nova_data_hora,
            user_id=body.user_id,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))


@router.post("/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,
            user_id=body.user_id,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))


@router.post("/realizar-pedido")
async def realizar_pedido_endpoint(
    body: RealizarPedidoRequest,
) -> Dict[str, Any]:
    """Cria um pedido de compra para cliente aprovado no valor informado."""
    try:
        return await realizar_pedido(
            cpf=body.cpf,
            valor_veiculo=body.valor_veiculo,
            user_id=body.user_id,
        )
    except SQLAlchemyError as exc:
        raise HTTPException(status_code=503, detail=db_error_detail(exc))