from rest_framework import viewsets, status, filters, permissions
from rest_framework.decorators import action
from rest_framework.exceptions import PermissionDenied
from rest_framework.response import Response
from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
from django.utils import timezone
from django_filters.rest_framework import DjangoFilterBackend
from django.db.models import Count, Q
from .models import Ticket, TicketComment, TicketAttachment, TicketHistory
from .serializers import (TicketListSerializer, TicketDetailSerializer,
                          TicketCreateSerializer, TicketCommentSerializer,
                          TicketAttachmentSerializer, TicketHistorySerializer)
from audit.models import AuditLog


# Roles that belong to the service provider and may see the whole ticket queue.
# Anything NOT in here (client-portal roles, or an account with no role) is
# scoped to its own client — see TicketViewSet.get_queryset.
INTERNAL_ROLES = {'system_admin', 'operations_manager', 'team_leader', 'qa_analyst', 'agent'}

from core.scoping import is_ticket_readonly  # noqa: E402


def _notify_critical(ticket):
    """Send in-app notifications to admins/managers/client-admins when a ticket is critical."""
    from core.models import User
    from notifications.models import Notification
    title = f'🚨 Critical Ticket: {ticket.ticket_number}'
    message = (
        f'[{ticket.client.name if ticket.client else ""}] '
        f'{ticket.subject or "No subject"} — assigned to '
        f'{ticket.assigned_agent.get_full_name() if ticket.assigned_agent else "Unassigned"}'
    )
    # system_admin, operations_manager, team_leader always notified
    privileged_roles = ['system_admin', 'operations_manager', 'team_leader']
    recipients = list(User.objects.filter(
        is_active=True,
        role__name__in=privileged_roles,
    ))
    # client_admin only for their own client
    if ticket.client:
        client_admins = list(User.objects.filter(
            is_active=True,
            role__name='client_admin',
            client=ticket.client,
        ))
        recipients += client_admins
    if not recipients:
        return
    Notification.objects.bulk_create([
        Notification(
            recipient=u,
            notification_type='system',
            title=title,
            message=message,
            ticket=ticket,
            channel='in_app',
            sent=True,
        ) for u in recipients
    ])


def _notify_escalation(ticket):
    """Email the client's configured Escalation Email when a ticket is escalated."""
    if not ticket.client_id:
        return
    from clients.models import ClientConfiguration
    from django.core.mail import send_mail
    from django.conf import settings
    cfg = ClientConfiguration.objects.filter(client=ticket.client).first()
    raw = (cfg.escalation_email if cfg else '') or ''
    recipients = [e.strip() for e in raw.replace(';', ',').split(',') if e.strip()]
    if not recipients:
        return
    agent = ticket.assigned_agent.get_full_name() if ticket.assigned_agent else 'Unassigned'
    subject = f"[ESCALATED] {ticket.ticket_number} — {(ticket.subject or '')[:80]}"
    body = (
        f"A ticket has been escalated and needs attention.\n\n"
        f"Ticket:   {ticket.ticket_number}\n"
        f"Client:   {ticket.client.name}\n"
        f"Subject:  {ticket.subject}\n"
        f"Priority: {ticket.get_priority_display()}\n"
        f"Customer: {ticket.customer_name} <{ticket.customer_email}>\n"
        f"Assigned: {agent}\n\n"
        f"{(ticket.description or '')[:600]}"
    )
    try:
        send_mail(subject, body, getattr(settings, 'DEFAULT_FROM_EMAIL', None),
                  recipients, fail_silently=True)
    except Exception:
        pass


