from usuarios.permissions import IsClubAdmin, IsClubStaff
import json

from django.shortcuts import render
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny, IsAuthenticated
from rest_framework.response import Response
from django.utils import timezone
from eventos.models import Evento
from usuarios.models import UsersTeams, Equipos


# Create your views here.
@api_view(['GET'])
def get_user_events(request, user_id):
    # Obtener todos los equipos del usuario
    user_teams = UsersTeams.objects.filter(
        idUser=user_id
    ).select_related('idTeam')

    team_ids = [ut.idTeam.id for ut in user_teams if ut.idTeam]

    # Obtener eventos de todos los equipos del usuario
    eventos = Evento.objects.filter(
        equipo_id__in=team_ids,
        fecha_inicio__gte=timezone.now()  # Solo eventos futuros
    ).select_related('equipo').order_by('fecha_inicio')

    eventos_data = [
        {
            'id': evento.id,
            'titulo': evento.titulo,
            'descripcion': evento.descripcion,
            'tipo': evento.tipo,
            'fecha_inicio': evento.fecha_inicio,
            'fecha_fin': evento.fecha_fin,
            'ubicacion': evento.ubicacion,
            'equipo': {
                'id': evento.equipo.id,
                'description': evento.equipo.description,
                'category': evento.equipo.category,
                'level': evento.equipo.level,
                'division': evento.equipo.division
            }
        }
        for evento in eventos
    ]

    return Response(eventos_data)

