"""Trip cancellation catalog and shared helpers."""

from __future__ import annotations

from django.db import transaction
from django.utils import timezone

from core.models import Bid, RateRequest, Shipment, Trip, TripCancellation

CANCELLABLE_TRIP_STATUSES = frozenset({
    Trip.Status.ASSIGNED,
    Trip.Status.EN_ROUTE,
    Trip.Status.ARRIVED_PICKUP,
})

TRIP_CANCEL_REASONS = [
    {'code': code, 'label': label}
    for code, label in TripCancellation.ReasonCode.choices
]


def resolve_cancelled_by_role(user, trip) -> str:
    if getattr(trip.shipment, 'shipper_id', None) == user.id:
        return TripCancellation.CancelledByRole.SHIPPER
    if trip.transporter_id == user.id:
        return TripCancellation.CancelledByRole.TRANSPORTER
    if trip.assigned_driver_id == user.id:
        return TripCancellation.CancelledByRole.DRIVER
    return TripCancellation.CancelledByRole.TRANSPORTER


def validate_cancel_reason(reason_code, reason_text):
    """Return (code, text, error_dict_or_None)."""
    code = (reason_code or '').strip().upper()
    text = (reason_text or '').strip()
    valid = {c for c, _ in TripCancellation.ReasonCode.choices}
    if not code:
        return None, None, {'reason_code': 'This field is required.'}
    if code not in valid:
        return None, None, {'reason_code': f'Must be one of: {", ".join(sorted(valid))}.'}
    if code == TripCancellation.ReasonCode.OTHER and not text:
        return None, None, {'reason_text': 'Required when reason_code is OTHER.'}
    if len(text) > 500:
        return None, None, {'reason_text': 'Must be 500 characters or fewer.'}
    return code, text, None


def cancellation_payload(cancellation: TripCancellation) -> dict:
    return {
        'reason_code': cancellation.reason_code,
        'reason_text': cancellation.reason_text or '',
        'cancelled_by_id': cancellation.cancelled_by_id,
        'cancelled_by_role': cancellation.cancelled_by_role,
        'previous_status': cancellation.previous_status,
        'cancelled_at': cancellation.cancelled_at.isoformat() if cancellation.cancelled_at else None,
    }


def trip_cancel_notification_recipient_ids(trip, *, cancelled_by_user_id, cancelled_by_role) -> list[int]:
    """
    Push / in-app recipients after a trip cancel.

    - Fleet / transporter's driver cancels → shipper + fleet owner (transporter)
    - Individual driver (or fleet owner) cancels → shipper only
      (+ assigned fleet driver when a distinct fleet owner cancels)
    - Shipper cancels → transporter + assigned fleet driver (when distinct)
    """
    recipients: set[int] = set()
    shipper_id = getattr(trip.shipment, 'shipper_id', None)
    transporter_id = trip.transporter_id
    assigned_driver_id = trip.assigned_driver_id

    if cancelled_by_role == TripCancellation.CancelledByRole.DRIVER:
        if shipper_id:
            recipients.add(shipper_id)
        if transporter_id and transporter_id != cancelled_by_user_id:
            recipients.add(transporter_id)
    elif cancelled_by_role == TripCancellation.CancelledByRole.TRANSPORTER:
        if shipper_id and shipper_id != cancelled_by_user_id:
            recipients.add(shipper_id)
        # Fleet owner cancelling: also notify the assigned company driver.
        if (
            assigned_driver_id
            and assigned_driver_id != cancelled_by_user_id
            and assigned_driver_id != transporter_id
        ):
            recipients.add(assigned_driver_id)
    else:
        # Shipper (or unknown): notify transporter side.
        if transporter_id and transporter_id != cancelled_by_user_id:
            recipients.add(transporter_id)
        if (
            assigned_driver_id
            and assigned_driver_id != cancelled_by_user_id
            and assigned_driver_id != transporter_id
        ):
            recipients.add(assigned_driver_id)

    recipients.discard(cancelled_by_user_id)
    return sorted(uid for uid in recipients if uid)


def cancel_open_bids_and_rate_requests(shipment):
    Bid.objects.filter(
        shipment=shipment,
        status__in=(Bid.Status.PENDING, Bid.Status.COUNTERED, Bid.Status.AGREED),
    ).update(status=Bid.Status.REJECTED, updated_at=timezone.now())
    RateRequest.objects.filter(
        shipment=shipment,
        status=RateRequest.Status.PENDING,
    ).update(
        status=RateRequest.Status.CANCELLED,
        responded_at=timezone.now(),
        updated_at=timezone.now(),
    )


@transaction.atomic
def cancel_trip(*, trip: Trip, user, reason_code: str, reason_text: str = '') -> TripCancellation:
    """Cancel an active trip. Caller must enforce auth and cancellable status."""
    from api.trip_status import record_trip_status

    try:
        existing = trip.cancellation
    except TripCancellation.DoesNotExist:
        existing = None
    if trip.status == Trip.Status.CANCELLED and existing:
        return existing

    previous = trip.status
    role = resolve_cancelled_by_role(user, trip)
    cancellation = TripCancellation.objects.create(
        trip=trip,
        cancelled_by=user,
        cancelled_by_role=role,
        reason_code=reason_code,
        reason_text=reason_text or '',
        previous_status=previous,
    )
    trip.status = Trip.Status.CANCELLED
    trip.save(update_fields=['status', 'updated_at'])
    record_trip_status(trip, Trip.Status.CANCELLED)

    shipment = trip.shipment
    shipment.status = Shipment.Status.CANCELLED
    shipment.save(update_fields=['status', 'updated_at'])
    cancel_open_bids_and_rate_requests(shipment)
    return cancellation
