"""
questions/views.py
===================
Vistas del banco de preguntas.
"""

import logging
from rest_framework import viewsets
from rest_framework.decorators import action
from rest_framework.permissions import IsAuthenticated

from questions.models import Pregunta
from questions.serializers import PreguntaSerializer, ImportarPreguntasSerializer
from shared.permissions import IsApprovedDocente, IsDocenteOwner
from shared.utils.responses import success_response, error_response
from shared.pagination import StandardPagination

logger = logging.getLogger('eduplay')


class PreguntaViewSet(viewsets.ModelViewSet):
    """
    ViewSet del banco de preguntas.
    
    Acciones estándar (CRUD) + acciones extra:
      GET  /preguntas/publicas/         → banco público de todos los docentes
      POST /preguntas/importar/         → importación masiva desde JSON
      POST /preguntas/{id}/valorar/     → votar una pregunta pública como útil
    """

    permission_classes = [IsApprovedDocente]
    serializer_class   = PreguntaSerializer
    pagination_class   = StandardPagination

    def get_queryset(self):
        """
        Filtra preguntas del docente autenticado.
        Filtros: ?tipo=multiple, ?asignatura_id=N, ?search=texto, ?es_publica=true
        """
        qs = Pregunta.objects.filter(
            docente=self.request.user
        ).select_related('asignatura')

        # Filtros
        tipo = self.request.query_params.get('tipo')
        if tipo:
            qs = qs.filter(tipo=tipo)

        asig_id = self.request.query_params.get('asignatura_id')
        if asig_id:
            qs = qs.filter(asignatura_id=asig_id)

        es_publica = self.request.query_params.get('es_publica')
        if es_publica is not None:
            qs = qs.filter(es_publica=es_publica.lower() == 'true')

        search = self.request.query_params.get('search', '').strip()
        if search:
            qs = qs.filter(enunciado__icontains=search)

        return qs

    def perform_create(self, serializer):
        """El docente siempre es el propietario."""
        serializer.save(docente=self.request.user)

    @action(detail=False, methods=['get'], permission_classes=[IsAuthenticated])
    def publicas(self, request):
        """
        GET /preguntas/publicas/
        Banco de preguntas públicas de todos los docentes.
        Se puede filtrar por asignatura código: ?asignatura_codigo=TI2031
        """
        qs = Pregunta.objects.filter(
            es_publica=True
        ).select_related('asignatura', 'docente').order_by('-valoraciones', '-created_at')

        asig_codigo = request.query_params.get('asignatura_codigo')
        if asig_codigo:
            qs = qs.filter(asignatura__codigo=asig_codigo.upper())

        tipo = request.query_params.get('tipo')
        if tipo:
            qs = qs.filter(tipo=tipo)

        paginator = self.pagination_class()
        page = paginator.paginate_queryset(qs, request)
        serializer = PreguntaSerializer(page, many=True)
        return paginator.get_paginated_response(serializer.data)

    @action(detail=False, methods=['post'])
    def importar(self, request):
        """
        POST /preguntas/importar/
        Importa preguntas masivamente desde un JSON validado.
        """
        serializer = ImportarPreguntasSerializer(
            data=request.data,
            context={'request': request}
        )
        if not serializer.is_valid():
            return error_response(
                message='El JSON de importación tiene errores',
                errors=serializer.errors,
                status_code=422
            )

        resultado = serializer.save(docente=request.user)
        logger.info(f'Importación de preguntas: {resultado.preguntas_ok} OK, {resultado.preguntas_err} errores. docente_id={request.user.id}')

        return success_response(
            data={
                'importadas': resultado.preguntas_ok,
                'errores':    resultado.preguntas_err,
                'log':        resultado.log_errores if resultado.preguntas_err else None,
            },
            message=f'{resultado.preguntas_ok} preguntas importadas correctamente.',
            status_code=201 if resultado.preguntas_ok > 0 else 400
        )

    @action(detail=True, methods=['post'], permission_classes=[IsApprovedDocente])
    def valorar(self, request, pk=None):
        """
        POST /preguntas/{id}/valorar/
        Vota una pregunta pública como útil (+1 valoración).
        Solo se puede valorar una vez por docente (simplificado — en prod usar tabla de votos).
        """
        pregunta = self.get_object()
        if not pregunta.es_publica:
            return error_response(message='Solo se pueden valorar preguntas públicas.', status_code=400)

        pregunta.valoraciones += 1
        pregunta.save(update_fields=['valoraciones'])
        return success_response(data={'valoraciones': pregunta.valoraciones})


class ImportacionViewSet(viewsets.ReadOnlyModelViewSet):
    """
    ViewSet de historial de importaciones (solo lectura).
    GET /importaciones/ → historial del docente
    """
    permission_classes = [IsApprovedDocente]
    pagination_class   = StandardPagination

    def get_queryset(self):
        from questions.models import ImportacionPreguntas
        return ImportacionPreguntas.objects.filter(
            docente=self.request.user
        ).order_by('-created_at')

    def get_serializer_class(self):
        from rest_framework import serializers
        # Serializer inline simple para el historial
        class ImportacionListSerializer(serializers.ModelSerializer):
            class Meta:
                from questions.models import ImportacionPreguntas
                model  = ImportacionPreguntas
                fields = ['id', 'asignatura', 'preguntas_ok', 'preguntas_err', 'created_at']
        return ImportacionListSerializer