"""Tenant isolation and ticket write-permission tests.

These cover the two failures that are most expensive here: one client seeing
another client's tickets, and an oversight account changing a ticket it should
only be able to read. Both have regressed before.
"""
from django.test import TestCase
from rest_framework.test import APIRequestFactory, force_authenticate

from clients.models import Client
from core.models import Role, User
from tickets.models import Ticket
from tickets.views import TicketViewSet


def _role(name):
    return Role.objects.get_or_create(name=name)[0]


class TicketAccessTests(TestCase):
    @classmethod
    def setUpTestData(cls):
        cls.acme = Client.objects.create(name='Acme', code='ACME', is_active=True)
        cls.globex = Client.objects.create(name='Globex', code='GLBX', is_active=True)

        cls.acme_ticket = Ticket.objects.create(
            client=cls.acme, customer_name='A Customer', subject='Acme order', channel='email')
        cls.globex_ticket = Ticket.objects.create(
            client=cls.globex, customer_name='G Customer', subject='Globex order', channel='email')

        cls.acme_user = User.objects.create(
            username='acme_portal', role=_role('client_admin'), client=cls.acme)
        cls.sysadmin = User.objects.create(username='sysadmin', role=_role('system_admin'))
        cls.team_leader = User.objects.create(username='tl', role=_role('team_leader'))
        # A user with no role and no client: must see nothing, not everything.
        cls.orphan = User.objects.create(username='orphan')

        cls.rf = APIRequestFactory()

    def _list(self, user):
        req = self.rf.get('/api/tickets/')
        force_authenticate(req, user=user)
        resp = TicketViewSet.as_view({'get': 'list'})(req)
        self.assertEqual(resp.status_code, 200)
        data = resp.data
        return data['results'] if isinstance(data, dict) and 'results' in data else data

    def _patch(self, user, ticket, payload):
        req = self.rf.patch(f'/api/tickets/{ticket.pk}/', payload, format='json')
        force_authenticate(req, user=user)
        return TicketViewSet.as_view({'patch': 'partial_update'})(req, pk=ticket.pk)

    # ---- tenant isolation -------------------------------------------------

    def test_client_user_sees_only_own_tickets(self):
        subjects = [t['subject'] for t in self._list(self.acme_user)]
        self.assertIn('Acme order', subjects)
        self.assertNotIn('Globex order', subjects)

    def test_user_with_no_role_and_no_client_sees_nothing(self):
        """Fail closed. A missing role must never mean 'show everything'."""
        self.assertEqual(len(self._list(self.orphan)), 0)

    def test_internal_staff_see_all_clients(self):
        subjects = [t['subject'] for t in self._list(self.team_leader)]
        self.assertIn('Acme order', subjects)
        self.assertIn('Globex order', subjects)

    def test_client_user_cannot_reach_another_clients_ticket_by_id(self):
        req = self.rf.get(f'/api/tickets/{self.globex_ticket.pk}/')
        force_authenticate(req, user=self.acme_user)
        resp = TicketViewSet.as_view({'get': 'retrieve'})(req, pk=self.globex_ticket.pk)
        self.assertEqual(resp.status_code, 404)

    # ---- view-only administrator -----------------------------------------

    def test_system_admin_can_read_tickets(self):
        req = self.rf.get(f'/api/tickets/{self.acme_ticket.pk}/')
        force_authenticate(req, user=self.sysadmin)
        resp = TicketViewSet.as_view({'get': 'retrieve'})(req, pk=self.acme_ticket.pk)
        self.assertEqual(resp.status_code, 200)

    def test_system_admin_cannot_write(self):
        resp = self._patch(self.sysadmin, self.acme_ticket, {'priority': 'critical'})
        self.assertEqual(resp.status_code, 403)
        self.acme_ticket.refresh_from_db()
        self.assertNotEqual(self.acme_ticket.priority, 'critical')

    def test_team_leader_can_still_write(self):
        resp = self._patch(self.team_leader, self.acme_ticket, {'priority': 'high'})
        self.assertEqual(resp.status_code, 200)
        self.acme_ticket.refresh_from_db()
        self.assertEqual(self.acme_ticket.priority, 'high')