class TicketViewSet(viewsets.ModelViewSet):
    queryset = Ticket.objects.select_related(
        'client', 'assigned_agent', 'assigned_team_leader',
        'category', 'sub_category', 'department', 'sla_policy', 'parent'
    ).all()
    filterset_fields = ['status', 'priority', 'client', 'assigned_agent',
                        'channel', 'severity', 'category', 'ticket_type',
                        # Group/Campaign and sub-disposition — modelled all along,
                        # just never exposed as filters.
                        'department', 'sub_category', 'assigned_team_leader']

    def initial(self, request, *args, **kwargs):
        """Enforce read-only oversight accounts before any handler runs.

        Gating here rather than in each method covers create/update/delete AND
        every @action (reply, note, assign, escalate, resolve…) in one place, so
        a new action can't accidentally ship without the check.
        """
        super().initial(request, *args, **kwargs)
        if request.method not in permissions.SAFE_METHODS and is_ticket_readonly(request.user):
            raise PermissionDenied(
                'System Administrator accounts have view-only access to tickets. '
                'Use an agent or team leader account to work on this ticket.')

    def get_queryset(self):
        qs = super().get_queryset()
        # Annotate sub-ticket count in a single query instead of a per-row
        # COUNT(*) (avoids an N+1 that made list endpoints scale linearly).
        qs = qs.annotate(sub_ticket_count=Count('sub_tickets'))
        user = self.request.user
        role_name = getattr(getattr(user, 'role', None), 'name', None)

        # Tenant isolation. Internal staff see the whole queue (an agent still
        # only sees their own tickets). ANYONE ELSE — client-portal users, and
        # accounts with no role at all — is hard-scoped to their own client, so
        # a missing/incorrect role can never expose another client's tickets.
        # Enforced here rather than relying on the frontend sending ?client=.
        if user.is_superuser or user.is_staff or role_name in INTERNAL_ROLES:
            if role_name == 'agent':
                qs = qs.filter(assigned_agent=user)
        else:
            client_id = getattr(user, 'client_id', None)
            # Fail closed: no client and not staff means no tickets, not all.
            qs = qs.filter(client_id=client_id) if client_id else qs.none()
        # Default to most-recently-active first (Freshdesk-style): a new ticket
        # or a fresh customer reply bubbles to the top. An explicit ?ordering=
        # query param still overrides this. Also gives pagination a stable order
        # (silences UnorderedObjectListWarning).
        return qs.order_by('-updated_at', '-id')

    def filter_queryset(self, queryset):
        queryset = super().filter_queryset(queryset)
        p = self.request.query_params

        # Multi-value filters sent as comma-separated strings
        status_in = p.get('status__in')
        if status_in:
            queryset = queryset.filter(status__in=[s.strip() for s in status_in.split(',')])

        priority_in = p.get('priority__in')
        if priority_in:
            queryset = queryset.filter(priority__in=[s.strip() for s in priority_in.split(',')])

        ticket_type_in = p.get('ticket_type__in')
        if ticket_type_in:
            queryset = queryset.filter(ticket_type__in=[s.strip() for s in ticket_type_in.split(',')])

        channel_in = p.get('channel__in')
        if channel_in:
            queryset = queryset.filter(channel__in=[s.strip() for s in channel_in.split(',')])

        client_in = p.get('client__in')
        if client_in:
            queryset = queryset.filter(client__in=[s.strip() for s in client_in.split(',')])

        # Date range filters
        from_date = p.get('created_at__date__gte')
        if from_date:
            queryset = queryset.filter(created_at__date__gte=from_date)

        to_date = p.get('created_at__date__lte')
        if to_date:
            queryset = queryset.filter(created_at__date__lte=to_date)

        # Overdue / due today filters
        res_due_lt = p.get('resolution_due__lt')
        if res_due_lt:
            queryset = queryset.filter(resolution_due__lt=res_due_lt)

        res_due_date = p.get('resolution_due__date')
        if res_due_date:
            queryset = queryset.filter(resolution_due__date=res_due_date)

        # Unassigned filter
        if p.get('assigned_agent__isnull') == 'true':
            queryset = queryset.filter(assigned_agent__isnull=True)

        # Multi-select Agent and Group, matching how the other __in filters work.
        # These are integer FKs, so a non-numeric value is dropped rather than
        # raising a 500 on a malformed query string.
        for param, field in (('assigned_agent__in', 'assigned_agent_id'),
                             ('department__in', 'department_id')):
            raw = p.get(param)
            if raw:
                ids = [v.strip() for v in raw.split(',') if v.strip().isdigit()]
                if ids:
                    queryset = queryset.filter(**{f'{field}__in': ids})

        # --- Resolved / Closed date ranges -------------------------------
        # Created-at already had a range; resolution and closure did not, so
        # "how many did we close last week" was unanswerable.
        for field in ('resolved_at', 'closed_at'):
            gte = p.get(f'{field}__date__gte')
            if gte:
                queryset = queryset.filter(**{f'{field}__date__gte': gte})
            lte = p.get(f'{field}__date__lte')
            if lte:
                queryset = queryset.filter(**{f'{field}__date__lte': lte})

        # --- Tags --------------------------------------------------------
        # Comma-separated in the query means ANY of them (OR), which is how
        # people read a tag filter — "show me vip or chargeback-risk".
        tags = (p.get('tags') or '').strip()
        if tags:
            wanted = [t.strip() for t in tags.split(',') if t.strip()]
            if wanted:
                q = Q()
                for t in wanted:
                    q |= Q(tags__icontains=t)
                queryset = queryset.filter(q)

        return queryset

    @action(detail=False, methods=['get'])
    def tags(self, request):
        """Every tag in use, for populating the filter without free-typing."""
        seen = set()
        for raw in self.get_queryset().exclude(tags='').values_list('tags', flat=True):
            for t in (raw or '').split(','):
                t = t.strip()
                if t:
                    seen.add(t)
        return Response({'tags': sorted(seen, key=str.lower)})

    @action(detail=False, methods=['get'])
    def groups(self, request):
        """Departments (Freshdesk calls these Groups) that tickets can belong to."""
        from clients.models import ClientDepartment
        from core.scoping import scope_to_client
        qs = scope_to_client(ClientDepartment.objects.all(), request.user)
        client_id = request.query_params.get('client')
        if client_id:
            qs = qs.filter(client_id=client_id)
        return Response({'groups': [
            {'id': d.pk, 'name': d.name, 'client': d.client_id} for d in qs.order_by('name')
        ]})
    search_fields = ['ticket_number', 'customer_name', 'customer_email',
                     'customer_phone', 'subject', 'description']
    ordering_fields = ['created_at', 'updated_at', 'resolution_due', 'priority']

    def get_serializer_class(self):
        if self.action == 'list':
            return TicketListSerializer
        if self.action == 'create':
            return TicketCreateSerializer
        return TicketDetailSerializer

    def perform_create(self, serializer):
        instance = serializer.save()
        if instance.priority == 'critical':
            _notify_critical(instance)

    def perform_update(self, serializer):
        old = self.get_object()
        old_priority = old.priority
        old_status = old.status
        instance = serializer.save()
        # Stamp the lifecycle timestamps here too, not only in the change-status
        # action. The UI changes status with a plain PATCH, so closed_at and
        # resolved_at were staying empty — which made "Closed At" unreportable.
        stamp = []
        if instance.status != old_status:
            if instance.status == Ticket.RESOLVED and not instance.resolved_at:
                instance.resolved_at = timezone.now()
                stamp.append('resolved_at')
            elif instance.status == Ticket.CLOSED and not instance.closed_at:
                instance.closed_at = timezone.now()
                stamp.append('closed_at')
            # Reopening clears them, or the ticket looks resolved and open at once.
            elif instance.status in (Ticket.REOPENED, Ticket.OPEN, Ticket.IN_PROGRESS):
                if instance.resolved_at or instance.closed_at:
                    instance.resolved_at = None
                    instance.closed_at = None
                    stamp += ['resolved_at', 'closed_at']
        if stamp:
            instance.save(update_fields=list(set(stamp)))
        if instance.priority == 'critical' and old_priority != 'critical':
            _notify_critical(instance)
        # Email the client's Escalation Email when a ticket becomes escalated.
        if instance.status == Ticket.ESCALATED and old_status != Ticket.ESCALATED:
            _notify_escalation(instance)
        fields_to_track = ['status', 'priority', 'assigned_agent', 'assigned_team_leader']
        for field in fields_to_track:
            old_val = str(getattr(old, field, ''))
            new_val = str(getattr(instance, field, ''))
            if old_val != new_val:
                TicketHistory.objects.create(
                    ticket=instance,
                    user=self.request.user,
                    field_changed=field,
                    old_value=old_val,
                    new_value=new_val,
                )
                AuditLog.objects.create(
                    user=self.request.user,
                    action='update',
                    model_name='Ticket',
                    object_id=str(instance.id),
                    object_repr=instance.ticket_number,
                    previous_value={field: old_val},
                    new_value={field: new_val},
                )

    @action(detail=True, methods=['post'])
    def add_comment(self, request, pk=None):
        ticket = self.get_object()
        serializer = TicketCommentSerializer(data={**request.data, 'ticket': ticket.id})
        if serializer.is_valid():
            comment = serializer.save(author=request.user)
            if request.data.get('comment_type') == 'public' and not ticket.first_responded_at:
                ticket.first_responded_at = timezone.now()
                ticket.save(update_fields=['first_responded_at'])
            AuditLog.objects.create(
                user=request.user, action='comment',
                model_name='Ticket', object_id=str(ticket.id),
                object_repr=ticket.ticket_number,
            )
            return Response(TicketCommentSerializer(comment).data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    @action(detail=True, methods=['post'])
    def upload_attachment(self, request, pk=None):
        ticket = self.get_object()
        file = request.FILES.get('file')
        if not file:
            return Response({'error': 'No file provided'}, status=status.HTTP_400_BAD_REQUEST)
        attachment = TicketAttachment.objects.create(
            ticket=ticket,
            uploaded_by=request.user,
            file=file,
            filename=file.name,
            file_size=file.size,
            file_type=file.content_type,
            tags=request.data.get('tags', ''),
        )
        AuditLog.objects.create(
            user=request.user, action='attachment',
            model_name='Ticket', object_id=str(ticket.id),
            object_repr=ticket.ticket_number,
        )
        return Response(TicketAttachmentSerializer(attachment).data, status=status.HTTP_201_CREATED)

    @action(detail=True, methods=['post'])
    def change_status(self, request, pk=None):
        ticket = self.get_object()
        new_status = request.data.get('status')
        reason = request.data.get('reason', '')
        if new_status not in dict(Ticket.STATUS_CHOICES):
            return Response({'error': 'Invalid status'}, status=status.HTTP_400_BAD_REQUEST)
        old_status = ticket.status
        ticket.status = new_status
        if new_status == Ticket.RESOLVED:
            ticket.resolved_at = timezone.now()
        elif new_status == Ticket.CLOSED:
            ticket.closed_at = timezone.now()
            ticket.closure_reason = reason
        elif new_status == Ticket.REOPENED:
            ticket.reopen_count += 1
        ticket.save()
        TicketHistory.objects.create(
            ticket=ticket, user=request.user,
            field_changed='status', old_value=old_status, new_value=new_status,
        )
        AuditLog.objects.create(
            user=request.user, action='status_change',
            model_name='Ticket', object_id=str(ticket.id),
            object_repr=ticket.ticket_number,
            previous_value={'status': old_status},
            new_value={'status': new_status},
        )
        return Response(TicketDetailSerializer(ticket).data)

    @action(detail=True, methods=['post'])
    def assign(self, request, pk=None):
        ticket = self.get_object()
        agent_id = request.data.get('agent_id')
        from core.models import User
        try:
            agent = User.objects.get(id=agent_id)
        except User.DoesNotExist:
            return Response({'error': 'Agent not found'}, status=status.HTTP_404_NOT_FOUND)
        old_agent = str(ticket.assigned_agent)
        ticket.assigned_agent = agent
        if ticket.status == Ticket.NEW:
            ticket.status = Ticket.ASSIGNED
        ticket.save()
        TicketHistory.objects.create(
            ticket=ticket, user=request.user,
            field_changed='assigned_agent', old_value=old_agent, new_value=str(agent),
        )
        return Response(TicketDetailSerializer(ticket).data)

    @action(detail=True, methods=['post'])
    def send_email(self, request, pk=None):
        ticket = self.get_object()
        subject = request.data.get('subject', f'Re: {ticket.subject}')
        body = request.data.get('body', '').strip()
        to_email = request.data.get('to', ticket.customer_email)
        if not body:
            return Response({'error': 'Email body is required.'}, status=400)
        if not to_email:
            return Response({'error': 'No recipient email address on this ticket.'}, status=400)
        try:
            from clients.models import ClientEmailAccount
            # Use the same account that received the ticket (matched by channel_source name)
            acct = ClientEmailAccount.objects.filter(
                client=ticket.client, is_active=True, name=ticket.channel_source
            ).first() or ClientEmailAccount.objects.filter(
                client=ticket.client, is_active=True
            ).first()
            if not acct:
                return Response({'error': 'No active email account configured for this client. Go to Configuration → Email.'}, status=400)
            import smtplib
            from email.mime.text import MIMEText
            from email.mime.multipart import MIMEMultipart
            from email.utils import make_msgid
            msg = MIMEMultipart('alternative')
            msg['Subject'] = subject
            msg['From'] = f'{acct.name} <{acct.email}>'
            msg['To'] = to_email
            msg['Reply-To'] = acct.email
            out_msgid = make_msgid(domain=(acct.email.split('@')[-1] or None))
            msg['Message-ID'] = out_msgid
            # Thread the outgoing mail against the customer's original email so
            # their reply comes back In-Reply-To one of this ticket's messages.
            if ticket.source_message_id:
                msg['In-Reply-To'] = ticket.source_message_id
                msg['References'] = ticket.source_message_id
            plain = MIMEText(body, 'plain', 'utf-8')
            html_body = body.replace('\n', '<br>')
            html = MIMEText(f'<div style="font-family:sans-serif;font-size:14px;line-height:1.6">{html_body}</div>', 'html', 'utf-8')
            msg.attach(plain); msg.attach(html)
            # Choose transport by port: 465 = implicit SSL, 587/25 = STARTTLS.
            # (Using STARTTLS on 465 is the classic "reply never sends" bug.)
            port = int(acct.smtp_port)
            if port == 465:
                server = smtplib.SMTP_SSL(acct.smtp_host, port, timeout=20)
            else:
                server = smtplib.SMTP(acct.smtp_host, port, timeout=20)
                if acct.smtp_tls:
                    server.starttls()
            raw = msg.as_string()
            server.login(acct.smtp_user or acct.email, acct.smtp_pass)
            server.sendmail(acct.email, [to_email], raw)
            server.quit()
            # File a copy in the mailbox's Sent folder so agent replies appear
            # there too — SMTP alone leaves Sent empty.
            from core.mailbox import save_to_sent
            save_to_sent(acct, raw)
            # Log as public reply comment. Store our Message-ID so the customer's
            # reply threads back onto this ticket; bump activity so it rises.
            from .models import TicketComment
            from django.utils import timezone as tz
            TicketComment.objects.create(
                ticket=ticket,
                author=request.user,
                body=f'[Email sent to {to_email}]\n\n{body}',
                comment_type='public',
                source_message_id=out_msgid,
            )
            update_fields = ['updated_at']
            if not ticket.first_responded_at:
                ticket.first_responded_at = tz.now()
                update_fields.append('first_responded_at')
            ticket.save(update_fields=update_fields)
            return Response({'ok': True, 'message': f'Email sent to {to_email}.'})
        except Exception as e:
            return Response({'error': str(e)}, status=400)

    @action(detail=False, methods=['get'])
    def my_tickets(self, request):
        tickets = self.get_queryset().filter(assigned_agent=request.user)
        serializer = TicketListSerializer(tickets, many=True)
        return Response(serializer.data)

    @action(detail=False, methods=['get'])
    def overdue(self, request):
        now = timezone.now()
        tickets = self.get_queryset().filter(
            resolution_due__lt=now,
            status__in=[Ticket.NEW, Ticket.OPEN, Ticket.ASSIGNED, Ticket.IN_PROGRESS, Ticket.ESCALATED]
        )
        return Response(TicketListSerializer(tickets, many=True).data)

    @action(detail=False, methods=['get'])
    def dashboard_stats(self, request):
        from django.db.models import Count
        from django.db.models.functions import ExtractHour
        qs = self.get_queryset()
        now = timezone.now()
        today = now.date()
        active_statuses = [Ticket.NEW, Ticket.OPEN, Ticket.ASSIGNED, Ticket.IN_PROGRESS,
                           Ticket.WAITING_CUSTOMER, Ticket.WAITING_CLIENT, Ticket.WAITING_APPROVAL, Ticket.ESCALATED]
        unresolved_qs = qs.filter(status__in=active_statuses)

        # Hourly trend for today
        hourly = (
            qs.filter(created_at__date=today)
            .annotate(hour=ExtractHour('created_at'))
            .values('hour')
            .annotate(count=Count('id'))
            .order_by('hour')
        )
        hourly_data = {row['hour']: row['count'] for row in hourly}
        trend = [{'hour': h, 'count': hourly_data.get(h, 0)} for h in range(24)]

        # Unresolved by client
        by_client = (
            unresolved_qs
            .values('client__name')
            .annotate(count=Count('id'))
            .order_by('-count')[:10]
        )

        return Response({
            'unresolved': unresolved_qs.count(),
            'overdue': qs.filter(
                resolution_due__lt=now,
                status__in=active_statuses
            ).count(),
            'due_today': qs.filter(
                resolution_due__date=today,
                status__in=active_statuses
            ).count(),
            'open': qs.filter(status=Ticket.OPEN).count(),
            'on_hold': qs.filter(status__in=[Ticket.WAITING_CUSTOMER, Ticket.WAITING_CLIENT]).count(),
            'unassigned': unresolved_qs.filter(assigned_agent__isnull=True).count(),
            'resolved_today': qs.filter(resolved_at__date=today).count(),
            'received_today': qs.filter(created_at__date=today).count(),
            'avg_first_response_hrs': None,
            'resolution_within_sla_pct': None,
            'trend': trend,
            'by_client': [{'client': r['client__name'] or 'Unknown', 'count': r['count']} for r in by_client],
        })