@swagger_auto_schema(
    method='get',
    operation_description="Obtener todos los eventos",
    tags=["Eventos"],
    security=[{'Bearer': []}],
    responses={
        200: openapi.Response(
            description="Eventos listados con éxito"
        ),
        400: openapi.Response(description="Ocurrió un error inesperado"),
    },
)
@api_view(['GET'])
@permission_classes([IsAuthenticated])
def getEvents(request, idteams = None):
    try:
        # idteams puede venir opcionalmente (query params o body)


        # 1) Intentar obtenerlo desde query params: ?idteams=1,2,3  (o repetido ?idteams=1&idteams=2)
        if hasattr(request, "query_params"):
            qp = request.query_params
            if "idteams" in qp:
                raw = qp.getlist("idteams")
                if len(raw) == 1 and isinstance(raw[0], str) and "," in raw[0]:
                    raw = [x.strip() for x in raw[0].split(",") if x.strip()]
                idteams = raw

        # 2) Si no vino por query params, intentar desde el body (JSON): {"idteams":[1,2,3]} o {"idteams":"1,2,3"}
        if (not idteams) and hasattr(request, "data"):
            body_value = request.data.get("idteams", None)
            if body_value is not None:
                if isinstance(body_value, str):
                    idteams = [x.strip() for x in body_value.split(",") if x.strip()]
                elif isinstance(body_value, (list, tuple)):
                    idteams = list(body_value)
                else:
                    idteams = [body_value]

        # Normalizar a lista de ints (y filtrar valores inválidos)
        team_ids = None
        if idteams:
            team_ids = []
            for x in idteams:
                try:
                    team_ids.append(int(x))
                except (TypeError, ValueError):
                    continue

        # Query base
        qs = Evento.objects.select_related('equipo').all()

        # Si vino idteams (y quedó al menos un id válido), filtrar
        if team_ids:
            qs = qs.filter(equipo_id__in=team_ids)

        data = []
        for e in qs:
            equipo = e.equipo
            print(e)
            # convierte el evento + algunos campos del equipo a diccionario
            data.append({
                'id': e.id,
                'title': e.titulo,
                'description': e.descripcion,
                'tipo': e.tipo,
                'start': e.fecha_inicio.isoformat(),
                'end': e.fecha_fin.isoformat(),
                'ubicacion': e.ubicacion,
                'creado_en': e.creado_en.isoformat(),
                'actualizado_en': e.actualizado_en.isoformat(),
                'equipo': {
                    'id': equipo.id,
                    # Ajusta los campos según el modelo Equipos (p. ej. nombre, descripcion)
                    'description': getattr(equipo, 'description', None),
                    'color': getattr(equipo, 'color', None),
                    #'descripcion': getattr(equipo, 'descripcion', None),
                }
            })
        return Response({"message": "Eventos listados con éxito", "data": data}, status=status.HTTP_200_OK)
    except json.JSONDecodeError:
        return Response({"message": "Ocurrió un error inesperado"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

@swagger_auto_schema(
    method='get',
    operation_description="Obtener los eventos de un equipo",
    tags=["Eventos"],
    security=[{'Bearer': []}],
    responses={
        200: openapi.Response(
            description="Eventos encontrados"
        ),
        400: openapi.Response(description="Ocurrió un error"),
    },
)
@api_view(['GET'])
def get_team_events(request, team_id):
    """Obtener eventos de un equipo específico"""
    try:
        equipo = Equipos.objects.get(id=team_id)
    except Equipos.DoesNotExist:
        return Response(
            {'error': 'Equipo no encontrado'},
            status=status.HTTP_404_NOT_FOUND
        )

    # Obtener parámetros opcionales de filtro
    tipo = request.query_params.get('tipo', None)
    fecha_desde = request.query_params.get('fecha_desde', None)
    fecha_hasta = request.query_params.get('fecha_hasta', None)

    # Query base
    eventos = Evento.objects.filter(equipo_id=team_id)

    # Aplicar filtros opcionales
    if tipo:
        eventos = eventos.filter(tipo=tipo)

    if fecha_desde:
        eventos = eventos.filter(fecha_inicio__gte=fecha_desde)

    if fecha_hasta:
        eventos = eventos.filter(fecha_inicio__lte=fecha_hasta)

    # Ordenar y optimizar query
    eventos = eventos.select_related('equipo').order_by('fecha_inicio')

    # Serializar datos
    eventos_data = [
        {
            'id': evento.id,
            'titulo': evento.titulo,
            'descripcion': evento.descripcion,
            'tipo': evento.tipo,
            'fecha_inicio': evento.fecha_inicio,
            'fecha_fin': evento.fecha_fin,
            'ubicacion': evento.ubicacion,
            'es_recurrente': evento.es_recurrente,
            'frecuencia': evento.frecuencia,
        }
        for evento in eventos
    ]

    return Response({
        'equipo': {
            'id': equipo.id,
            'description': equipo.description,
            'category': equipo.category,
            'level': equipo.level,
            'division': equipo.division
        },
        'total_eventos': len(eventos_data),
        'eventos': eventos_data
    })


@swagger_auto_schema(
    method='post',
    operation_description="Crear un evento",
    tags=["Eventos"],
    security=[{'Bearer': []}],
    responses={
        201: openapi.Response(description="Evento creado con éxito"),
        400: openapi.Response(description="Solicitud inválida"),
    },
)
@api_view(['POST'])
@permission_classes([IsClubAdmin])
def create_event(request):
    """Crear un nuevo evento"""
    data = request.data

    evento = Evento.objects.create(
        equipo_id=data['equipo_id'],
        titulo=data['titulo'],
        descripcion=data.get('descripcion', ''),
        tipo=data.get('tipo', 'ENTRENAMIENTO'),
        fecha_inicio=data['fecha_inicio'],
        fecha_fin=data['fecha_fin'],
        ubicacion=data.get('ubicacion', '')
    )

    # Crear asistencias pendientes para todos los miembros del equipo
    #team_members = UsersTeams.objects.filter(idTeam=evento.equipo)

    return Response({'message': 'Evento creado exitosamente'}, status=status.HTTP_200_OK)

@swagger_auto_schema(
    method='delete',
    operation_description="Eliminar un evento por ID",
    tags=["Eventos"],
    security=[{'Bearer': []}],
    responses={
        200: openapi.Response(description="Evento eliminado exitosamente"),
        404: openapi.Response(description="Evento no encontrado"),
    },
)
@api_view(['DELETE'])
@permission_classes([IsClubAdmin])
def delete(request, id):
    try:
        evento = Evento.objects.get(id=id)
        evento.delete()
        return Response({"message": "Evento eliminado exitosamente"}, status=200)
    except Evento.DoesNotExist:
        return Response({"error": "Evento no encontrado"}, status=404)