from decimal import Decimal
from unittest.mock import patch

from django.contrib.auth import get_user_model
from django.test import SimpleTestCase, TestCase
from rest_framework.authtoken.models import Token
from rest_framework.test import APIClient

from accounts.models import ShipperProfile, TransporterDriverLink, TransporterProfile, UserRole
from core.models import Bid, Shipment, Trip, TripCancellation
from core.trip_cancel import trip_cancel_notification_recipient_ids

User = get_user_model()


class _FakeTrip:
    def __init__(self, *, shipper_id, transporter_id, assigned_driver_id=None):
        self.shipment = type('S', (), {'shipper_id': shipper_id})()
        self.transporter_id = transporter_id
        self.assigned_driver_id = assigned_driver_id


class TripCancelNotificationRecipientTests(SimpleTestCase):
    def test_fleet_driver_cancel_notifies_shipper_and_transporter(self):
        trip = _FakeTrip(shipper_id=1, transporter_id=2, assigned_driver_id=3)
        ids = trip_cancel_notification_recipient_ids(
            trip,
            cancelled_by_user_id=3,
            cancelled_by_role=TripCancellation.CancelledByRole.DRIVER,
        )
        self.assertEqual(ids, [1, 2])

    def test_individual_driver_cancel_notifies_shipper_only(self):
        # Individual driver is both transporter and assigned_driver.
        trip = _FakeTrip(shipper_id=1, transporter_id=2, assigned_driver_id=2)
        ids = trip_cancel_notification_recipient_ids(
            trip,
            cancelled_by_user_id=2,
            cancelled_by_role=TripCancellation.CancelledByRole.TRANSPORTER,
        )
        self.assertEqual(ids, [1])

    def test_shipper_cancel_notifies_transporter_and_fleet_driver(self):
        trip = _FakeTrip(shipper_id=1, transporter_id=2, assigned_driver_id=3)
        ids = trip_cancel_notification_recipient_ids(
            trip,
            cancelled_by_user_id=1,
            cancelled_by_role=TripCancellation.CancelledByRole.SHIPPER,
        )
        self.assertEqual(ids, [2, 3])


class TripCancelPushNotificationApiTests(TestCase):
    def setUp(self):
        self.shipper = User.objects.create_user(
            'cancel-push-ship@test.com',
            email='cancel-push-ship@test.com',
            password='secret',
        )
        UserRole.objects.create(user=self.shipper, role=UserRole.Role.SHIPPER, phone='', language='en')
        ShipperProfile.objects.create(user=self.shipper, account_type=ShipperProfile.AccountType.INDIVIDUAL)

        self.fleet_owner = User.objects.create_user(
            'cancel-push-owner@test.com',
            email='cancel-push-owner@test.com',
            password='secret',
        )
        UserRole.objects.create(user=self.fleet_owner, role=UserRole.Role.TRANSPORTER, phone='', language='en')
        TransporterProfile.objects.create(
            user=self.fleet_owner,
            account_type=TransporterProfile.AccountType.FLEET_OWNER,
            documents_verified=True,
            local=True,
        )

        self.fleet_driver = User.objects.create_user(
            'cancel-push-drv@test.com',
            email='cancel-push-drv@test.com',
            password='secret',
        )
        UserRole.objects.create(user=self.fleet_driver, role=UserRole.Role.TRANSPORTER, phone='', language='en')
        TransporterProfile.objects.create(
            user=self.fleet_driver,
            account_type=TransporterProfile.AccountType.TRANSPORTER_DRIVER,
            documents_verified=True,
            local=True,
        )
        TransporterDriverLink.objects.create(
            transporter=self.fleet_owner,
            driver=self.fleet_driver,
            is_active=True,
        )

        self.individual = User.objects.create_user(
            'cancel-push-ind@test.com',
            email='cancel-push-ind@test.com',
            password='secret',
        )
        UserRole.objects.create(user=self.individual, role=UserRole.Role.TRANSPORTER, phone='', language='en')
        TransporterProfile.objects.create(
            user=self.individual,
            account_type=TransporterProfile.AccountType.DRIVER,
            documents_verified=True,
            local=True,
        )

    def _client(self, user):
        token, _ = Token.objects.get_or_create(user=user)
        client = APIClient()
        client.credentials(HTTP_AUTHORIZATION=f'Bearer {token.key}')
        return client

    def _trip(self, *, transporter, assigned_driver=None):
        shipment = Shipment.objects.create(
            shipper=self.shipper,
            pickup_address='A',
            delivery_address='B',
            cargo_type='General',
            weight='1 ton',
            vehicle_type_required='Flatbed',
            local=True,
            country_to_country=False,
            status=Shipment.Status.ASSIGNED,
        )
        bid = Bid.objects.create(
            shipment=shipment,
            transporter=transporter,
            amount=Decimal('100.00'),
            status=Bid.Status.ACCEPTED,
        )
        return Trip.objects.create(
            shipment=shipment,
            accepted_bid=bid,
            transporter=transporter,
            assigned_driver=assigned_driver,
            status=Trip.Status.ASSIGNED,
        )

    @patch('api.views.notify_users')
    def test_fleet_driver_cancel_notifies_shipper_and_fleet_owner(self, mock_notify):
        trip = self._trip(transporter=self.fleet_owner, assigned_driver=self.fleet_driver)
        res = self._client(self.fleet_driver).post(
            f'/api/transporter/trips/{trip.id}/cancel/',
            {'reason_code': 'DRIVER_UNAVAILABLE'},
            format='json',
        )
        self.assertEqual(res.status_code, 200, res.content)
        self.assertEqual(res.json()['data']['cancellation']['cancelled_by_role'], 'DRIVER')
        mock_notify.assert_called_once()
        recipient_ids = set(mock_notify.call_args.args[0])
        self.assertEqual(recipient_ids, {self.shipper.id, self.fleet_owner.id})
        self.assertEqual(mock_notify.call_args.args[1], 'TRIP_CANCELLED')

    @patch('api.views.notify_users')
    def test_individual_driver_cancel_notifies_shipper_only(self, mock_notify):
        trip = self._trip(transporter=self.individual, assigned_driver=self.individual)
        res = self._client(self.individual).post(
            f'/api/transporter/trips/{trip.id}/cancel/',
            {'reason_code': 'DRIVER_UNAVAILABLE'},
            format='json',
        )
        self.assertEqual(res.status_code, 200, res.content)
        mock_notify.assert_called_once()
        recipient_ids = set(mock_notify.call_args.args[0])
        self.assertEqual(recipient_ids, {self.shipper.id})
        self.assertEqual(mock_notify.call_args.args[1], 'TRIP_CANCELLED')