class TicketFilterTests(TestCase):
    """Filters and fields added to close the Freshdesk gaps.

    Each of these was reported as missing; several existed in the model but had
    no way to query them, which is the same thing from a user's seat.
    """

    @classmethod
    def setUpTestData(cls):
        from clients.models import ClientDepartment
        cls.client_obj = Client.objects.create(name='Acme', code='ACME', is_active=True)
        cls.sales = ClientDepartment.objects.create(client=cls.client_obj, name='Sales', code='SAL')
        cls.billing = ClientDepartment.objects.create(client=cls.client_obj, name='Billing', code='BIL')
        cls.agent_a = User.objects.create(username='agent_a', first_name='Ann',
                                          role=_role('agent'), is_active=True)
        cls.agent_b = User.objects.create(username='agent_b', first_name='Ben',
                                          role=_role('agent'), is_active=True)
        cls.viewer = User.objects.create(username='ops', role=_role('operations_manager'))

        def mk(**kw):
            base = dict(client=cls.client_obj, customer_name='C', subject='S', channel='email')
            base.update(kw)
            return Ticket.objects.create(**base)

        cls.t_vip = mk(subject='VIP refund', tags='vip, refund', assigned_agent=cls.agent_a,
                       department=cls.sales)
        cls.t_risk = mk(subject='Chargeback', tags='chargeback-risk', assigned_agent=cls.agent_b,
                        department=cls.billing)
        cls.t_plain = mk(subject='Plain', assigned_agent=cls.agent_b, department=cls.billing)
        cls.rf = APIRequestFactory()

    def _list(self, params):
        req = self.rf.get('/api/tickets/', params)
        force_authenticate(req, user=self.viewer)
        resp = TicketViewSet.as_view({'get': 'list'})(req)
        self.assertEqual(resp.status_code, 200)
        d = resp.data
        rows = d['results'] if isinstance(d, dict) and 'results' in d else d
        return [r['subject'] for r in rows]

    # ---- new filters ------------------------------------------------------

    def test_filter_by_agent(self):
        self.assertEqual(self._list({'assigned_agent': self.agent_a.pk}), ['VIP refund'])

    def test_filter_by_group(self):
        """Freshdesk's "Group" is our department — modelled, never filterable."""
        self.assertCountEqual(self._list({'department': self.billing.pk}),
                              ['Chargeback', 'Plain'])

    def test_filter_by_single_tag(self):
        self.assertEqual(self._list({'tags': 'vip'}), ['VIP refund'])

    def test_filter_by_multiple_tags_is_or(self):
        self.assertCountEqual(self._list({'tags': 'vip, chargeback-risk'}),
                              ['VIP refund', 'Chargeback'])

    def test_untagged_tickets_excluded_by_tag_filter(self):
        self.assertNotIn('Plain', self._list({'tags': 'vip'}))

    def test_resolved_at_range_filter(self):
        from django.utils import timezone
        self.t_vip.resolved_at = timezone.now()
        self.t_vip.save(update_fields=['resolved_at'])
        today = timezone.now().date().isoformat()
        self.assertEqual(self._list({'resolved_at__date__gte': today}), ['VIP refund'])

    def test_closed_at_range_filter(self):
        from django.utils import timezone
        self.t_risk.closed_at = timezone.now()
        self.t_risk.save(update_fields=['closed_at'])
        today = timezone.now().date().isoformat()
        self.assertEqual(self._list({'closed_at__date__gte': today}), ['Chargeback'])

    # ---- helper endpoints -------------------------------------------------

    def test_tags_endpoint_lists_tags_in_use(self):
        req = self.rf.get('/api/tickets/tags/')
        force_authenticate(req, user=self.viewer)
        resp = TicketViewSet.as_view({'get': 'tags'})(req)
        self.assertCountEqual(resp.data['tags'], ['chargeback-risk', 'refund', 'vip'])

    def test_groups_endpoint_lists_departments(self):
        req = self.rf.get('/api/tickets/groups/')
        force_authenticate(req, user=self.viewer)
        resp = TicketViewSet.as_view({'get': 'groups'})(req)
        self.assertCountEqual([g['name'] for g in resp.data['groups']], ['Sales', 'Billing'])

    # ---- lifecycle timestamps --------------------------------------------

    def test_patching_status_to_closed_stamps_closed_at(self):
        """The UI closes a ticket with a plain PATCH; closed_at used to stay null."""
        req = self.rf.patch(f'/api/tickets/{self.t_plain.pk}/', {'status': 'closed'}, format='json')
        force_authenticate(req, user=self.viewer)
        TicketViewSet.as_view({'patch': 'partial_update'})(req, pk=self.t_plain.pk)
        self.t_plain.refresh_from_db()
        self.assertIsNotNone(self.t_plain.closed_at)

    def test_reopening_clears_the_timestamps(self):
        from django.utils import timezone
        self.t_plain.status = 'resolved'
        self.t_plain.resolved_at = timezone.now()
        self.t_plain.save()
        req = self.rf.patch(f'/api/tickets/{self.t_plain.pk}/', {'status': 'reopened'}, format='json')
        force_authenticate(req, user=self.viewer)
        TicketViewSet.as_view({'patch': 'partial_update'})(req, pk=self.t_plain.pk)
        self.t_plain.refresh_from_db()
        self.assertIsNone(self.t_plain.resolved_at)

    # ---- new status -------------------------------------------------------

    def test_waiting_on_third_party_is_a_valid_status(self):
        req = self.rf.patch(f'/api/tickets/{self.t_plain.pk}/',
                            {'status': 'waiting_third_party'}, format='json')
        force_authenticate(req, user=self.viewer)
        resp = TicketViewSet.as_view({'patch': 'partial_update'})(req, pk=self.t_plain.pk)
        self.assertEqual(resp.status_code, 200)
        self.t_plain.refresh_from_db()
        self.assertEqual(self.t_plain.status, 'waiting_third_party')
