import math
import random
import re
from datetime import datetime
from typing import Any
from uuid import uuid4

from app.core.time_utils import utc_now
from app.db.mock_database import SessionMockLocal
from app.db.mock_models import RentalContract, RentalFine, RentalPayment, RentalVehicle, User
from app.services.domain.tool_errors import raise_tool_http_error
from app.services.integrations.events import (
    RENTAL_OPENED_EVENT,
    RENTAL_PAYMENT_REGISTERED_EVENT,
    RENTAL_RETURN_REGISTERED_EVENT,
)
from app.services.integrations.service import publish_business_event_safely
from app.services.orchestration import technical_normalizer
from app.services.user.mock_customer_service import hydrate_mock_customer_from_cpf


# Normaliza o numero do contrato para comparacoes e buscas.
def _normalize_contract_number(value: str | None) -> str | None:
    text = str(value or "").strip().upper()
    return text or None


# Limpa campos textuais livres antes de salvar ou responder.
def _normalize_text_field(value: str | None) -> str | None:
    text = str(value or "").strip(" ,.;")
    return text or None


# Converte datas opcionais de aluguel em datetime com formatos aceitos.
def _parse_optional_datetime(value: str | None, *, field_name: str) -> datetime | None:
    text = str(value or "").strip()
    if not text:
        return None

    normalized = re.sub(r"\s+(?:as|às)\s+", " ", text, flags=re.IGNORECASE)
    for candidate in (text, normalized):
        try:
            return datetime.fromisoformat(candidate.replace("Z", "+00:00"))
        except ValueError:
            pass

    for fmt in (
        "%d/%m/%Y %H:%M",
        "%d/%m/%Y",
        "%Y-%m-%d %H:%M",
        "%Y-%m-%d",
    ):
        try:
            return datetime.strptime(normalized, fmt)
        except ValueError:
            continue

    raise_tool_http_error(
        status_code=400,
        code="invalid_rental_datetime",
        message=(
            f"{field_name} invalido. Exemplos aceitos: "
            "17/03/2026, 17/03/2026 14:30, 2026-03-17, 2026-03-17 14:30."
        ),
        retryable=True,
        field=field_name,
    )
    return None


# Exige uma data obrigatoria de aluguel e reaproveita a validacao comum.
def _parse_required_datetime(value: str | None, *, field_name: str) -> datetime:
    parsed = _parse_optional_datetime(value, field_name=field_name)
    if parsed is None:
        raise_tool_http_error(
            status_code=400,
            code="missing_rental_datetime",
            message=f"Informe {field_name} para continuar a locacao.",
            retryable=True,
            field=field_name,
        )
    return parsed


# Valida e normaliza valores monetarios positivos usados no fluxo.
def _normalize_money(value) -> float:
    number = technical_normalizer.normalize_positive_number(value)
    if number is None or float(number) <= 0:
        raise_tool_http_error(
            status_code=400,
            code="invalid_amount",
            message="Informe um valor monetario valido maior que zero.",
            retryable=True,
            field="valor",
        )
    return float(number)


# Garante que o identificador do veiculo seja um inteiro positivo.
def _normalize_vehicle_id(value) -> int | None:
    if value is None or value == "":
        return None
    try:
        numeric = int(value)
    except (TypeError, ValueError):
        raise_tool_http_error(
            status_code=400,
            code="invalid_rental_vehicle_id",
            message="Informe um identificador numerico de veiculo para locacao.",
            retryable=True,
            field="rental_vehicle_id",
        )
    if numeric <= 0:
        raise_tool_http_error(
            status_code=400,
            code="invalid_rental_vehicle_id",
            message="Informe um identificador numerico de veiculo para locacao.",
            retryable=True,
            field="rental_vehicle_id",
        )
    return numeric


# Calcula a quantidade de diarias cobradas entre inicio e fim da locacao.
def _calculate_rental_days(start: datetime, end: datetime) -> int:
    delta_seconds = (end - start).total_seconds()
    if delta_seconds < 0:
        raise_tool_http_error(
            status_code=400,
            code="invalid_rental_period",
            message="A data final da locacao nao pode ser anterior a data inicial.",
            retryable=True,
            field="data_fim_prevista",
        )
    if delta_seconds == 0:
        return 1
    return max(1, math.ceil(delta_seconds / 86400))


