from django.shortcuts import render
from rest_framework import viewsets, status
from rest_framework.decorators import action
from rest_framework.response import Response
from drf_yasg.utils import swagger_auto_schema
from drf_yasg import openapi
from Models.origen import  Origen
from django.utils import timezone
from origen.serializers import OrigenSerializer, CreateOrigenSerializer, EditOrigenSerializer, DeleteOrigenSerializer

class OrigenViewSet(viewsets.ViewSet):
    @swagger_auto_schema(
        operation_description="Lista todos los orígenes activos",
        responses={
            200: OrigenSerializer(many=True)
        }
    )
    @action(detail=False, methods=['get'], url_path='list_origin')
    def listar_origenes(self, request):
        origenes = Origen.objects.filter(deleted_at__isnull=True)
        serializer = OrigenSerializer(origenes, many=True)
        return Response(serializer.data)
    
    @swagger_auto_schema(
        operation_description="Crea un nuevo origen con id_usuario y nombre",
        request_body=CreateOrigenSerializer,
        responses={
            201: openapi.Response(
                description="Origen creado correctamente",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'mensaje': openapi.Schema(type=openapi.TYPE_STRING, description='Mensaje de éxito'),
                        'id': openapi.Schema(type=openapi.TYPE_INTEGER, description='ID del origen creado'),
                        'datos': openapi.Schema(type=openapi.TYPE_OBJECT, description='Datos del origen creado')
                    }
                )
            ),
            400: openapi.Response(
                description="Error en los datos proporcionados",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'error': openapi.Schema(type=openapi.TYPE_STRING),
                        'detalles': openapi.Schema(type=openapi.TYPE_OBJECT)
                    }
                )
            )
        }
    )
    @action(detail=False, methods=['post'], url_path='create_origin')
    def crear_origen(self, request):
        serializer = CreateOrigenSerializer(data=request.data)
        
        if not serializer.is_valid():
            return Response({"error": "Datos inválidos", "detalles": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
        
        # Extraer el ID de usuario
        id_usuario = serializer.validated_data.pop('id_usuario')
        
        # Crear el origen con los campos adicionales
        origen = Origen.objects.create(
            nombre=serializer.validated_data['nombre'],
            created_by=id_usuario,
            created_at=timezone.now()
        )
        
        # Devolver la respuesta con los datos del origen creado
        return Response({
            "mensaje": "Origen creado correctamente",
            "id": origen.id,
            "datos": OrigenSerializer(origen).data
        }, status=status.HTTP_201_CREATED)

    @swagger_auto_schema(
        operation_description="Actualiza un origen existente mediante método POST. Solo es necesario incluir el ID y los campos que se desean modificar.",
        request_body=EditOrigenSerializer,
        responses={
            200: openapi.Response(
                description="Origen actualizado correctamente",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'mensaje': openapi.Schema(type=openapi.TYPE_STRING, description='Mensaje de éxito'),
                        'id': openapi.Schema(type=openapi.TYPE_INTEGER, description='ID del origen actualizado'),
                        'datos': openapi.Schema(type=openapi.TYPE_OBJECT, description='Datos actualizados del origen')
                    }
                )
            ),
            400: openapi.Response(
                description="Error en los datos proporcionados",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'error': openapi.Schema(type=openapi.TYPE_STRING),
                        'detalles': openapi.Schema(type=openapi.TYPE_OBJECT)
                    }
                )
            ),
            404: openapi.Response(
                description="Origen no encontrado",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'error': openapi.Schema(type=openapi.TYPE_STRING)
                    }
                )
            )
        }
    )
    @action(detail=False, methods=['post'], url_path='update_origin')
    def actualizar_origen(self, request):
        serializer = EditOrigenSerializer(data=request.data)
        
        if not serializer.is_valid():
            return Response({"error": "Datos inválidos", "detalles": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
            
        try:
            # Obtener el ID y eliminar del diccionario para que no intente modificarlo
            id_origen = serializer.validated_data.pop('id')
            
            # Buscar el origen existente
            origen = Origen.objects.get(id=id_origen, deleted_at__isnull=True)
            
            # Actualizar solo los campos proporcionados en la solicitud
            campos_actualizados = []
            for campo, valor in serializer.validated_data.items():
                old_value = getattr(origen, campo, None)
                if old_value != valor:
                    setattr(origen, campo, valor)
                    campos_actualizados.append(campo)
                
            # Obtener el usuario actual si está disponible
            usuario_id = request.user.id if request.user.is_authenticated else None
                
            # Actualizar la información de auditoría
            origen.updated_at = timezone.now()
            origen.updated_by = usuario_id if usuario_id else 1  # Valor predeterminado si no hay usuario autenticado
            campos_actualizados.extend(['updated_at', 'updated_by'])
            
            # Guardar los cambios en la base de datos
            origen.save(update_fields=campos_actualizados)
            
            return Response({
                "mensaje": "Origen actualizado correctamente",
                "id": id_origen,
                "campos_actualizados": campos_actualizados,
                "datos": OrigenSerializer(origen).data
            }, status=status.HTTP_200_OK)
            
        except Origen.DoesNotExist:
            return Response({"error": "El origen no existe o ya fue eliminado"}, status=status.HTTP_404_NOT_FOUND)
    
    @swagger_auto_schema(
        operation_description="Elimina lógicamente un origen por su ID",
        request_body=DeleteOrigenSerializer,
        responses={
            200: openapi.Response(
                description="Origen eliminado correctamente",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'mensaje': openapi.Schema(type=openapi.TYPE_STRING),
                        'id': openapi.Schema(type=openapi.TYPE_INTEGER)
                    }
                )
            ),
            400: openapi.Response(
                description="Datos inválidos",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'error': openapi.Schema(type=openapi.TYPE_STRING),
                        'detalles': openapi.Schema(type=openapi.TYPE_OBJECT)
                    }
                )
            ),
            404: openapi.Response(
                description="Origen no encontrado",
                schema=openapi.Schema(
                    type=openapi.TYPE_OBJECT,
                    properties={
                        'error': openapi.Schema(type=openapi.TYPE_STRING)
                    }
                )
            )
        }
    )
    @action(detail=False, methods=['post'], url_path='delete_origin')
    def eliminar_origen(self, request):
        serializer = DeleteOrigenSerializer(data=request.data)
        
        if not serializer.is_valid():
            return Response({"error": "Datos inválidos", "detalles": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
            
        try:
            id_origen = serializer.validated_data['id']
            origen = Origen.objects.get(id=id_origen, deleted_at__isnull=True)
            
            # Obtener el usuario actual si está disponible
            usuario_id = request.user.id if request.user.is_authenticated else None
            
            # Realizar el soft delete
            origen.deleted_at = timezone.now()
            origen.deleted_by = usuario_id if usuario_id else 1  # Valor predeterminado si no hay usuario autenticado
            origen.save(update_fields=['deleted_at', 'deleted_by'])
            
            return Response({"mensaje": "Origen eliminado correctamente", "id": id_origen}, status=status.HTTP_200_OK)
        except Origen.DoesNotExist:
            return Response({"error": "El origen no existe o ya fue eliminado"}, status=status.HTTP_404_NOT_FOUND)
