from rest_framework import viewsets, permissions, filters
from rest_framework.response import Response
from rest_framework import status
from rest_framework.exceptions import ValidationError
from django.core.exceptions import ValidationError as DjangoValidationError
from clientes.models import Region, Comuna
from .models import Proyecto, ProyectoDireccion, UnidadDeMedida, HorarioActivo, SLA, Equipo
from .serializers import (
    ProyectoSerializer,
    ProyectoDireccionSerializer,
    UnidadDeMedidaSerializer,
    HorarioActivoSerializer,
    SLASerializer,
    EquipoSerializer,
    RegionDetalleSerializer
)
from django.utils.encoding import force_str

 # ajusta esto a tus modelos reales
class ProyectoViewSet(viewsets.ModelViewSet):
    queryset = Proyecto.objects.all().order_by('-fechaCreacion')
    serializer_class = ProyectoSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = [
        'nombre',
        'clienteMandante__razonSocial',
        'clienteMandante__rut',
        'clienteFinal__razonSocial',
        'clienteFinal__rut',
        'estado',
    ]

    def create(self, request, *args, **kwargs):
        try:
          
            serializer = self.get_serializer(data=request.data)

            if not serializer.is_valid():
                print("Errores de validaciOn:", serializer.errors)
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

            self.perform_create(serializer)
            return Response(serializer.data, status=status.HTTP_201_CREATED)

        except Exception as e:
           
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def update(self, request, *args, **kwargs):
        try:
           
            instance = self.get_object()
            serializer = self.get_serializer(instance, data=request.data, partial=False)

            if not serializer.is_valid():
                print("Errores de validación (PUT):", serializer.errors)
                return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

            self.perform_update(serializer)
            return Response(serializer.data)

        except Exception as e:
          
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
        
    #permission_classes = [permissions.IsAuthenticatedOrReadOnly]