# Busca o veiculo da locacao por id ou placa normalizada.
def _build_rental_vehicle_query(
    db,
    *,
    rental_vehicle_id: int | None = None,
    placa: str | None = None,
) -> Any:
    if rental_vehicle_id is not None:
        return db.query(RentalVehicle).filter(RentalVehicle.id == rental_vehicle_id)

    normalized_plate = technical_normalizer.normalize_plate(placa)
    if normalized_plate:
        return db.query(RentalVehicle).filter(RentalVehicle.placa == normalized_plate)

    raise_tool_http_error(
        status_code=400,
        code="missing_rental_vehicle_reference",
        message="Informe a placa ou o identificador do veiculo de locacao.",
        retryable=True,
        field="placa",
    )
    return db.query(RentalVehicle).filter(RentalVehicle.id.is_(None))


def _lookup_rental_vehicle(
    db,
    *,
    rental_vehicle_id: int | None = None,
    placa: str | None = None,
) -> RentalVehicle | None:
    return _build_rental_vehicle_query(
        db,
        rental_vehicle_id=rental_vehicle_id,
        placa=placa,
    ).first()


# Recupera e trava o veiculo no mesmo turno transacional para evitar dupla locacao.
def _get_rental_vehicle_for_update(
    db,
    *,
    rental_vehicle_id: int | None = None,
    placa: str | None = None,
) -> RentalVehicle | None:
    return _build_rental_vehicle_query(
        db,
        rental_vehicle_id=rental_vehicle_id,
        placa=placa,
    ).with_for_update().first()

# Prioriza contratos do proprio usuario antes de cair para contratos sem dono.
def _lookup_contract_by_user_preference(query, user_id: int | None):
    if user_id is None:
        return query.order_by(RentalContract.created_at.desc()).first()

    own_contract = query.filter(RentalContract.user_id == user_id).order_by(RentalContract.created_at.desc()).first()
    if own_contract is not None:
        return own_contract

    return query.filter(RentalContract.user_id.is_(None)).order_by(RentalContract.created_at.desc()).first()


# Resolve um contrato de aluguel usando contrato, placa ou contexto do usuario.
def _resolve_rental_contract(
    db,
    *,
    contrato_numero: str | None = None,
    placa: str | None = None,
    user_id: int | None = None,
    active_only: bool = False,
) -> RentalContract | None:
    normalized_contract = _normalize_contract_number(contrato_numero)
    normalized_plate = technical_normalizer.normalize_plate(placa)

    if normalized_contract:
        query = db.query(RentalContract).filter(RentalContract.contrato_numero == normalized_contract)
        if active_only:
            query = query.filter(RentalContract.status == "ativa")
        contract = _lookup_contract_by_user_preference(query, user_id)
        if contract is not None:
            return contract

    if normalized_plate:
        query = db.query(RentalContract).filter(RentalContract.placa == normalized_plate)
        if active_only:
            query = query.filter(RentalContract.status == "ativa")
        contract = _lookup_contract_by_user_preference(query, user_id)
        if contract is not None:
            return contract

    if user_id is not None:
        query = db.query(RentalContract).filter(RentalContract.user_id == user_id)
        if active_only:
            query = query.filter(RentalContract.status == "ativa")
        contracts = query.order_by(RentalContract.created_at.desc()).limit(2).all()
        if len(contracts) == 1:
            return contracts[0]

    return None


