from django.utils import timezone
from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.permissions import IsAuthenticated, IsAdminUser

from .models import ApparelItem, CollectionRecord
from .serializers import ApparelItemSerializer, CollectionRecordSerializer, ScanApparelSerializer
from apps.attendance.models import RegisteredMember


class ApparelItemViewSet(viewsets.ModelViewSet):
    serializer_class = ApparelItemSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        qs = ApparelItem.objects.select_related('event').all()
        is_active = self.request.query_params.get('is_active')
        if is_active is not None:
            qs = qs.filter(is_active=is_active.lower() == 'true')
        return qs

    def get_permissions(self):
        if self.action in ['list', 'retrieve']:
            return [IsAuthenticated()]
        return [IsAdminUser()]


class CollectionRecordViewSet(viewsets.ReadOnlyModelViewSet):
    serializer_class = CollectionRecordSerializer
    permission_classes = [IsAuthenticated]

    def get_queryset(self):
        qs = CollectionRecord.objects.select_related('apparel_item', 'recorded_by').all()
        item_id = self.request.query_params.get('item_id')
        search = self.request.query_params.get('search')
        if item_id:
            qs = qs.filter(apparel_item_id=item_id)
        if search:
            qs = qs.filter(full_name__icontains=search) | qs.filter(registration_code__icontains=search)
        return qs


class ScanApparelView(APIView):
    """Record apparel collection via barcode scan."""
    permission_classes = [IsAuthenticated]

    def post(self, request):
        serializer = ScanApparelSerializer(data=request.data)
        if not serializer.is_valid():
            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

        registration_code = serializer.validated_data['registration_code'].strip()
        apparel_item_id = serializer.validated_data['apparel_item_id']
        notes = serializer.validated_data.get('notes', '')

        try:
            apparel_item = ApparelItem.objects.get(id=apparel_item_id, is_active=True)
        except ApparelItem.DoesNotExist:
            return Response({'success': False, 'message': 'Apparel item not found or inactive.'}, status=status.HTTP_404_NOT_FOUND)

        # Look up member — must be a paid registered member
        member = None
        try:
            member = RegisteredMember.objects.get(registration_code=registration_code)
        except RegisteredMember.DoesNotExist:
            pass

        if member is None:
            return Response({'success': False, 'message': 'Registration code not found. Only pre-registered paid members can collect apparel.'})

        if not member.is_paid:
            return Response({
                'success': False,
                'message': f'Member payment status is "{member.payment_status}". Only PAID members can collect apparel.',
            })

        # Check if already collected
        existing = CollectionRecord.objects.filter(apparel_item=apparel_item, registration_code=registration_code).first()
        member_data = {
            'full_name': member.full_name,
            'email': member.email,
            'registration_code': member.registration_code,
            'payment_status': member.payment_status,
            'apparel_item': apparel_item.name,
        }

        if existing:
            return Response({
                'success': True,
                'already_collected': True,
                'message': 'Member has already collected this item.',
                'collected_at': existing.collected_at,
                'member': member_data,
            })

        record = CollectionRecord.objects.create(
            apparel_item=apparel_item,
            registration_code=registration_code,
            full_name=member.full_name,
            email=member.email,
            payment_status=member.payment_status,
            collected_at=timezone.now(),
            recorded_by=request.user,
            notes=notes,
        )

        return Response({
            'success': True,
            'already_collected': False,
            'message': 'Collection recorded successfully.',
            'collected_at': record.collected_at,
            'member': member_data,
        })


class ApparelDashboardView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        items = ApparelItem.objects.prefetch_related('collections').filter(is_active=True)
        data = []
        for item in items:
            data.append({
                'id': item.id,
                'name': item.name,
                'event_name': item.event.name if item.event else None,
                'collection_count': item.collection_count,
                'recent_collections': CollectionRecordSerializer(
                    item.collections.order_by('-collected_at')[:5], many=True
                ).data,
            })
        return Response({'items': data, 'total_active_items': len(data)})