GPU Management

class RegistroGPU(models.Model):
    """
    pro_registro_gpu (Espejo Administrativo y Evidencias).
    Solo se crea para C-2 y C-3.
    """
    id_produccion = models.OneToOneField(Produccion, on_delete=models.CASCADE, related_name='gpu')
    id_estatus = models.ForeignKey(Estatus, on_delete=models.CASCADE, limit_choices_to={'nivel_afectacion': 6}, verbose_name="Estatus GPU")
    archivo = models.URLField(max_length=500, blank=True, null=True, verbose_name="Link Evidencia Fotográfica")
    nota_bloqueo = models.TextField(blank=True, verbose_name="Observaciones", null=True)
    id_estimacion_detalle = models.ForeignKey('EstimacionDetalle', on_delete=models.SET_NULL, null=True, blank=True)
    fecha_actualizacion = models.DateTimeField(auto_now=True)

    class Meta:
        db_table = 'registro_generadores_pu'

try:
    estatus_pendiente = Estatus.objects.get(id=20)  # Pendiente status
except Estatus.DoesNotExist:
    estatus_pendiente = None

if estatus_pendiente:
    anexos_validos_gpu = ['C-2', 'C-3', 'C2EXT', 'C3EXT']

    # Find all production records that need GPU tracking
    producciones_validas_gpu = Produccion.objects.filter(
        id_reporte_mensual=reporte_mensual,
        volumen_produccion__gt=0,
        id_partida_anexo__anexo__in=anexos_validos_gpu
    ).values_list('id', flat=True)

    # Check which already have GPU registries
    gpus_existentes = RegistroGPU.objects.filter(
        id_produccion__in=producciones_validas_gpu
    ).values_list('id_produccion', flat=True)

    # Create missing GPU registries
    ids_faltantes = set(producciones_validas_gpu) - set(gpus_existentes)

    gpus_nuevos = []
    for pid in ids_faltantes:
        gpus_nuevos.append(RegistroGPU(
            id_produccion_id=pid,
            id_estatus=estatus_pendiente,
        ))
    
    if gpus_nuevos:
        RegistroGPU.objects.bulk_create(gpus_nuevos)

    # Clean up GPU registries for production with zero volume
    RegistroGPU.objects.filter(
        id_produccion__id_reporte_mensual=reporte_mensual,
        id_produccion__volumen_produccion=0
    ).delete()

@login_required
def obtener_grid_gpus(request):
    """
    Retorna la matriz de datos para el DataTable de GPUs.
    """
    try:
        id_ot = request.GET.get('id_ot')
        mes = request.GET.get('mes')
        anio = request.GET.get('anio')
        
        if not id_ot or not mes or not anio:
            return JsonResponse({'data': []})

        anexos_validos_gpu = ['C-2', 'C-3', 'C2EXT', 'C3EXT']

        reporte = ReporteMensual.objects.filter(id_ot_id=id_ot, mes=mes, anio=anio).first()
        if not reporte:
            return JsonResponse({'data': []})

        # Load all production requiring GPU evidence
        producciones = Produccion.objects.filter(
            id_reporte_mensual=reporte,
            volumen_produccion__gt=0.00,
            id_partida_anexo__anexo__in=anexos_validos_gpu,
            id_partida_anexo__importacion_anexo__es_activo=True
        ).select_related('id_partida_anexo', 'id_partida_anexo__unidad_medida', 'gpu', 'gpu__id_estatus')

        data_map = {}

        for prod in producciones:
            partida = prod.id_partida_anexo
            pid = partida.id
            
            if pid not in data_map:
                unidad_clave = str(partida.unidad_medida.clave) if hasattr(partida.unidad_medida, 'clave') else str(partida.unidad_medida)
                
                data_map[pid] = {
                    'id_partida_anexo': pid,
                    'codigo': partida.id_partida,
                    'descripcion': partida.descripcion_concepto,
                    'unidad': unidad_clave,
                    'anexo': str(partida.anexo),
                    **{f'dia_{d}': None for d in range(1, 32)}
                }

            dia = prod.fecha_produccion.day
            
            # Build day cell data
            estado_gpu = {
                'id_produccion': prod.id,
                'volumen': prod.volumen_produccion,
                'estatus_id': 19,  # Default: Pendiente
                'estatus_texto': 'PENDIENTE',
                'archivos_count': 0,
                'archivo': ''
            }

            # Check if GPU registry exists
            if hasattr(prod, 'gpu'):
                gpu = prod.gpu
                estado_gpu['estatus_id'] = gpu.id_estatus.id
                estado_gpu['estatus_texto'] = str(gpu.id_estatus.descripcion if hasattr(gpu.id_estatus, 'descripcion') else gpu.id_estatus)
                
                evidencias = gpu.archivo
                if evidencias:
                    estado_gpu['archivos_count'] = 1
                    estado_gpu['archivo'] = evidencias
                
                estado_gpu['id_gpu'] = gpu.id

            data_map[pid][f'dia_{dia}'] = estado_gpu

        return JsonResponse({'data': list(data_map.values())})

    except Exception as e:
        print(f"Error en obtener_grid_gpus: {str(e)}")
        return JsonResponse({'error': str(e)}, status=500)

@login_required
@require_http_methods(["POST"])
def guardar_estatus_gpu(request):
    """
    Actualiza el estatus y el archivo de evidencia de un generador.
    """
    try:
        data = json.loads(request.body)
        id_produccion = data.get('id_produccion')
        nuevo_estatus_id = data.get('estatus_id')
        archivo_url = data.get('archivo')

        if not id_produccion:
            return JsonResponse({'exito': False, 'mensaje': 'ID de producción no proporcionado'})

        produccion = get_object_or_404(Produccion, pk=id_produccion)

        # Update or create GPU registry
        gpu, created = RegistroGPU.objects.update_or_create(
            id_produccion=produccion,
            defaults={
                'id_estatus_id': nuevo_estatus_id,
                'archivo': archivo_url
            }
        )

        accion = "creado" if created else "actualizado"
        return JsonResponse({'exito': True, 'mensaje': f'Registro GPU {accion} correctamente'})

    except Exception as e:
        print(f"Error en guardar_estatus_gpu: {str(e)}")
        return JsonResponse({'exito': False, 'mensaje': f'Error interno: {str(e)}'})

class EstimacionDetalle(models.Model):
    id_estimacion_header = models.ForeignKey(EstimacionHeader, on_delete=models.CASCADE, related_name='detalles')
    id_produccion = models.ForeignKey(Produccion, on_delete=models.CASCADE)
    volumen_actual = models.DecimalField(max_digits=15, decimal_places=2)
    volumen_estimado = models.DecimalField(max_digits=15, decimal_places=2,default=0)
    id_estatus_cobro = models.ForeignKey(Estatus, on_delete=models.CASCADE, limit_choices_to={'nivel_afectacion': 3})
    comentario_ajuste = models.TextField(blank=True)
    
    class Meta:
        db_table = 'estimacion_detalle'

    def __str__(self):
        return f"Detalle Estimación {self.id} - Prod {self.id_produccion.id}"