from drf_yasg.utils import swagger_auto_schema
from rest_framework.decorators import action
from rest_framework.response import Response
from drf_yasg import openapi
from rest_framework import viewsets, status
from Models.workflow import Workflow
from Models.oportunidad_de_venta_model import ColumnWorkflow

from Models.oportunidad_de_venta_model import OportunidadDeVenta
from oportunidad_de_venta.serializers import OportunidadDeVentaSerializer

class WorkflowViewSet(viewsets.ViewSet):
    """
    ViewSet para manejar operaciones de workflows
    """

    @swagger_auto_schema(
        operation_description="Obtener todas las oportunidades de venta de un workflow completas",
        responses={200: OportunidadDeVentaSerializer(many=True)},
        tags=['tablero']
    )
    @action(detail=True, methods=['get'], url_path='opportunities')
    def opportunities(self, request, pk=None):
        """
        Endpoint que retorna todas las oportunidades asociadas a las columnas de este workflow.
        Evita hacer N peticiones por columna.
        """
        try:
            # 1. Obtener columnas del workflow
            columnas = ColumnWorkflow.objects.filter(
                workflow_id=pk,
                deleted_at__isnull=True
            ).values_list('id', flat=True)

            if not columnas:
                return Response({
                    "success": True, 
                    "data": []
                }, status=status.HTTP_200_OK)

            # 2. Traer todas las oportunidades de esas columnas
            oportunidades = OportunidadDeVenta.objects.filter(
                column_workflow_id__in=columnas,
                deleted_at__isnull=True
            ).select_related(
                'empresa', 'usuario_responsable', 'estado_oportunidad', 'column_workflow'
            ).order_by('-fecha_creacion')

            serializer = OportunidadDeVentaSerializer(oportunidades, many=True)

            return Response({
                "success": True,
                "data": serializer.data
            }, status=status.HTTP_200_OK)

        except Exception as e:
            return Response({
                "success": False,
                "message": f"Error al obtener oportunidades del workflow: {str(e)}"
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

    @swagger_auto_schema(
        operation_description="Obtener listado de workflows disponibles con sus columnas ordenadas",
        responses={
            200: openapi.Response(
                description="Lista de workflows con columnas obtenida exitosamente",
                examples={
                    "application/json": {
                        "success": True,
                        "data": [
                            {
                                "id": 1,
                                "nombre": "Workflow de Ventas",
                                "descripcion": "Proceso automatizado de ventas",
                                "activo": True,
                                "fecha_creacion": "2025-10-14T10:30:00Z",
                                "columnas": [
                                    {
                                        "id": 1,
                                        "nombre": "Prospecto",
                                        "orden": 1
                                    },
                                    {
                                        "id": 2,
                                        "nombre": "Contactado",
                                        "orden": 2
                                    }
                                ]
                            }
                        ]
                    }
                }
            ),
            500: openapi.Response(description="Error interno del servidor")
        },
        tags=['tablero']
    )
    @action(detail=False, methods=['get'], url_path='listado')
    def obtener_workflows(self, request):
        """
        Endpoint para obtener el listado completo de workflows con sus columnas ordenadas
        """
        try:
            workflows = Workflow.objects.filter(deleted_at__isnull=True)
            
            # Obtener todos los IDs de los workflows
            workflow_ids = [w.id for w in workflows]

            # Traer todas las columnas de un solo golpe (Query optimizada)
            all_columns = ColumnWorkflow.objects.filter(
                workflow_id__in=workflow_ids,
                deleted_at__isnull=True
            ).order_by('orden')

            # Agrupar columnas por workflow_id en un diccionario
            columns_by_workflow = {}
            for col in all_columns:
                if col.workflow_id not in columns_by_workflow:
                    columns_by_workflow[col.workflow_id] = []
                columns_by_workflow[col.workflow_id].append({
                    "id": col.id,
                    "nombre": col.nombre,
                    "orden": col.orden,
                    "descripcion": getattr(col, 'descripcion', ''),
                    "color": getattr(col, 'color', ''),
                })

            workflows_data = []
            for workflow_obj in workflows:
                # Obtener columnas ya procesadas desde el diccionario
                columnas_data = columns_by_workflow.get(workflow_obj.id, [])
                
                workflows_data.append({
                    "id": workflow_obj.id,
                    "nombre": workflow_obj.nombre,
                    "descripcion": getattr(workflow_obj, 'descripcion', ''),
                    "activo": getattr(workflow_obj, 'activo', True),
                    "fecha_creacion": getattr(workflow_obj, 'fecha_creacion', workflow_obj.created_at),
                    "fecha_actualizacion": getattr(workflow_obj, 'fecha_actualizacion', workflow_obj.updated_at),
                    "columnas": columnas_data,
                    "total_columnas": len(columnas_data)
                })
            
            return Response({
                "success": True,
                "data": workflows_data,
                "total": len(workflows_data)
            }, status=status.HTTP_200_OK)
            
        except Exception as e:
            return Response({
                "success": False,
                "message": f"Error al obtener workflows: {str(e)}"
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)