class ProyectoDireccionViewSet(viewsets.ModelViewSet):
    queryset = ProyectoDireccion.objects.all()
    serializer_class = ProyectoDireccionSerializer
    pagination_class = None

    def get_queryset(self):
        queryset = super().get_queryset()
        proyecto_id = self.request.query_params.get('proyecto')

        if proyecto_id:
            queryset = queryset.filter(proyecto_id=proyecto_id)

        return queryset

    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
    
        # Mensaje de error detallado
        return Response({
            "message": "No se pudo crear la dirección del proyecto.",
            "errors": serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)
    
    def update(self, request, *args, **kwargs):
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
    
        if serializer.is_valid():
            self.perform_update(serializer)
            return Response(serializer.data)
    
        return Response({
            "message": "No se pudo actualizar la dirección del proyecto.",
            "errors": serializer.errors
        }, status=status.HTTP_400_BAD_REQUEST)


class UnidadDeMedidaViewSet(viewsets.ModelViewSet):
    queryset = UnidadDeMedida.objects.all()
    serializer_class = UnidadDeMedidaSerializer
    pagination_class = None
    #permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def get_queryset(self):
        queryset = super().get_queryset()
        proyecto_id = self.request.query_params.get('proyecto')
        if proyecto_id:
            queryset = queryset.filter(proyecto__id=proyecto_id)
        return queryset

    def create(self, request, *args, **kwargs):
        # Asegura que la unidad se asocie al proyecto indicado
        proyecto_id = request.query_params.get('proyecto') or request.data.get('proyecto')
        data = request.data.copy()
        if proyecto_id:
            data['proyecto'] = proyecto_id

        serializer = self.get_serializer(data=data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        # Convierte dias_habiles a boolean si viene como string
        response_data = serializer.data
        return Response(response_data, status=status.HTTP_201_CREATED, headers=headers)

    def update(self, request, *args, **kwargs):
        # Permite actualizar la unidad, protegiendo el campo proyecto
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        data = request.data.copy()
        # Forzar que el proyecto no cambie
        data['proyecto'] = instance.proyecto.id if hasattr(instance.proyecto, 'id') else instance.proyecto

        serializer = self.get_serializer(instance, data=data, partial=partial)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)
        response_data = serializer.data
        return Response(response_data)

from rest_framework.exceptions import ValidationError
from rest_framework.response import Response
from rest_framework import status
from rest_framework import viewsets

class HorarioActivoViewSet(viewsets.ModelViewSet):
    queryset = HorarioActivo.objects.all()
    serializer_class = HorarioActivoSerializer
    pagination_class = None

    def get_queryset(self):
        queryset = super().get_queryset()
        proyecto_id = self.request.query_params.get('proyecto')

      
        if proyecto_id and proyecto_id != 'undefined':
            try:
                proyecto_id_int = int(proyecto_id)
                queryset = queryset.filter(proyecto__id=proyecto_id_int)
              
            except (ValueError, TypeError) as e:
               
                raise ValidationError({'proyecto': 'Debe ser un número entero válido'})

        return queryset

    def create(self, request, *args, **kwargs):
      
        proyecto_id = request.query_params.get('proyecto') or request.data.get('proyecto')
       
        if proyecto_id == 'undefined':
            proyecto_id = None

        if not proyecto_id:
            print("Error: proyecto_id está vacío o no definido")
            return Response({'error': {'proyecto': 'Este campo es requerido'}}, status=status.HTTP_400_BAD_REQUEST)

        try:
            proyecto_id_int = int(proyecto_id)
           
        except (ValueError, TypeError) as e:
           
            return Response({'error': {'proyecto': 'Debe ser un número entero válido'}}, status=status.HTTP_400_BAD_REQUEST)

        proyecto_obj = Proyecto.objects.filter(id=proyecto_id_int).first()
       
        if not proyecto_obj:
            return Response({'error': {'proyecto': 'Proyecto no encontrado'}}, status=status.HTTP_400_BAD_REQUEST)

        data = request.data.copy()
        data['proyecto'] = proyecto_id_int
   

        dia = data.get("dia")
        conflicto = HorarioActivo.objects.filter(proyecto=proyecto_id_int, dia=dia)


        serializer = self.get_serializer(data=data)
        try:
            serializer.is_valid(raise_exception=True)
          
        except ValidationError as ve:
           
            return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
        except Exception as e:
          
            return Response({'error': 'Error inesperado al validar los datos.'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
       
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def update(self, request, *args, **kwargs):

        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        data = request.data.copy()

        if hasattr(instance.proyecto, 'id'):
            data['proyecto'] = instance.proyecto.id
        else:
            data['proyecto'] = instance.proyecto

    

        #  Si activo es False, eliminar el registro
        if data.get('activo') is False or data.get('activo') == 'false':
            instance.delete()
 
            return Response({'mensaje': 'Registro eliminado porque activo es False.'}, status=status.HTTP_204_NO_CONTENT)

        # Validar y actualizar normalmente
        serializer = self.get_serializer(instance, data=data, partial=partial)

        try:
            serializer.is_valid(raise_exception=True)
        
        except ValidationError as ve:
       
            return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
        except Exception as e:
          
            return Response({'error': 'Error inesperado al actualizar el horario.'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

        self.perform_update(serializer)
     
        return Response(serializer.data)


from rest_framework import viewsets, status
from rest_framework.response import Response
from .models import SLA
from .serializers import SLASerializer

class SLAViewSet(viewsets.ModelViewSet):
    queryset = SLA.objects.all()
    serializer_class = SLASerializer
    pagination_class = None

    def get_queryset(self):
        queryset = super().get_queryset()
        proyecto_id = self.request.query_params.get('proyecto')
        zona_id = self.request.query_params.get('zona')

        if proyecto_id:
            queryset = queryset.filter(proyecto__id=proyecto_id)
        if zona_id:
            queryset = queryset.filter(zona__id=zona_id)

        return queryset

    def create(self, request, *args, **kwargs):
        try:
            data = request.data.get("slas", [])
            cleaned_data = []
    
            if not isinstance(data, list):
                data = [data]
    
            for item in data:
                cleaned_item = {
                    'proyecto': item.get('proyecto'),
                    'zona_id': item.get('zona_id'),
                    'categoria': item.get('categoria'),
                    'unidad_medida': item.get('unidad_medida'),
                    'cantidad': int(item.get('cantidad', 0)),
                    'multa': int(float(item.get('multa', 0)))
                }
                cleaned_data.append(cleaned_item)
    
            serializer = self.get_serializer(data=cleaned_data, many=True)
            serializer.is_valid(raise_exception=True)
            self.perform_create(serializer)
    
            return Response(data={"message": "SLAs creados", "slas": serializer.data}, status=status.HTTP_201_CREATED)
    
        except ValidationError as e:
            return Response({
                "message": "Error de validación",
                "errors": e.detail
            }, status=status.HTTP_400_BAD_REQUEST)
    
        except Exception as e:
            return Response({
                "message": "Error inesperado en el servidor",
                "error": str(e)
            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

    def update(self, request, *args, **kwargs):
        # Obtener el objeto SLA a actualizar
        instance = self.get_object()

        data = request.data.get('slas', [])[0]

        # Limpiar los datos como en el create
        cleaned_item = {
                'proyecto': data.get('proyecto', instance.proyecto.id),  # <-- ID, no objeto
                'zona_id': data.get('zona_id', instance.zona.codigo),    # <-- O zona.id si quieres
                'categoria': data.get('categoria', instance.categoria),
                'unidad_medida': data.get('unidad_medida', instance.unidad_medida.id),  # <-- ID
                'cantidad': int(float(data.get('cantidad', instance.cantidad or 0))),  # <-- esta es la corrección importante
                'multa': int(float(data.get('multa', instance.multa or 0)))
            }


        # Serializar y actualizar
        serializer = self.get_serializer(instance, data=cleaned_item)
        serializer.is_valid(raise_exception=True)
        self.perform_update(serializer)


        return Response(data={
            "message": "SLA actualizado",
            "sla": {
                "proyecto": serializer.instance.proyecto.id,
                "zona_id": serializer.instance.zona.codigo,  # O el campo correcto que uses como zona_id
                "categoria": serializer.instance.categoria,
                "unidad_medida": serializer.instance.unidad_medida.id,
                "cantidad": serializer.instance.cantidad,
                "multa": serializer.instance.multa,
            }
        }, status=status.HTTP_200_OK)



class EquipoViewSet(viewsets.ModelViewSet):
    queryset = Equipo.objects.all()
    serializer_class = EquipoSerializer
    #permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def get_queryset(self):
        queryset = super().get_queryset()
        proyecto_id = self.request.query_params.get('proyecto')
        ubicacion_id = self.request.query_params.get('ubicacion')
        
        if proyecto_id:
            queryset = queryset.filter(proyecto__id=proyecto_id)
        if ubicacion_id:
            queryset = queryset.filter(ubicacion__id=ubicacion_id)
        return queryset


class RegionViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = Region.objects.all()
    serializer_class = RegionDetalleSerializer
    pagination_class = None