# Lista a frota de aluguel com filtros simples e ordenacao configuravel.
async def consultar_frota_aluguel(
    categoria: str | None = None,
    valor_diaria_max: float | None = None,
    modelo: str | None = None,
    status: str | None = None,
    ordenar_diaria: str | None = None,
    limite: int | None = None,
) -> list[dict[str, Any]]:
    db = SessionMockLocal()
    try:
        query = db.query(RentalVehicle)

        normalized_status = str(status or "").strip().lower() or "disponivel"
        query = query.filter(RentalVehicle.status == normalized_status)

        if categoria:
            query = query.filter(RentalVehicle.categoria == str(categoria).strip().lower())

        if valor_diaria_max is not None:
            max_value = technical_normalizer.normalize_positive_number(valor_diaria_max)
            if max_value is not None:
                query = query.filter(RentalVehicle.valor_diaria <= float(max_value))

        if modelo:
            query = query.filter(RentalVehicle.modelo.ilike(f"%{str(modelo).strip()}%"))

        order_mode = str(ordenar_diaria or "").strip().lower()
        normalized_limit = None
        if limite is not None:
            try:
                normalized_limit = max(1, min(int(limite), 50))
            except (TypeError, ValueError):
                normalized_limit = None

        if order_mode in {"asc", "desc"}:
            query = query.order_by(
                RentalVehicle.valor_diaria.asc()
                if order_mode == "asc"
                else RentalVehicle.valor_diaria.desc()
            )
        elif order_mode != "random":
            query = query.order_by(RentalVehicle.valor_diaria.asc(), RentalVehicle.modelo.asc())

        if order_mode == "random":
            rows = query.all()
            random.shuffle(rows)
            if normalized_limit is not None:
                rows = rows[:normalized_limit]
        else:
            if normalized_limit is not None:
                query = query.limit(normalized_limit)
            rows = query.all()

        return [
            {
                "id": row.id,
                "placa": row.placa,
                "modelo": row.modelo,
                "categoria": row.categoria,
                "ano": int(row.ano),
                "valor_diaria": float(row.valor_diaria),
                "status": row.status,
            }
            for row in rows
        ]
    finally:
        db.close()


# Abre uma locacao, reserva o veiculo e devolve o resumo do contrato.
async def abrir_locacao_aluguel(
    data_inicio: str,
    data_fim_prevista: str,
    rental_vehicle_id: int | None = None,
    placa: str | None = None,
    cpf: str | None = None,
    nome_cliente: str | None = None,
    observacoes: str | None = None,
    user_id: int | None = None,
) -> dict[str, Any]:
    vehicle_id = _normalize_vehicle_id(rental_vehicle_id)
    data_inicio_dt = _parse_required_datetime(data_inicio, field_name="data_inicio")
    data_fim_dt = _parse_required_datetime(data_fim_prevista, field_name="data_fim_prevista")
    diarias = _calculate_rental_days(data_inicio_dt, data_fim_dt)

    cpf_norm = technical_normalizer.normalize_cpf(cpf)
    if cpf and not cpf_norm:
        raise_tool_http_error(
            status_code=400,
            code="invalid_cpf",
            message="Informe um CPF valido para a locacao ou remova esse campo.",
            retryable=True,
            field="cpf",
        )

    if cpf_norm:
        await hydrate_mock_customer_from_cpf(cpf=cpf_norm, user_id=user_id)

    db = SessionMockLocal()
    try:
        vehicle = _get_rental_vehicle_for_update(
            db,
            rental_vehicle_id=vehicle_id,
            placa=placa,
        )
        if vehicle is None:
            raise_tool_http_error(
                status_code=404,
                code="rental_vehicle_not_found",
                message="Veiculo de aluguel nao encontrado.",
                retryable=True,
                field="placa",
            )

        if vehicle.status != "disponivel":
            raise_tool_http_error(
                status_code=409,
                code="rental_vehicle_unavailable",
                message=(
                    f"O veiculo {vehicle.placa} nao esta disponivel para locacao no momento. "
                    f"Status atual: {vehicle.status}."
                ),
                retryable=True,
                field="placa",
            )

        contract_number = f"LOC-{utc_now().strftime('%Y%m%d')}-{uuid4().hex[:8].upper()}"
        total_preview = round(float(vehicle.valor_diaria) * diarias, 2)

        contract = RentalContract(
            contrato_numero=contract_number,
            user_id=user_id,
            cpf=cpf_norm,
            rental_vehicle_id=vehicle.id,
            placa=vehicle.placa,
            modelo_veiculo=vehicle.modelo,
            categoria=vehicle.categoria,
            data_inicio=data_inicio_dt,
            data_fim_prevista=data_fim_dt,
            valor_diaria=float(vehicle.valor_diaria),
            valor_previsto=total_preview,
            status="ativa",
            observacoes=_normalize_text_field(observacoes),
        )

        if user_id is not None and cpf_norm:
            user = db.query(User).filter(User.id == user_id).first()
            if user and user.cpf != cpf_norm:
                user.cpf = cpf_norm

        vehicle.status = "alugado"
        db.add(contract)
        db.commit()
        db.refresh(contract)
        db.refresh(vehicle)

        result = {
            "contrato_numero": contract.contrato_numero,
            "placa": contract.placa,
            "modelo_veiculo": contract.modelo_veiculo,
            "categoria": contract.categoria,
            "data_inicio": contract.data_inicio.isoformat(),
            "data_fim_prevista": contract.data_fim_prevista.isoformat(),
            "valor_diaria": float(contract.valor_diaria),
            "valor_previsto": float(contract.valor_previsto),
            "status": contract.status,
            "status_veiculo": vehicle.status,
            "cpf": contract.cpf,
            "nome_cliente": _normalize_text_field(nome_cliente),
            "user_id": contract.user_id,
        }
        await publish_business_event_safely(RENTAL_OPENED_EVENT, result)
        return result
    finally:
        db.close()


