pos_heidiver/app/Models/Confeccion.php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Confeccion extends Model
{
    protected $fillable = [
        'proveedor_id',
        'orden_produccion_id',
        'fecha_envio',
        'cantidad_enviada',
        'fecha_recepcion',
        'cantidad_recibida',
        'prendas_defectuosas',
        'valor_por_prenda',
        'total_pagar',
        'estado',
        'descuentos_cobros',
    ];

    public function cobros()
    {
        return $this->morphMany(\App\Models\Cobro::class, 'referencia');
    }

    public function ajustes()
    {
        return $this->morphMany(\App\Models\Ajuste::class, 'referencia');
    }

    /* Relaciones */
    public function proveedor()
    {
        return $this->belongsTo(Proveedor::class);
    }

    public function ordenProduccion()
    {
        return $this->belongsTo(OrdenProduccion::class);
    }

    /* Lógica de negocio */
    protected static function booted()
    {
        static::saving(function ($confeccion) {
            // Establecer fecha de envío por defecto si no se proporcionó
            if (! $confeccion->fecha_envio) {
                $confeccion->fecha_envio = now();
            }

            // Validación: cantidad_enviada no puede exceder la cantidad total de la OP
            if ($confeccion->cantidad_enviada !== null && $confeccion->orden_produccion_id) {
                $orden = \App\Models\OrdenProduccion::find($confeccion->orden_produccion_id);
                if ($orden && $confeccion->cantidad_enviada > $orden->cantidad_total) {
                    throw \Illuminate\Validation\ValidationException::withMessages([
                        'cantidad_enviada' => 'La cantidad enviada no puede exceder la cantidad total de la Orden de Producción (' . $orden->cantidad_total . ').',
                    ]);
                }
            }

            // Total a pagar: usa cantidad_recibida si existe, sino cantidad_enviada
            $cantidadBase = $confeccion->cantidad_recibida ?? $confeccion->cantidad_enviada ?? 0;
            $valorUnitario = $confeccion->valor_por_prenda ?? 0;

            // Aplicar descuentos de cobros si existen (se guarda también en descuentos_cobros para compatibilidad)
            $descuentos = (float) ($confeccion->getCobrosTotalAttribute() ?? 0);

            $confeccion->total_pagar = max(0, ($cantidadBase * $valorUnitario) - $descuentos);

            // Mantener campo redundante 'descuentos_cobros' sincronizado
            $confeccion->descuentos_cobros = $descuentos;

            // Estado automático
            if (! $confeccion->cantidad_recibida) {
                $confeccion->estado = 'pendiente';
            } elseif ($confeccion->cantidad_recibida < $confeccion->cantidad_enviada) {
                $confeccion->estado = 'parcial';
            } else {
                $confeccion->estado = 'completo';
            }
        });

        // Mantener avance de OP cuando la confección se completa
        static::saved(function ($confeccion) {
            if ($confeccion->estado === 'completo') {
                $confeccion->ordenProduccion?->avanzarEstado();
            }
        });
    }

    /* Recepciones polimórficas */
    public function recepciones()
    {
        return $this->morphMany(\App\Models\Recepcion::class, 'referencia');
    }

    // Total recibido calculado desde recepciones (fuente de la verdad)
    public function getRecibidoTotalAttribute()
    {
        $recepciones = (int) $this->recepciones()->sum(\DB::raw('cantidad - COALESCE(prendas_defectuosas, 0)'));
        $ajustes = (int) $this->ajustes()->where('tipo', 'arreglo')->sum('cantidad');

        return max(0, $recepciones - $ajustes);
    }

    // Cuantas faltan por recibir (usa la suma real de recepciones menos ajustes)
    public function getFaltantesAttribute()
    {
        return max(0, (int)($this->cantidad_enviada ?? 0) - $this->recibido_total);
    }

    // Total de cobros aplicados
    public function getCobrosTotalAttribute()
    {
        return (float) $this->cobros()->sum('valor');
    }

    /**
     * Registrar un arreglo como ajuste histórico y crear traslado de reparaciones
     */
    public function registerArreglo(int $cantidad, ?string $notas = null, ?int $userId = null)
    {
        if ($cantidad <= 0) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => 'La cantidad debe ser mayor que 0.']);
        }

        $recibido = $this->recibido_total;
        if ($cantidad > $recibido) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => 'La cantidad supera lo recibido.']);
        }

        // Crear ajuste
        $aj = \App\Models\Ajuste::create([
            'referencia_type' => self::class,
            'referencia_id' => $this->id,
            'user_id' => $userId,
            'tipo' => 'arreglo',
            'cantidad' => $cantidad,
            'notas' => $notas,
        ]);

        // Crear traslado de reparaciones para reflejar la salida
        \App\Models\TrasladoPrenda::create([
            'orden_produccion_id' => $this->orden_produccion_id,
            'referencia_type' => self::class,
            'referencia_id' => $this->id,
            'origen' => 'confeccion',
            'destino' => 'reparaciones',
            'cantidad_enviada' => $cantidad,
            'cantidad_recibida' => 0,
            'prendas_defectuosas' => 0,
            'reparaciones' => $cantidad,
            'fecha_envio' => now(),
            'fecha_recepcion' => now(),
            'estado' => 'recibido',
        ]);

        // Recalcular cantidad_recibida almacenada para compatibilidad con UI
        $this->cantidad_recibida = $this->recibido_total;
        $this->save();

        return $aj;
    }

    /**
     * Registrar un cobro: descontar inventario y crear registro de cobro
     */
    public function registerCobro(int $cantidad, float $valor, ?string $notas = null, ?int $userId = null)
    {
        if ($cantidad <= 0) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => 'La cantidad debe ser mayor que 0.']);
        }

        if (!$this->orden_produccion_id) {
            throw \Illuminate\Validation\ValidationException::withMessages(['orden_produccion_id' => 'La confección debe tener una orden de producción asociada.']);
        }

        // Buscar inventarios disponibles de esta orden de producción
        $inventarios = \App\Models\InventarioPrenda::where('orden_produccion_id', $this->orden_produccion_id)
            ->where('cantidad_disponible', '>', 0)
            ->orderBy('cantidad_disponible', 'desc')
            ->get();

        if ($inventarios->isEmpty()) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => 'No hay inventario disponible para la orden de producción #' . $this->orden_produccion_id . '. Asegúrate de que exista inventario con cantidad_disponible > 0.']);
        }

        $totalDisponible = $inventarios->sum('cantidad_disponible');
        
        if ($totalDisponible < $cantidad) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => "Solo hay {$totalDisponible} unidades disponibles en inventario. No se puede descontar {$cantidad}."]);
        }

        // Descontar del inventario de forma distribuida si es necesario
        $cantidadRestante = $cantidad;
        foreach ($inventarios as $inventario) {
            if ($cantidadRestante <= 0) {
                break;
            }

            $aDescontar = min($cantidadRestante, $inventario->cantidad_disponible);
            $inventario->cantidad_disponible -= $aDescontar;
            $inventario->save();

            // Si está asociado a producto, decrementar stock
            if ($inventario->producto_id) {
                $producto = \App\Models\Producto::find($inventario->producto_id);
                if ($producto) {
                    $producto->decrement('stock', $aDescontar);
                }
            }

            $cantidadRestante -= $aDescontar;
        }

        // Crear registro de cobro
        $c = \App\Models\Cobro::create([
            'referencia_type' => self::class,
            'referencia_id' => $this->id,
            'user_id' => $userId,
            'cantidad' => $cantidad,
            'valor' => $valor,
            'notas' => $notas,
        ]);

        // Mantener campo redundante sincronizado
        $this->descuentos_cobros = $this->getCobrosTotalAttribute();
        $this->save();

        return $c;
    }
}