import uuid

from django.db import transaction
from django.db.models import CharField, Max
from django.db.models.functions import Cast
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.pagination import PageNumberPagination
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.utils import json

from apps.common.serializers import AIAnnotateTeamMemberSerializer, AIAnnotateTeamSerializer
from apps.core.models import AIAnnotateTeam, AIAnnotateTeamMember


@api_view(["POST"])
@permission_classes([IsAuthenticated])
def create_annotate_team(request):
    data = request.data
    data["id"] = str(uuid.uuid4())
    max_team_code = AIAnnotateTeam.objects.aggregate(
        team_code=Max(Cast("team_code", CharField()))
    ).get("team_code")
    max_team_code = int(max_team_code) if max_team_code is not None else 0
    new_team_code = f"{max_team_code + 1:04}"
    data["team_code"] = new_team_code
    data["status"] = "01"
    serializer = AIAnnotateTeamSerializer(data=data)

    if serializer.is_valid():
        serializer.save()
        return Response({"message": "团队创建成功"})

    return Response(
        {"error": "无效的数据", "details": serializer.errors},
        status=status.HTTP_400_BAD_REQUEST,
    )


@api_view(["POST"])
@permission_classes([IsAuthenticated])
@transaction.atomic
def add_team_members(request):
    data = request.data
    team_id = data.get("team_id")
    josn_str = data.get("team_members")
    members = json.loads(josn_str)

    objects_to_save = []

    for member in members:
        if not AIAnnotateTeamMember.objects.filter(
            team_id=team_id, member_account=member.get("member_account")
        ).exists():
            member_obj = AIAnnotateTeamMember(
                id=str(uuid.uuid4()),
                team_id=team_id,
                member_account=member.get("member_account"),
                member_name=member.get("member_name"),
                member_email=member.get("member_email"),
            )
            objects_to_save.append(member_obj)

    AIAnnotateTeamMember.objects.bulk_create(objects_to_save)
    return Response({"message": "团队成员添加成功"})


@api_view(["GET"])
@permission_classes([IsAuthenticated])
def read_annotate_team(request):
    team_id = request.GET.get("id", None)
    team = get_object_or_404(AIAnnotateTeam, id=team_id)
    serializer = AIAnnotateTeamSerializer(team)
    return Response(serializer.data)


@api_view(["GET"])
@permission_classes([IsAuthenticated])
def search_annotate_team(request):
    team_code = request.GET.get("team_code", None)
    team_name = request.GET.get("team_name", None)
    organization = request.GET.get("organization", None)
    page_size = request.GET.get("page_size", None)
    filter_kwargs = {}
    if team_code:
        filter_kwargs["team_code__icontains"] = team_code
    if team_name:
        filter_kwargs["team_name__icontains"] = team_name
    if organization:
        filter_kwargs["organization"] = organization

    teams = AIAnnotateTeam.objects.filter(**filter_kwargs).order_by("team_code")

    paginator = PageNumberPagination()
    paginator.page_size = page_size or 10
    result_page = paginator.paginate_queryset(teams, request)
    serializer = AIAnnotateTeamSerializer(result_page, many=True)
    return paginator.get_paginated_response(serializer.data)


@api_view(["GET"])
@permission_classes([IsAuthenticated])
def get_team_members(request):
    team_id = request.GET.get("team_id", None)
    filter_kwargs = {}
    if team_id:
        filter_kwargs["team_id"] = team_id

    members = AIAnnotateTeamMember.objects.filter(**filter_kwargs).order_by(
        "-member_role", "member_name"
    )
    serializer = AIAnnotateTeamMemberSerializer(members, many=True)
    return Response(serializer.data)


@api_view(["PUT"])
@permission_classes([IsAuthenticated])
def update_annotate_team(request):
    data = request.data
    team = get_object_or_404(AIAnnotateTeam, id=data.get("id"))
    serializer = AIAnnotateTeamSerializer(instance=team, data=data, partial=True)
    if serializer.is_valid():
        serializer.save()
        return Response({"message": "团队更新成功"})

    return Response(
        {"error": "无效的数据", "details": serializer.errors},
        status=status.HTTP_400_BAD_REQUEST,
    )


@api_view(["PUT"])
@permission_classes([IsAuthenticated])
@transaction.atomic
def update_team_member(request):
    data = request.data
    team_member = get_object_or_404(AIAnnotateTeamMember, id=data.get("id"))
    member_role = data.get("member_role")
    if member_role == "leader":
        AIAnnotateTeamMember.objects.filter(team_id=team_member.team_id).exclude(
            id__in=team_member.id
        ).update(member_role="labeler")
        AIAnnotateTeam.objects.filter(id=team_member.team_id).update(
            team_leader_id=team_member.member_account,
            team_leader_name=team_member.member_name,
        )
    serializer = AIAnnotateTeamMemberSerializer(instance=team_member, data=data, partial=True)
    if serializer.is_valid():
        serializer.save()
        return Response({"message": "团队成员更新成功"})

    return Response(
        {"error": "无效的数据", "details": serializer.errors},
        status=status.HTTP_400_BAD_REQUEST,
    )


@api_view(["DELETE"])
@permission_classes([IsAuthenticated])
def delete_annotate_team(request):
    team_id = request.GET.get("id", None)
    team = get_object_or_404(AIAnnotateTeam, id=team_id)
    team.delete()
    return Response({"message": "团队删除成功"})


@api_view(["DELETE"])
def delete_team_members(request):
    member_ids = request.GET.get("ids", None)

    if member_ids is None:
        return Response({"message": "未选择成员ID"}, status=400)

    ids = [id for id in member_ids.split(",")]
    if ids:
        queryset = AIAnnotateTeamMember.objects.filter(id__in=ids)
        queryset.delete()

    return Response({"message": "团队成员删除成功"})