from django.shortcuts import render
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework import status
from django.db import transaction
from .models import SupervisorGroup
from .serializers import SupervisorGroupSerializer
from ErrorLogs.utils import log_error

# Create your views here.

@api_view(['GET', 'POST'])
def supervisor_group_list(request):
    if request.method == 'GET':
        try:
            supervisor_groups = SupervisorGroup.objects.all()
            serializer = SupervisorGroupSerializer(supervisor_groups, many=True)
            return Response(serializer.data)
        except Exception as e:
            log_error('supervisor_group_list.GET', e)
            return Response(
                {"error": "An error occurred while fetching supervisor groups"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )
    
    elif request.method == 'POST':
        try:
            with transaction.atomic():
                # Check if this is a bulk create request (users is a list)
                users = request.data.get('users', [])
                if isinstance(users, list) and len(users) > 0:
                    # Bulk create multiple supervisor groups
                    group = request.data.get('group')
                    primary_user = request.data.get('primaryUser')
                    
                    if not group:
                        return Response(
                            {"error": "group is required"},
                            status=status.HTTP_400_BAD_REQUEST
                        )
                    
                    created_groups = []
                    for user_id in users:
                        serializer = SupervisorGroupSerializer(data={
                            'group': group,
                            'user': user_id,
                            'isprimary': primary_user == user_id,
                        })
                        if serializer.is_valid():
                            supervisor_group = serializer.save()
                            created_groups.append(SupervisorGroupSerializer(supervisor_group).data)
                        else:
                            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
                    
                    # Return the first created group (for backward compatibility)
                    # The frontend will handle refreshing the full list
                    return Response(created_groups[0] if created_groups else {}, status=status.HTTP_201_CREATED)
                else:
                    # Single create (backward compatibility)
                    serializer = SupervisorGroupSerializer(data=request.data)
                    if serializer.is_valid():
                        supervisor_group = serializer.save()
                        return Response(SupervisorGroupSerializer(supervisor_group).data, status=status.HTTP_201_CREATED)
                    return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        except Exception as e:
            log_error('supervisor_group_list.POST', e)
            return Response(
                {"error": "An error occurred while creating supervisor group"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

@api_view(['GET', 'PUT', 'DELETE'])
def supervisor_group_detail(request, pk):
    try:
        supervisor_group = SupervisorGroup.objects.get(pk=pk)
    except SupervisorGroup.DoesNotExist:
        return Response(status=status.HTTP_404_NOT_FOUND)
    except Exception as e:
        log_error('supervisor_group_detail.get_supervisor_group', e)
        return Response(
            {"error": "An error occurred while fetching supervisor group"},
            status=status.HTTP_500_INTERNAL_SERVER_ERROR
        )

    if request.method == 'GET':
        try:
            serializer = SupervisorGroupSerializer(supervisor_group)
            return Response(serializer.data)
        except Exception as e:
            log_error('supervisor_group_detail.GET', e)
            return Response(
                {"error": "An error occurred while fetching supervisor group details"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

    elif request.method == 'PUT':
        try:
            with transaction.atomic():
                serializer = SupervisorGroupSerializer(supervisor_group, data=request.data)
                if serializer.is_valid():
                    updated_supervisor_group = serializer.save()
                    return Response(SupervisorGroupSerializer(updated_supervisor_group).data)
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
        except Exception as e:
            log_error('supervisor_group_detail.PUT', e)
            return Response(
                {"error": "An error occurred while updating supervisor group"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

    elif request.method == 'DELETE':
        try:
            with transaction.atomic():
                supervisor_group.delete()
                return Response(status=status.HTTP_204_NO_CONTENT)
        except Exception as e:
            log_error('supervisor_group_detail.DELETE', e)
            return Response(
                {"error": "An error occurred while deleting supervisor group"},
                status=status.HTTP_500_INTERNAL_SERVER_ERROR
            )

@api_view(['GET'])
def get_supervisor_groups_by_user(request, user_id):
    try:
        supervisor_groups = SupervisorGroup.objects.filter(user_id=user_id)
        serializer = SupervisorGroupSerializer(supervisor_groups, many=True)
        return Response(serializer.data)
    except Exception as e:
        log_error('get_supervisor_groups_by_user', e)
        return Response(
            {"error": "An error occurred while fetching supervisor groups"},
            status=status.HTTP_500_INTERNAL_SERVER_ERROR
        )