from decimal import Decimal

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

from accounts.models import ShipperProfile, TransporterProfile, UserRole
from core.models import Bid, RateRequest, Shipment, Trip, TripCancellation

User = get_user_model()


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

        self.transporter = User.objects.create_user(
            'cancel-transporter@test.com',
            email='cancel-transporter@test.com',
            password='secret',
            first_name='Trans',
            last_name='Porter',
        )
        UserRole.objects.create(user=self.transporter, role=UserRole.Role.TRANSPORTER, phone='2', language='en')
        TransporterProfile.objects.create(
            user=self.transporter,
            account_type=TransporterProfile.AccountType.DRIVER,
            documents_verified=True,
            local=True,
        )

        self.shipper_client = APIClient()
        st, _ = Token.objects.get_or_create(user=self.shipper)
        self.shipper_client.credentials(HTTP_AUTHORIZATION=f'Bearer {st.key}')

        self.transporter_client = APIClient()
        tt, _ = Token.objects.get_or_create(user=self.transporter)
        self.transporter_client.credentials(HTTP_AUTHORIZATION=f'Bearer {tt.key}')

    def _shipment(self, *, status=Shipment.Status.ASSIGNED, **extra):
        defaults = dict(
            shipper=self.shipper,
            pickup_address='A Street',
            pickup_company='Pick Co',
            pickup_lat=Decimal('24.8607000'),
            pickup_lon=Decimal('67.0011000'),
            pickup_country_code='PK',
            delivery_address='B Street',
            dropoff_company='Drop Co',
            delivery_lat=Decimal('31.5204000'),
            delivery_lon=Decimal('74.3587000'),
            delivery_country_code='PK',
            cargo_type='Goods',
            weight='100 kg',
            vehicle_type_required='Van',
            status=status,
            local=True,
            country_to_country=False,
        )
        defaults.update(extra)
        return Shipment.objects.create(**defaults)

    def _trip(self, shipment, *, status=Trip.Status.ASSIGNED):
        bid = Bid.objects.create(
            shipment=shipment,
            transporter=self.transporter,
            amount=Decimal('1000.00'),
            status=Bid.Status.ACCEPTED,
        )
        return Trip.objects.create(
            shipment=shipment,
            accepted_bid=bid,
            transporter=self.transporter,
            assigned_driver=self.transporter,
            status=status,
            agreed_price=Decimal('1000.00'),
        )

    def test_cancel_reasons_list(self):
        res = self.shipper_client.get('/api/shipper/trip-cancel-reasons/')
        self.assertEqual(res.status_code, 200)
        codes = {r['code'] for r in res.json()['data']['reasons']}
        self.assertIn('OTHER', codes)
        self.assertIn('WRONG_DETAILS', codes)

    def test_shipper_cancel_assigned_trip(self):
        shipment = self._shipment()
        trip = self._trip(shipment)
        res = self.shipper_client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'WRONG_DETAILS', 'reason_text': 'Bad address'},
            format='json',
        )
        self.assertEqual(res.status_code, 200, res.content)
        data = res.json()['data']
        self.assertEqual(data['status'], 'CANCELLED')
        self.assertEqual(data['cancellation']['reason_code'], 'WRONG_DETAILS')
        self.assertEqual(data['cancellation']['cancelled_by_role'], 'SHIPPER')

        trip.refresh_from_db()
        shipment.refresh_from_db()
        self.assertEqual(trip.status, Trip.Status.CANCELLED)
        self.assertEqual(shipment.status, Shipment.Status.CANCELLED)
        self.assertTrue(TripCancellation.objects.filter(trip=trip).exists())

    def test_transporter_cancel_en_route(self):
        shipment = self._shipment()
        trip = self._trip(shipment, status=Trip.Status.EN_ROUTE)
        res = self.transporter_client.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'], 'TRANSPORTER')

    def test_reject_cancel_when_loaded(self):
        shipment = self._shipment()
        trip = self._trip(shipment, status=Trip.Status.LOADED)
        res = self.shipper_client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'NO_LONGER_NEEDED'},
            format='json',
        )
        self.assertEqual(res.status_code, 400)

    def test_other_requires_reason_text(self):
        shipment = self._shipment()
        trip = self._trip(shipment)
        res = self.shipper_client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'OTHER'},
            format='json',
        )
        self.assertEqual(res.status_code, 400)
        self.assertIn('reason_text', res.json()['error'])

    def test_wrong_actor_cannot_cancel(self):
        other = User.objects.create_user('other-ship@test.com', email='other-ship@test.com', password='secret')
        UserRole.objects.create(user=other, role=UserRole.Role.SHIPPER, phone='', language='en')
        ShipperProfile.objects.create(user=other, account_type=ShipperProfile.AccountType.INDIVIDUAL)
        client = APIClient()
        token, _ = Token.objects.get_or_create(user=other)
        client.credentials(HTTP_AUTHORIZATION=f'Bearer {token.key}')

        shipment = self._shipment()
        trip = self._trip(shipment)
        res = client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'SCHEDULE_CHANGE'},
            format='json',
        )
        self.assertEqual(res.status_code, 404)

    def test_delete_published_without_trip(self):
        shipment = self._shipment(status=Shipment.Status.PUBLISHED)
        Bid.objects.create(
            shipment=shipment,
            transporter=self.transporter,
            amount=Decimal('50'),
            status=Bid.Status.PENDING,
        )
        RateRequest.objects.create(
            shipment=shipment,
            driver=self.transporter,
            status=RateRequest.Status.PENDING,
        )
        res = self.shipper_client.delete(f'/api/shipper/shipments/{shipment.id}/')
        self.assertEqual(res.status_code, 200, res.content)
        self.assertFalse(Shipment.objects.filter(pk=shipment.id).exists())

    def test_delete_published_with_trip_rejected(self):
        shipment = self._shipment(status=Shipment.Status.ASSIGNED)
        self._trip(shipment)
        res = self.shipper_client.delete(f'/api/shipper/shipments/{shipment.id}/')
        self.assertEqual(res.status_code, 400)
        self.assertTrue(Shipment.objects.filter(pk=shipment.id).exists())

    def test_clone_draft_from_published(self):
        shipment = self._shipment(
            status=Shipment.Status.PUBLISHED,
            cargo_type='Electronics',
            special_instructions='Fragile',
        )
        res = self.shipper_client.post(f'/api/shipper/shipments/{shipment.id}/clone-draft/')
        self.assertEqual(res.status_code, 201, res.content)
        data = res.json()['data']
        self.assertEqual(data['status'], 'DRAFT')
        self.assertEqual(data['cargo_type'], 'Electronics')
        self.assertEqual(data['special_instructions'], 'Fragile')
        self.assertNotEqual(data['id'], shipment.id)
        self.assertNotEqual(data['unique_id'], shipment.unique_id)

        shipment.refresh_from_db()
        self.assertEqual(shipment.status, Shipment.Status.PUBLISHED)

    def test_clone_requires_published_without_trip(self):
        shipment = self._shipment(status=Shipment.Status.DRAFT)
        res = self.shipper_client.post(f'/api/shipper/shipments/{shipment.id}/clone-draft/')
        self.assertEqual(res.status_code, 400)

        assigned = self._shipment(status=Shipment.Status.ASSIGNED)
        self._trip(assigned)
        # PUBLISHED with an existing trip still blocked
        assigned.status = Shipment.Status.PUBLISHED
        assigned.save(update_fields=['status'])
        res2 = self.shipper_client.post(f'/api/shipper/shipments/{assigned.id}/clone-draft/')
        self.assertEqual(res2.status_code, 400)

    def test_clone_draft_from_cancelled_with_trip(self):
        shipment = self._shipment()
        trip = self._trip(shipment)
        cancel = self.shipper_client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'NO_LONGER_NEEDED'},
            format='json',
        )
        self.assertEqual(cancel.status_code, 200, cancel.content)
        shipment.refresh_from_db()
        self.assertEqual(shipment.status, Shipment.Status.CANCELLED)

        res = self.shipper_client.post(f'/api/shipper/shipments/{shipment.id}/clone-draft/')
        self.assertEqual(res.status_code, 201, res.content)
        data = res.json()['data']
        self.assertEqual(data['status'], 'DRAFT')
        self.assertNotEqual(data['id'], shipment.id)
        trip.refresh_from_db()
        self.assertEqual(trip.status, Trip.Status.CANCELLED)

    def test_after_cancel_shipper_lists(self):
        shipment = self._shipment()
        trip = self._trip(shipment)
        self.shipper_client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'SCHEDULE_CHANGE'},
            format='json',
        )

        trips_res = self.shipper_client.get('/api/shipper/trips/')
        self.assertEqual(trips_res.status_code, 200)
        trip_ids = [t['id'] for t in trips_res.json()['data']]
        self.assertNotIn(trip.id, trip_ids)

        loads_res = self.shipper_client.get('/api/shipper/shipments/')
        self.assertEqual(loads_res.status_code, 200)
        load_ids = {s['id']: s['status'] for s in loads_res.json()['data']}
        self.assertEqual(load_ids.get(shipment.id), 'CANCELLED')

        history_res = self.shipper_client.get('/api/shipper/shipments/history/')
        self.assertEqual(history_res.status_code, 200)
        history_ids = {s['id']: s['status'] for s in history_res.json()['data']}
        self.assertEqual(history_ids.get(shipment.id), 'CANCELLED')

    def test_after_cancel_individual_driver_completed_includes(self):
        shipment = self._shipment()
        trip = self._trip(shipment)
        self.shipper_client.post(
            f'/api/shipper/trips/{trip.id}/cancel/',
            {'reason_code': 'WRONG_DETAILS'},
            format='json',
        )

        completed = self.transporter_client.get('/api/transporter/my-trips/completed/')
        self.assertEqual(completed.status_code, 200, completed.content)
        body = completed.json()['data']
        ids = [t['id'] for t in body['trips']]
        self.assertIn(trip.id, ids)

        active = self.transporter_client.get('/api/transporter/my-trips/active/')
        self.assertEqual(active.status_code, 200)
        active_ids = [t['id'] for t in active.json()['data']['trips']]
        self.assertNotIn(trip.id, active_ids)

        assigned = self.transporter_client.get('/api/transporter/my-trips/assigned/')
        self.assertEqual(assigned.status_code, 200)
        assigned_ids = [t['id'] for t in assigned.json()['data']['trips']]
        self.assertNotIn(trip.id, assigned_ids)
