import hashlib

from django.contrib.auth import get_user_model
from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase
from django.utils import timezone
from rest_framework.authtoken.models import Token
from rest_framework.test import APIClient

from accounts.models import (
    LegalDocument,
    ShipperProfile,
    TransporterProfile,
    UserAgreementAcceptance,
    UserRole,
)
from api.pdf_agreement import (
    agreement_text_for_pdf,
    agreement_title_for_pdf,
    build_agreement_acceptance_pdf_bytes,
    save_acceptance_pdf,
)

User = get_user_model()

SAMPLE_AGREEMENT_TEXT = (
    'Truck Me User Agreement\n\n'
    'By accepting, you agree to the terms shown in the mobile app.\n'
    'Unique marker APP_POSTED_TEXT_v1.'
)


class LegalAgreementApiTests(TestCase):
    def setUp(self):
        self.shipper = User.objects.create_user(
            'legal-shipper@test.com',
            email='legal-shipper@test.com',
            password='secret',
            first_name='Ship',
            last_name='Per',
        )
        UserRole.objects.create(
            user=self.shipper,
            role=UserRole.Role.SHIPPER,
            phone='0500000001',
            language='en',
        )
        ShipperProfile.objects.create(
            user=self.shipper,
            account_type=ShipperProfile.AccountType.INDIVIDUAL,
        )
        self.shipper_client = APIClient()
        token, _ = Token.objects.get_or_create(user=self.shipper)
        self.shipper_client.credentials(HTTP_AUTHORIZATION=f'Bearer {token.key}')

        self.driver = User.objects.create_user(
            'legal-driver@test.com',
            email='legal-driver@test.com',
            password='secret',
            first_name='Ahmad',
            last_name='Driver',
        )
        UserRole.objects.create(
            user=self.driver,
            role=UserRole.Role.TRANSPORTER,
            phone='03201165876',
            language='en',
        )
        TransporterProfile.objects.create(
            user=self.driver,
            account_type=TransporterProfile.AccountType.DRIVER,
            documents_verified=True,
        )
        self.driver_client = APIClient()
        dtoken, _ = Token.objects.get_or_create(user=self.driver)
        self.driver_client.credentials(HTTP_AUTHORIZATION=f'Bearer {dtoken.key}')

        self.admin = User.objects.create_user(
            'legal-admin@test.com',
            email='legal-admin@test.com',
            password='secret',
            is_staff=True,
        )
        UserRole.objects.create(user=self.admin, role=UserRole.Role.ADMIN, phone='', language='en')
        self.admin_client = APIClient()
        atoken, _ = Token.objects.get_or_create(user=self.admin)
        self.admin_client.credentials(HTTP_AUTHORIZATION=f'Bearer {atoken.key}')

        self.ua, _ = LegalDocument.objects.get_or_create(
            doc_type=LegalDocument.DocType.USER_AGREEMENT,
            version='1.0',
            locale='en',
            defaults={
                'title': 'Truck Me User Agreement',
                'body': '<p>Agreement body v1.0</p>',
                'is_active': True,
                'effective_at': timezone.now(),
            },
        )
        if not self.ua.is_active:
            self.ua.is_active = True
            self.ua.save()
        LegalDocument.objects.get_or_create(
            doc_type=LegalDocument.DocType.PRIVACY_POLICY,
            version='1.0',
            locale='en',
            defaults={
                'title': 'Truck Me Privacy Policy',
                'body': '<p>Privacy body v1.0</p>',
                'is_active': True,
                'effective_at': timezone.now(),
            },
        )

    def _sig(self, name='sig.png'):
        if name.endswith('.jpg'):
            return SimpleUploadedFile(name, b'\xff\xd8\xff' + b'y' * 20, content_type='image/jpeg')
        return SimpleUploadedFile(name, b'\x89PNG\r\n\x1a\n' + b'x' * 20, content_type='image/png')

    def _accept_payload(self, *, version='1.0', text=SAMPLE_AGREEMENT_TEXT, signature=None, **extra):
        data = {
            'agreement_version': version,
            'accepted': 'true',
            'agreement_text': text,
            'signature': signature or self._sig(),
        }
        data.update(extra)
        return data

    def test_public_user_agreement_and_privacy(self):
        anon = APIClient()
        ua = anon.get('/api/legal/user-agreement/')
        self.assertEqual(ua.status_code, 200)
        self.assertEqual(ua.json()['data']['doc_type'], 'USER_AGREEMENT')
        self.assertEqual(ua.json()['data']['version'], '1.0')
        pp = anon.get('/api/legal/privacy-policy/')
        self.assertEqual(pp.status_code, 200)
        self.assertEqual(pp.json()['data']['doc_type'], 'PRIVACY_POLICY')

    def test_accept_requires_signature_and_flips_profile(self):
        before = self.shipper_client.get('/api/shipper/profile/')
        self.assertEqual(before.status_code, 200)
        self.assertFalse(before.json()['data']['user_agreement_accepted'])

        bad = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            {
                'agreement_version': '1.0',
                'accepted': 'true',
                'agreement_text': SAMPLE_AGREEMENT_TEXT,
            },
            format='multipart',
        )
        self.assertEqual(bad.status_code, 400)
        self.assertIn('signature', bad.json()['error'])

        ok = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(),
            format='multipart',
        )
        self.assertEqual(ok.status_code, 200, ok.content)
        data = ok.json()['data']
        self.assertTrue(data['user_agreement_accepted'])
        self.assertEqual(data['user_agreement_version'], '1.0')
        self.assertEqual(data['account_type'], 'SHIPPER')
        self.assertIsNotNone(data.get('signature_url'))
        self.assertTrue(data.get('agreement_text_stored'))

        row = UserAgreementAcceptance.objects.get(user=self.shipper)
        self.assertEqual(row.agreement_text_snapshot, SAMPLE_AGREEMENT_TEXT)
        self.assertEqual(
            row.agreement_text_hash,
            hashlib.sha256(SAMPLE_AGREEMENT_TEXT.encode('utf-8')).hexdigest(),
        )

        after = self.shipper_client.get('/api/shipper/profile/')
        self.assertTrue(after.json()['data']['user_agreement_accepted'])
        self.assertEqual(after.json()['data']['privacy_policy_version'], '1.0')

        again = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            {'agreement_version': '1.0', 'accepted': 'true'},
            format='multipart',
        )
        self.assertEqual(again.status_code, 200)
        self.assertTrue(again.json()['data']['user_agreement_accepted'])
        self.assertTrue(again.json()['data']['agreement_text_stored'])

    def test_accept_requires_agreement_text(self):
        res = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            {
                'agreement_version': '1.0',
                'accepted': 'true',
                'signature': self._sig(),
            },
            format='multipart',
        )
        self.assertEqual(res.status_code, 400)
        self.assertIn('agreement_text', res.json()['error'])

        empty = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(text='   '),
            format='multipart',
        )
        self.assertEqual(empty.status_code, 400)
        self.assertIn('agreement_text', empty.json()['error'])

    def test_accept_rejects_oversized_agreement_text(self):
        huge = 'x' * 500_001
        res = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(text=huge),
            format='multipart',
        )
        self.assertEqual(res.status_code, 413)
        self.assertIn('agreement_text', res.json()['error'])

    def test_pdf_uses_snapshot_not_live_cms_body(self):
        marker = 'APP_POSTED_SNAPSHOT_MARKER_42'
        text = f'App shown terms.\n{marker}\nEnd.'
        ok = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(text=text, agreement_title='App Title'),
            format='multipart',
        )
        self.assertEqual(ok.status_code, 200, ok.content)
        row = UserAgreementAcceptance.objects.get(user=self.shipper)
        self.assertEqual(row.agreement_text_snapshot, text)
        self.assertEqual(row.agreement_title_snapshot, 'App Title')

        self.ua.body = '<p>CMS_MUTATED_BODY_SHOULD_NOT_APPEAR</p>'
        self.ua.save(update_fields=['body'])
        row.refresh_from_db()

        self.assertEqual(agreement_text_for_pdf(row), text)
        self.assertEqual(agreement_title_for_pdf(row), 'App Title')
        self.assertNotIn('CMS_MUTATED', agreement_text_for_pdf(row))

        pdf_bytes = build_agreement_acceptance_pdf_bytes(row)
        self.assertTrue(pdf_bytes.startswith(b'%PDF'))

        if row.pdf_file:
            row.pdf_file.delete(save=False)
            row.pdf_file = None
            row.save(update_fields=['pdf_file'])
        save_acceptance_pdf(row)
        row.refresh_from_db()
        self.assertEqual(agreement_text_for_pdf(row), text)
        self.assertTrue(row.pdf_file.read().startswith(b'%PDF'))

    def test_driver_accept_snapshot_account_type(self):
        res = self.driver_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(signature=self._sig('sig.jpg')),
            format='multipart',
        )
        self.assertEqual(res.status_code, 200, res.content)
        self.assertEqual(res.json()['data']['account_type'], 'DRIVER')
        row = UserAgreementAcceptance.objects.get(user=self.driver)
        self.assertEqual(row.account_type_at_accept, 'DRIVER')
        self.assertEqual(row.agreement_text_snapshot, SAMPLE_AGREEMENT_TEXT)

        profile = self.driver_client.get('/api/transporter/profile/')
        self.assertTrue(profile.json()['data']['user_agreement_accepted'])

    def test_version_mismatch_rejected(self):
        res = self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(version='9.9'),
            format='multipart',
        )
        self.assertEqual(res.status_code, 400)
        self.assertIn('agreement_version', res.json()['error'])

    def test_new_active_version_forces_reaccept(self):
        self.shipper_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(),
            format='multipart',
        )
        self.assertTrue(self.shipper_client.get('/api/shipper/profile/').json()['data']['user_agreement_accepted'])

        LegalDocument.objects.create(
            doc_type=LegalDocument.DocType.USER_AGREEMENT,
            version='1.1',
            locale='en',
            title='Truck Me User Agreement',
            body='<p>v1.1</p>',
            is_active=True,
            effective_at=timezone.now(),
        )
        gate = self.shipper_client.get('/api/shipper/profile/').json()['data']
        self.assertFalse(gate['user_agreement_accepted'])

    def test_login_includes_gate_flags(self):
        anon = APIClient()
        res = anon.post(
            '/api/auth/login/',
            {'email': 'legal-shipper@test.com', 'password': 'secret'},
            format='json',
        )
        self.assertEqual(res.status_code, 200)
        data = res.json()['data']
        self.assertIn('user_agreement_accepted', data)
        self.assertIn('privacy_policy_version', data)

    def test_admin_list_and_pdf(self):
        self.driver_client.post(
            '/api/legal/user-agreement/accept/',
            self._accept_payload(),
            format='multipart',
        )
        listing = self.admin_client.get('/api/admin/user-agreements/?account_type=DRIVER')
        self.assertEqual(listing.status_code, 200)
        results = listing.json()['data']['results']
        self.assertTrue(len(results) >= 1)
        acceptance_id = results[0]['id']

        detail = self.admin_client.get(f'/api/admin/user-agreements/{acceptance_id}/')
        self.assertEqual(detail.status_code, 200)
        detail_data = detail.json()['data']
        self.assertEqual(detail_data['account_type'], 'DRIVER')
        self.assertEqual(detail_data['agreement_text_snapshot'], SAMPLE_AGREEMENT_TEXT)
        self.assertNotIn('body', detail_data.get('agreement_document') or {})

        pdf = self.admin_client.get(f'/api/admin/user-agreements/{acceptance_id}/pdf/')
        self.assertEqual(pdf.status_code, 200)
        self.assertEqual(pdf['Content-Type'], 'application/pdf')
        body = b''.join(pdf.streaming_content)
        self.assertTrue(body.startswith(b'%PDF'))

    def test_admin_legal_document_create_activate(self):
        res = self.admin_client.post(
            '/api/admin/legal-documents/',
            {
                'doc_type': 'USER_AGREEMENT',
                'version': '2.0',
                'title': 'UA 2.0',
                'body': '<p>two</p>',
                'locale': 'en',
                'is_active': True,
            },
            format='json',
        )
        self.assertEqual(res.status_code, 201, res.content)
        self.assertTrue(res.json()['data']['is_active'])
        self.assertFalse(
            LegalDocument.objects.get(doc_type='USER_AGREEMENT', version='1.0', locale='en').is_active
        )
