"""AI auto-reply safety tests.

The auto-reply agent emails customers without a human in the loop, so the rules
that decide *not* to send matter more than the ones that decide to. Every test
here pins one of those refusals, plus the sweep that actually delivers — the
sweep silently stopped running once already and nothing caught it.

No test in this file reaches the Anthropic API; generation is stubbed.
"""
from datetime import timedelta
from unittest.mock import patch

from django.test import TestCase
from django.utils import timezone

from ai_services import auto_reply
from ai_services.models import AIReplyArchive, ScheduledReply
from clients.models import Client
from core.models import Role, SystemConfig, User
from tickets.models import Ticket, TicketComment

AI_JSON = (
    '{"concern": "Customer wants a refund", "category": "refund", '
    '"confidence": 95, "reply": "Hi Marc,\\n\\nYour refund is approved."}'
)


class AutoReplyTests(TestCase):
    def setUp(self):
        self.client_obj = Client.objects.create(name='Acme', code='ACME', is_active=True)
        self.agent = User.objects.create(
            username='agent1', first_name='Just', last_name='Tide',
            role=Role.objects.get_or_create(name='agent')[0], is_active=True)

        cfg = SystemConfig.get()
        cfg.ai_enabled = True
        cfg.autoreply_enabled = True
        cfg.autoreply_confidence = 85
        cfg.save()

    def _ticket(self, **kw):
        defaults = dict(client=self.client_obj, customer_name='Marc',
                        customer_email='marc@example.com', subject='Refund please',
                        description='I want a refund', channel='email',
                        assigned_agent=self.agent)
        defaults.update(kw)
        return Ticket.objects.create(**defaults)

    # ---- refusals ---------------------------------------------------------

    def test_never_replies_to_noreply_senders(self):
        t = self._ticket(customer_email='no-reply@shopify.com')
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['reason'], 'automated_sender')
        self.assertEqual(ScheduledReply.objects.count(), 0)

    def test_never_replies_to_dmarc_reports(self):
        t = self._ticket(subject='Report domain: example.com Submitter: google.com')
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['reason'], 'automated_sender')

    def test_disabled_switch_stops_everything(self):
        cfg = SystemConfig.get()
        cfg.autoreply_enabled = False
        cfg.save()
        t = self._ticket()
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['reason'], 'disabled')
        self.assertEqual(ScheduledReply.objects.count(), 0)

    def test_unassigned_ticket_drafts_instead_of_sending(self):
        """No assigned agent means nobody owns the reply — draft, don't send."""
        t = self._ticket(assigned_agent=None)
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['action'], 'drafted')
        self.assertEqual(ScheduledReply.objects.count(), 0)
        self.assertTrue(TicketComment.objects.filter(
            ticket=t, comment_type=TicketComment.INTERNAL).exists())

    def test_draft_only_mode_never_sends(self):
        cfg = SystemConfig.get()
        cfg.autoreply_confidence = 101      # the draft-only sentinel
        cfg.save()
        t = self._ticket()
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['action'], 'drafted')
        self.assertEqual(ScheduledReply.objects.count(), 0)

    def test_no_ai_response_produces_nothing(self):
        t = self._ticket()
        with patch('ai_services.views._claude_generate', return_value=None):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['reason'], 'no_ai')
        self.assertEqual(ScheduledReply.objects.count(), 0)

    # ---- the happy path ---------------------------------------------------

    def test_assigned_ticket_queues_a_delayed_reply(self):
        t = self._ticket()
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            result = auto_reply.auto_reply_to_ticket(t)
        self.assertEqual(result['action'], 'scheduled')
        sr = ScheduledReply.objects.get()
        self.assertEqual(sr.status, ScheduledReply.PENDING)
        self.assertEqual(sr.agent, self.agent)
        # Human-like delay, not instant.
        self.assertGreater(sr.send_at, timezone.now() + timedelta(minutes=4))

    def test_reply_is_signed_by_agent_and_team(self):
        t = self._ticket()
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            auto_reply.auto_reply_to_ticket(t)
        body = ScheduledReply.objects.get().body
        self.assertIn('Just Tide', body)
        self.assertIn(auto_reply.TEAM_SIGNOFF, body)

    def test_newer_customer_message_cancels_the_pending_reply(self):
        """Otherwise we answer a stale message and then answer again."""
        t = self._ticket()
        with patch('ai_services.views._claude_generate', return_value=AI_JSON):
            auto_reply.auto_reply_to_ticket(t)
            first = ScheduledReply.objects.get()
            auto_reply.auto_reply_to_ticket(t)
        first.refresh_from_db()
        self.assertEqual(first.status, ScheduledReply.CANCELLED)
        self.assertEqual(ScheduledReply.objects.filter(status='pending').count(), 1)

    # ---- the sweep --------------------------------------------------------

    def test_sweep_sends_due_replies_and_archives_them(self):
        t = self._ticket()
        sr = ScheduledReply.objects.create(
            ticket=t, agent=self.agent, subject='Re: Refund please', body='Hello there',
            send_at=timezone.now() - timedelta(minutes=1))
        with patch.object(auto_reply, '_send_ticket_email', return_value=(True, '<id@x>')):
            sent = auto_reply.send_due_replies()
        sr.refresh_from_db()
        self.assertEqual(sent, 1)
        self.assertEqual(sr.status, ScheduledReply.SENT)
        self.assertTrue(AIReplyArchive.objects.filter(kind='sent').exists())

    def test_sweep_leaves_future_replies_alone(self):
        t = self._ticket()
        sr = ScheduledReply.objects.create(
            ticket=t, agent=self.agent, body='Not yet',
            send_at=timezone.now() + timedelta(minutes=30))
        with patch.object(auto_reply, '_send_ticket_email', return_value=(True, '<id@x>')):
            self.assertEqual(auto_reply.send_due_replies(), 0)
        sr.refresh_from_db()
        self.assertEqual(sr.status, ScheduledReply.PENDING)

    def test_sweep_cancels_badly_overdue_replies(self):
        """A reply days late is no longer an answer — don't blast it."""
        t = self._ticket()
        sr = ScheduledReply.objects.create(
            ticket=t, agent=self.agent, body='Very stale',
            send_at=timezone.now() - timedelta(hours=auto_reply.STALE_AFTER_HOURS + 6))
        with patch.object(auto_reply, '_send_ticket_email', return_value=(True, '<id@x>')):
            self.assertEqual(auto_reply.send_due_replies(), 0)
        sr.refresh_from_db()
        self.assertEqual(sr.status, ScheduledReply.CANCELLED)

    def test_failed_send_is_recorded_not_lost(self):
        t = self._ticket()
        sr = ScheduledReply.objects.create(
            ticket=t, agent=self.agent, body='Will fail',
            send_at=timezone.now() - timedelta(minutes=1))
        with patch.object(auto_reply, '_send_ticket_email', return_value=(False, 'SMTP refused')):
            auto_reply.send_due_replies()
        sr.refresh_from_db()
        self.assertEqual(sr.status, ScheduledReply.FAILED)
        self.assertIn('SMTP', sr.error)
