from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from django.utils import timezone
from django.db.models import Count, Avg, Q, F
from django.db.models.functions import ExtractHour
from datetime import timedelta
from tickets.models import Ticket
from sla.models import SLABreachLog


class DashboardReportView(APIView):
    def get(self, request):
        now = timezone.now()
        today = now.date()
        yesterday = today - timedelta(days=1)
        week_ago = today - timedelta(days=7)

        qs = Ticket.objects.all()
        if request.user.role and request.user.role.name == 'agent':
            qs = qs.filter(assigned_agent=request.user)

        client_id = request.GET.get('client')
        if client_id:
            qs = qs.filter(client_id=client_id)
        channel = request.GET.get('channel')
        if channel:
            qs = qs.filter(channel=channel)

        active_statuses = [Ticket.NEW, Ticket.OPEN, Ticket.ASSIGNED, Ticket.IN_PROGRESS,
                           Ticket.ESCALATED, Ticket.WAITING_APPROVAL,
                           Ticket.WAITING_CLIENT, Ticket.WAITING_CUSTOMER]
        on_hold_statuses = [Ticket.WAITING_CUSTOMER, Ticket.WAITING_CLIENT]

        active_qs = qs.filter(status__in=active_statuses)

        # Hourly buckets — build 0-23 for today and yesterday
        def hourly_map(date):
            raw = dict(
                qs.filter(created_at__date=date)
                .annotate(hour=ExtractHour('created_at'))
                .values('hour').annotate(count=Count('id'))
                .values_list('hour', 'count')
            )
            return [{'hour': h, 'count': raw.get(h, 0)} for h in range(24)]

        received_today     = qs.filter(created_at__date=today).count()
        received_yesterday = qs.filter(created_at__date=yesterday).count()
        resolved_today     = qs.filter(resolved_at__date=today).count()
        resolved_yesterday = qs.filter(resolved_at__date=yesterday).count()

        avg_res = round(
            (qs.filter(resolved_at__isnull=False)
             .annotate(duration=F('resolved_at') - F('created_at'))
             .aggregate(avg=Avg('duration'))['avg'] or timedelta(0)).total_seconds() / 3600, 2
        )

        total_sla = qs.filter(first_response_due__isnull=False).count()
        breached_fr = qs.filter(
            first_responded_at__isnull=False,
            first_responded_at__gt=F('first_response_due')
        ).count()
        sla_rate = round((1 - breached_fr / total_sla) * 100, 1) if total_sla else 100.0

        return Response({
            'summary': {
                'total':             qs.count(),
                'unresolved':        active_qs.count(),
                'open':              qs.filter(status=Ticket.OPEN).count(),
                'overdue':           active_qs.filter(resolution_due__lt=now).count(),
                'due_today':         active_qs.filter(resolution_due__date=today).count(),
                'on_hold':           qs.filter(status__in=on_hold_statuses).count(),
                'unassigned':        active_qs.filter(assigned_agent__isnull=True).count(),
                'resolved_today':    resolved_today,
                'closed_today':      qs.filter(closed_at__date=today).count(),
                'escalated':         qs.filter(status=Ticket.ESCALATED).count(),
                'sla_breached':      active_qs.filter(resolution_due__lt=now).count(),
                'waiting_approval':  qs.filter(status=Ticket.WAITING_APPROVAL).count(),
                'received_today':    received_today,
                'received_yesterday': received_yesterday,
                'resolved_yesterday': resolved_yesterday,
            },
            'kpis': {
                'avg_resolution_hours': avg_res,
                'sla_compliance_rate':  sla_rate,
                'first_response_breached': breached_fr,
            },
            'hourly_today':     hourly_map(today),
            'hourly_yesterday': hourly_map(yesterday),
            'by_status':    list(qs.values('status').annotate(count=Count('id'))),
            'by_priority':  list(qs.values('priority').annotate(count=Count('id'))),
            'by_channel':   list(qs.values('channel').annotate(count=Count('id'))),
            'by_client':    list(active_qs.values('client__name').annotate(count=Count('id')).order_by('-count')[:10]),
            'daily_trend':  list(
                qs.filter(created_at__date__gte=week_ago)
                .values('created_at__date').annotate(count=Count('id')).order_by('created_at__date')
            ),
            'avg_resolution_hours': avg_res,
        })


class SLAReportView(APIView):
    def get(self, request):
        now = timezone.now()
        qs = Ticket.objects.all()
        active = [Ticket.NEW, Ticket.OPEN, Ticket.ASSIGNED, Ticket.IN_PROGRESS, Ticket.ESCALATED]

        total = qs.filter(first_response_due__isnull=False).count()
        breached_fr = qs.filter(
            first_responded_at__isnull=False,
            first_responded_at__gt=F('first_response_due')
        ).count()
        breached_res = qs.filter(status__in=active, resolution_due__lt=now).count()

        return Response({
            'total_with_sla': total,
            'first_response_breached': breached_fr,
            'resolution_breached': breached_res,
            'sla_compliance_rate': round((1 - breached_fr / total) * 100, 2) if total else 100,
            'breaches_by_priority': list(
                SLABreachLog.objects.values('ticket__priority')
                .annotate(count=Count('id'))
            ),
            'breaches_by_client': list(
                SLABreachLog.objects.values('ticket__client__name')
                .annotate(count=Count('id'))
                .order_by('-count')[:10]
            ),
        })


class AgentPerformanceReportView(APIView):
    def get(self, request):
        from core.models import User
        month_ago = timezone.now() - timedelta(days=30)
        agents = User.objects.filter(role__name='agent', is_active=True)
        data = []
        for agent in agents:
            qs = Ticket.objects.filter(assigned_agent=agent, created_at__gte=month_ago)
            data.append({
                'agent': agent.get_full_name(),
                'total_assigned': qs.count(),
                'resolved': qs.filter(status__in=['resolved', 'closed']).count(),
                'avg_csat': qs.aggregate(avg=Avg('customer_satisfaction'))['avg'],
                'sla_breached': qs.filter(
                    resolution_due__lt=timezone.now(),
                    status__in=['new', 'open', 'assigned', 'in_progress']
                ).count(),
            })
        return Response(sorted(data, key=lambda x: x['resolved'], reverse=True))
