<?php

namespace App\Domains\Bundle\Models;

use App\Domains\Tenant\Models\Tenant;
use Illuminate\Database\Eloquent\Attributes\Fillable;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Casts\Attribute;

use App\Domains\Shared\Contracts\Stockable;

#[Fillable([
    'tenant_codigo',
    'nombre',
    'descripcion',
    'precio',
])]
class Bundle extends Model implements Stockable
{
    use HasFactory;

    protected $table = 'bundles';

    protected $appends = ['stock_tecnico'];

    protected function casts(): array
    {
        return [
            'precio' => 'decimal:2',
        ];
    }

    /**
     * @return BelongsTo<Tenant, $this>
     */
    public function tenant(): BelongsTo
    {
        return $this->belongsTo(Tenant::class, 'tenant_codigo', 'codigo');
    }

    /**
     * @return HasMany<BundleItem, $this>
     */
    public function items(): HasMany
    {
        return $this->hasMany(BundleItem::class, 'bundle_id');
    }

    public function incrementRealStock(int $amount): void
    {
        if ($amount < 0) {
            throw new \InvalidArgumentException('El monto a incrementar debe ser positivo.');
        }

        foreach ($this->items as $item) {
            $item->variant->incrementRealStock($amount * $item->cantidad);
        }
    }

    public function decrementRealStock(int $amount): void
    {
        if ($amount < 0) {
            throw new \InvalidArgumentException('El monto a decrementar debe ser positivo.');
        }

        foreach ($this->items as $item) {
            $item->variant->decrementRealStock($amount * $item->cantidad);
        }
    }

    public function incrementReservedStock(int $amount): void
    {
        if ($amount < 0) {
            throw new \InvalidArgumentException('El monto a incrementar debe ser positivo.');
        }

        foreach ($this->items as $item) {
            $item->variant->incrementReservedStock($amount * $item->cantidad);
        }
    }

    public function decrementReservedStock(int $amount): void
    {
        if ($amount < 0) {
            throw new \InvalidArgumentException('El monto a decrementar debe ser positivo.');
        }

        foreach ($this->items as $item) {
            $item->variant->decrementReservedStock($amount * $item->cantidad);
        }
    }

    public function confirmReservedStock(int $amount): void
    {
        if ($amount < 0) {
            throw new \InvalidArgumentException('El monto a confirmar debe ser positivo.');
        }

        foreach ($this->items as $item) {
            $item->variant->confirmReservedStock($amount * $item->cantidad);
        }
    }

    public function validateStock(): void
    {
        if ($this->stock_tecnico <= 0) {
            throw new \InvalidArgumentException('El bundle no tiene stock técnico disponible.');
        }
    }

    protected function stockTecnico(): Attribute
    {
        return Attribute::get(function () {
            if ($this->items->isEmpty()) {
                return 0;
            }
            
            $minStock = PHP_INT_MAX;
            foreach ($this->items as $item) {
                // Ensure variant is loaded
                if ($item->variant) {
                    $itemStock = floor($item->variant->stock_tecnico / $item->cantidad);
                    if ($itemStock < $minStock) {
                        $minStock = $itemStock;
                    }
                }
            }
            
            return $minStock === PHP_INT_MAX ? 0 : (int) $minStock;
        });
    }
}