<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Tintoreria extends Model
{
    protected $fillable = [
        'proveedor_id',
        'orden_produccion_id',
        'tipo_proceso',
        'fecha_envio',
        'cantidad_enviada',
        'valor_por_prenda',
        'fecha_recepcion',
        'cantidad_recibida',
        'perdidas',
        'observaciones',
        'descuentos_cobros',
        'total_pagar',
    ];

    /* 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 ($tintoreria) {
            // Fecha de envío por defecto
            if (! $tintoreria->fecha_envio) {
                $tintoreria->fecha_envio = now();
            }

            // Validación: cantidad_enviada no puede exceder la suma de confecciones recibidas de la OP
            if ($tintoreria->cantidad_enviada !== null && $tintoreria->orden_produccion_id) {
                $sum = \App\Models\Confeccion::where('orden_produccion_id', $tintoreria->orden_produccion_id)->sum('cantidad_recibida');
                if ($sum && $tintoreria->cantidad_enviada > $sum) {
                    throw \Illuminate\Validation\ValidationException::withMessages([
                        'cantidad_enviada' => 'La cantidad enviada no puede exceder la cantidad recibida en Confección (' . $sum . ').',
                    ]);
                }
            }

            if ($tintoreria->cantidad_recibida !== null) {
                $tintoreria->perdidas =
                    $tintoreria->cantidad_enviada - $tintoreria->cantidad_recibida;
                if ($tintoreria->perdidas < 0) $tintoreria->perdidas = 0;
            }

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

            // Aplicar descuentos de cobros si existen
            $descuentos = (float) ($tintoreria->getCobrosTotalAttribute() ?? 0);

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

            // Mantener campo redundante 'descuentos_cobros' sincronizado
            $tintoreria->descuentos_cobros = $descuentos;
        });

        // Avanzar OP al cerrar el paso o cuando se complete
        static::saved(function ($tintoreria) {
            if ($tintoreria->fecha_recepcion && $tintoreria->cantidad_recibida !== null) {
                $tintoreria->ordenProduccion?->avanzarEstado();
            }
        });
    }

    /**
     * Registrar un reproceso: prendas que llegaron mal y salen a reparación
     * Permiten re-recepción cuando regresen arregladas (igual que arreglos en confecciones)
     */
    public function registerReproceso(int $cantidad, ?string $notas = null, ?int $userId = null)
    {
        if ($cantidad <= 0) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => 'La cantidad debe ser mayor que 0.']);
        }

        // Validar que no exceda las recepciones efectivas (solo puedes marcar como reproceso lo que YA recibiste)
        $recepcionesEfectivas = (int) $this->recepciones()->sum(\DB::raw('cantidad - COALESCE(prendas_defectuosas, 0)'));
        $reprocesosActuales = (int) $this->ajustes()->where('tipo', 'reproceso')->sum('cantidad');
        
        $disponibleParaReprocesos = $recepcionesEfectivas - $reprocesosActuales;

        if ($cantidad > $disponibleParaReprocesos) {
            throw \Illuminate\Validation\ValidationException::withMessages([
                'cantidad' => "No puedes registrar {$cantidad} prendas como reproceso.
                
                📊 Resumen:
                • Recepciones efectivas: {$recepcionesEfectivas}
                • Reprocesos ya registrados: {$reprocesosActuales}
                • Disponible para marcar como reproceso: {$disponibleParaReprocesos}
                
                ➡️ Solo puedes registrar máximo {$disponibleParaReprocesos} prendas como reproceso.
                
                💡 Los reprocesos deben ser de prendas YA recibidas que necesitan reparación."
            ]);
        }

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

        return $aj;
    }

    /**
     * Registrar un cobro: solo registra el cobro sin descontar inventario
     * Los cobros son prendas que NO llegaron - se cobran a la tintorería
     */
    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.']);
        }

        // Validar que no se exceda lo enviado
        $enviada = (int) ($this->cantidad_enviada ?? 0);
        if ($enviada <= 0) {
            throw \Illuminate\Validation\ValidationException::withMessages(['cantidad' => 'La tintorería no tiene cantidad_enviada registrada.']);
        }

        // Calcular lo que ya se ha contabilizado
        $recepcionesEfectivas = (int) $this->recepciones()->sum(\DB::raw('cantidad - COALESCE(prendas_defectuosas, 0)'));
        $reprocesos = (int) $this->ajustes()->where('tipo', 'reproceso')->sum('cantidad');
        $recibidoNeto = $recepcionesEfectivas - $reprocesos; // Los reprocesos permiten re-recepción
        
        $cobrosActuales = (int) $this->cobros()->sum('cantidad');
        
        $totalContabilizado = $recibidoNeto + $cobrosActuales;
        $disponible = $enviada - $totalContabilizado;

        if ($cantidad > $disponible) {
            throw \Illuminate\Validation\ValidationException::withMessages([
                'cantidad' => "No puedes registrar {$cantidad} prendas como cobro.
                
                📊 Resumen:
                • Enviadas: {$enviada}
                • Recepciones efectivas: {$recepcionesEfectivas}
                • Reprocesos (permiten re-recepción): {$reprocesos}
                • Recibido neto: {$recibidoNeto}
                • Cobros registrados: {$cobrosActuales}
                • Disponible para cobros: {$disponible}
                
                ➡️ Solo puedes registrar máximo {$disponible} prendas más como cobros."
            ]);
        }

        // 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;
    }

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

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

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

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

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

    // Total de pérdidas registradas en las recepciones
    public function getPerdidasTotalAttribute()
    {
        return (int) $this->recepciones()->sum('prendas_defectuosas');
    }

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

    // Cuantas faltan por recibir (considera cobros porque ya están contabilizados)
    public function getFaltantesAttribute()
    {
        $enviada = (int)($this->cantidad_enviada ?? 0);
        $recibidoNeto = $this->recibido_total;
        $cobros = (int) $this->cobros()->sum('cantidad');
        
        // Lo que puede recibir = enviadas - cobros - recibido_neto
        return max(0, $enviada - $cobros - $recibidoNeto);
    }

    // Estado de recepción (Parcial / Completado)
    public function getEstadoRecepcionAttribute()
    {
        $faltan = $this->faltantes ?? 0;

        if (($this->cantidad_enviada ?? 0) <= 0) {
            return 'Sin envío';
        }

        return $faltan > 0 ? 'Parcial' : 'Completado';
    }
}