# Encerra a locacao ativa, calcula o valor final e libera o veiculo.
async def registrar_devolucao_aluguel(
    contrato_numero: str | None = None,
    placa: str | None = None,
    data_devolucao: str | None = None,
    observacoes: str | None = None,
    user_id: int | None = None,
) -> dict[str, Any]:
    db = SessionMockLocal()
    try:
        contract = _resolve_rental_contract(
            db,
            contrato_numero=contrato_numero,
            placa=placa,
            user_id=user_id,
            active_only=True,
        )
        if contract is None:
            raise_tool_http_error(
                status_code=404,
                code="rental_contract_not_found",
                message="Nao encontrei uma locacao ativa com os dados informados.",
                retryable=True,
                field="contrato_numero",
            )

        returned_at = _parse_optional_datetime(data_devolucao, field_name="data_devolucao") or utc_now()
        if returned_at < contract.data_inicio:
            raise_tool_http_error(
                status_code=400,
                code="invalid_return_datetime",
                message="A data de devolucao nao pode ser anterior ao inicio da locacao.",
                retryable=True,
                field="data_devolucao",
            )

        rental_days = _calculate_rental_days(contract.data_inicio, returned_at)
        contract.data_devolucao = returned_at
        contract.valor_final = round(float(contract.valor_diaria) * rental_days, 2)
        contract.status = "encerrada"
        contract.observacoes = _normalize_text_field(observacoes) or contract.observacoes

        vehicle = db.query(RentalVehicle).filter(RentalVehicle.id == contract.rental_vehicle_id).first()
        if vehicle is not None:
            vehicle.status = "disponivel"

        db.commit()
        db.refresh(contract)
        if vehicle is not None:
            db.refresh(vehicle)

        result = {
            "contrato_numero": contract.contrato_numero,
            "placa": contract.placa,
            "modelo_veiculo": contract.modelo_veiculo,
            "data_devolucao": contract.data_devolucao.isoformat() if contract.data_devolucao else None,
            "valor_previsto": float(contract.valor_previsto),
            "valor_final": float(contract.valor_final) if contract.valor_final is not None else None,
            "status": contract.status,
            "status_veiculo": vehicle.status if vehicle is not None else None,
            "user_id": contract.user_id,
        }
        await publish_business_event_safely(RENTAL_RETURN_REGISTERED_EVENT, result)
        return result
    finally:
        db.close()


