# support/views.py
from django.shortcuts import get_object_or_404
from django.db.models import Q
from rest_framework.views import APIView
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateAPIView, CreateAPIView
from rest_framework.response import Response
from rest_framework import status, permissions, parsers

from .models import Ticket, TicketComment, TicketAttachment
from .serializers import TicketSerializer, TicketCommentSerializer, TicketAttachmentSerializer
from .permissions import SupportWritePermission
from .utils import parse_range
from users.models import CustomUser  # your user model
from .models import SupportSubject, SupportService
from .permissions import SupportWritePermission  # your admin/agent write guard

class TicketListCreateAPI(ListCreateAPIView):
    """
    GET /api/support/tickets/?status=&priority=&mobile=&order_id=&start_date=&end_date=
    POST /api/support/tickets/
    """
    serializer_class = TicketSerializer
    # permission_classes = [permissions.IsAuthenticated, SupportWritePermission]  # POST restricted
    permission_classes = [permissions.IsAuthenticated]

    def get_queryset(self):
        qs = Ticket.objects.select_related("requester", "assignee").all()
        q = self.request.query_params

        status_f = q.get("status")
        priority_f = q.get("priority")
        mobile = q.get("mobile") or q.get("mobile_number")
        order_id = q.get("order_id")
        start = q.get("start_date")
        end = q.get("end_date")
        service_id = q.get("service")

        if status_f:
            qs = qs.filter(status=status_f)
        if priority_f:
            qs = qs.filter(priority=priority_f)
        if mobile:
            qs = qs.filter(
                Q(requester__mobile_number=mobile) |
                Q(requester_mobile=mobile)
            )
        if order_id:
            qs = qs.filter(order_id=order_id)

        start_dt, end_dt = parse_range(start, end)
        if start_dt:
            qs = qs.filter(created_at__gte=start_dt)
        if end_dt:
            qs = qs.filter(created_at__lte=end_dt)

        if service_id:
            qs = qs.filter(service_id=service_id)

        # non-support users only see their own tickets
        user = self.request.user
        if getattr(user, "role", "user") not in {"admin","pincode_head","district_head","state_head","vertical_head","vendor"}:
            qs = qs.filter(Q(requester=user) | Q(requester_mobile=user.mobile_number))

        return qs.order_by("-created_at")

    def perform_create(self, serializer):
        # if requester not supplied (WhatsApp/phone), try to resolve by mobile
        requester = self.request.user if self.request.user.is_authenticated else None
        return serializer.save(requester=requester)

class TicketDetailAPI(RetrieveUpdateAPIView):
    """
    GET /api/support/tickets/<ticket_id>/
    PATCH /api/support/tickets/<ticket_id>/
    """
    serializer_class = TicketSerializer
    lookup_field = "ticket_id"
    queryset = Ticket.objects.select_related("requester", "assignee").all()
    permission_classes = [permissions.IsAuthenticated, SupportWritePermission]

    def get_queryset(self):
        qs = super().get_queryset()
        user = self.request.user
        if getattr(user, "role", "user") not in {"admin","pincode_head","district_head","state_head","vertical_head","vendor"}:
            qs = qs.filter(Q(requester=user) | Q(requester_mobile=user.mobile_number))
        return qs

class TicketCommentCreateAPI(CreateAPIView):
    """
    POST /api/support/tickets/<ticket_id>/comments/
    """
    serializer_class = TicketCommentSerializer
    # permission_classes = [permissions.IsAuthenticated, SupportWritePermission]
    permission_classes = [permissions.IsAuthenticated]


    def perform_create(self, serializer):
        ticket = get_object_or_404(Ticket, ticket_id=self.kwargs["ticket_id"])
        return serializer.save(ticket=ticket, author=self.request.user)

class TicketAttachmentUploadAPI(CreateAPIView):
    """
    POST multipart/form-data  /api/support/tickets/<ticket_id>/attachments/
    file=<file>
    """
    parser_classes = [parsers.MultiPartParser, parsers.FormParser]
    serializer_class = TicketAttachmentSerializer
    # permission_classes = [permissions.IsAuthenticated, SupportWritePermission]
    permission_classes = [permissions.IsAuthenticated]


    def perform_create(self, serializer):
        ticket = get_object_or_404(Ticket, ticket_id=self.kwargs["ticket_id"])
        return serializer.save(ticket=ticket, uploaded_by=self.request.user)

class TicketQuickIntakeAPI(APIView):
    """
    POST /api/support/tickets/intake/
    Body supports either free-text `subject` OR `subject_ref` (catalog) — subject auto-fills from catalog.
    {
      "mobile": "9999999999",           # required
      "subject": "",                    # optional if subject_ref provided
      "subject_ref": 4,                 # optional (FK to SupportSubject)
      "service": 1,                     # optional (FK to SupportService)
      "description": "Paid but not credited",
      "order_id": "ORD123",
      "priority": "high",
      "category": "Recharge"
    }
    """
    # permission_classes = [permissions.IsAuthenticated, SupportWritePermission]
    permission_classes = [permissions.IsAuthenticated]


    def post(self, request):
        payload = request.data or {}
        mobile = payload.get("mobile")
        if not mobile:
            return Response({"detail": "mobile is required."}, status=status.HTTP_400_BAD_REQUEST)

        # Link to existing user if found
        user = CustomUser.objects.filter(mobile_number=mobile).first()

        # Build data for serializer; allow subject to be blank — serializer will backfill from subject_ref
        data = {
            "requester": user.id if user else None,
            "requester_mobile": mobile,
            "subject": payload.get("subject", ""),                 # can be blank
            "subject_ref": payload.get("subject_ref"),             # FK id or null
            "service": payload.get("service"),                     # FK id or null
            "description": payload.get("description", ""),
            "order_id": payload.get("order_id"),
            "priority": payload.get("priority", "medium"),
            "category": payload.get("category"),
        }

        ser = TicketSerializer(data=data, context={"request": request})
        ser.is_valid(raise_exception=True)
        ticket = ser.save()
        return Response(ser.data, status=status.HTTP_201_CREATED)