# Registra um pagamento de aluguel e tenta vincular o contrato correto.
async def registrar_pagamento_aluguel(
    valor: float,
    contrato_numero: str | None = None,
    placa: str | None = None,
    data_pagamento: str | None = None,
    favorecido: str | None = None,
    identificador_comprovante: str | None = None,
    observacoes: str | None = None,
    user_id: int | None = None,
) -> dict:
    contract = None
    normalized_contract = _normalize_contract_number(contrato_numero)
    plate = technical_normalizer.normalize_plate(placa)

    db = SessionMockLocal()
    try:
        contract = _resolve_rental_contract(
            db,
            contrato_numero=normalized_contract,
            placa=plate,
            user_id=user_id,
            active_only=False,
        )

        if contract is not None:
            normalized_contract = contract.contrato_numero
            plate = contract.placa

        if not normalized_contract and not plate:
            raise_tool_http_error(
                status_code=400,
                code="missing_rental_reference",
                message=(
                    "Preciso da placa, do numero do contrato ou de uma locacao ativa vinculada ao usuario "
                    "para registrar o pagamento do aluguel."
                ),
                retryable=True,
                field="placa",
            )

        record = RentalPayment(
            protocolo=f"ALP-{utc_now().strftime('%Y%m%d')}-{uuid4().hex[:8].upper()}",
            user_id=user_id,
            rental_contract_id=contract.id if contract is not None else None,
            contrato_numero=normalized_contract,
            placa=plate,
            valor=_normalize_money(valor),
            data_pagamento=_parse_optional_datetime(data_pagamento, field_name="data_pagamento"),
            favorecido=_normalize_text_field(favorecido),
            identificador_comprovante=_normalize_text_field(identificador_comprovante),
            observacoes=_normalize_text_field(observacoes),
        )

        db.add(record)
        db.commit()
        db.refresh(record)
        result = {
            "protocolo": record.protocolo,
            "rental_contract_id": record.rental_contract_id,
            "contrato_numero": record.contrato_numero,
            "placa": record.placa,
            "valor": float(record.valor),
            "data_pagamento": record.data_pagamento.isoformat() if record.data_pagamento else None,
            "favorecido": record.favorecido,
            "identificador_comprovante": record.identificador_comprovante,
            "status": "registrado",
            "user_id": record.user_id,
        }
        await publish_business_event_safely(RENTAL_PAYMENT_REGISTERED_EVENT, result)
        return result
    finally:
        db.close()


# Registra uma multa ligada ao aluguel usando os identificadores disponiveis.
async def registrar_multa_aluguel(
    valor: float,
    placa: str | None = None,
    contrato_numero: str | None = None,
    auto_infracao: str | None = None,
    orgao_emissor: str | None = None,
    data_infracao: str | None = None,
    vencimento: str | None = None,
    observacoes: str | None = None,
    user_id: int | None = None,
) -> dict:
    normalized_contract = _normalize_contract_number(contrato_numero)
    plate = technical_normalizer.normalize_plate(placa)
    notice_number = _normalize_text_field(auto_infracao)

    db = SessionMockLocal()
    try:
        contract = _resolve_rental_contract(
            db,
            contrato_numero=normalized_contract,
            placa=plate,
            user_id=user_id,
            active_only=False,
        )
        if contract is not None:
            normalized_contract = contract.contrato_numero
            plate = contract.placa

        if not normalized_contract and not plate and not notice_number:
            raise_tool_http_error(
                status_code=400,
                code="missing_fine_reference",
                message=(
                    "Preciso da placa, do numero do contrato, do auto da infracao ou de uma locacao "
                    "vinculada ao usuario para registrar a multa."
                ),
                retryable=True,
                field="placa",
            )

        record = RentalFine(
            protocolo=f"ALM-{utc_now().strftime('%Y%m%d')}-{uuid4().hex[:8].upper()}",
            user_id=user_id,
            rental_contract_id=contract.id if contract is not None else None,
            contrato_numero=normalized_contract,
            placa=plate,
            auto_infracao=notice_number,
            orgao_emissor=_normalize_text_field(orgao_emissor),
            valor=_normalize_money(valor),
            data_infracao=_parse_optional_datetime(data_infracao, field_name="data_infracao"),
            vencimento=_parse_optional_datetime(vencimento, field_name="vencimento"),
            observacoes=_normalize_text_field(observacoes),
            status="registrada",
        )

        db.add(record)
        db.commit()
        db.refresh(record)
        return {
            "protocolo": record.protocolo,
            "rental_contract_id": record.rental_contract_id,
            "contrato_numero": record.contrato_numero,
            "placa": record.placa,
            "auto_infracao": record.auto_infracao,
            "orgao_emissor": record.orgao_emissor,
            "valor": float(record.valor),
            "data_infracao": record.data_infracao.isoformat() if record.data_infracao else None,
            "vencimento": record.vencimento.isoformat() if record.vencimento else None,
            "status": record.status,
        }
    finally:
        db.close()