Inventory Management

protected $fillable = [
    'company_id',
    'name',
    'internal_code',        // Uppercase alphanumeric identifier
    'quantity',             // Current stock level
    'low_stock_threshold',  // Alert threshold
    'is_sale_enabled',      // Can be sold directly
    'sale_price',           // Price when sold
];

public function createItem(Company $company, User $actor, array $payload): InventoryItem
{
    return DB::transaction(function () use ($company, $actor, $payload) {
        $item = InventoryItem::create([
            'company_id' => $company->id,
            'name' => $payload['name'],
            'internal_code' => trim(strtoupper($payload['internal_code'])),
            'quantity' => (int) $payload['quantity'],
            'low_stock_threshold' => (int) ($payload['low_stock_threshold'] ?? 5),
            'is_sale_enabled' => (bool) ($payload['is_sale_enabled'] ?? false),
            'sale_price' => !empty($payload['is_sale_enabled']) 
                ? ($payload['sale_price'] ?? null) 
                : null,
        ]);
        
        // Create initial movement record
        InventoryMovement::create([
            'inventory_item_id' => $item->id,
            'company_id' => $company->id,
            'user_id' => $actor->id,
            'movement_type' => 'addition',
            'quantity' => $item->quantity,
            'stock_before' => 0,
            'stock_after' => $item->quantity,
            'notes' => 'Alta inicial de producto',
        ]);
        
        $this->notifyLowStockIfNeeded($item);
        
        return $item;
    });
}

public function adjustStock(InventoryItem $item, User $actor, array $payload): InventoryItem
{
    return DB::transaction(function () use ($item, $actor, $payload) {
        $movementType = $payload['movement_type'];
        $delta = (int) $payload['quantity'];
        $before = $item->quantity;
        
        $after = $movementType === 'addition'
            ? $before + $delta
            : $before - $delta;
        
        if ($after < 0) {
            abort(422, 'Cannot remove more units than available stock.');
        }
        
        $item->update(['quantity' => $after]);
        
        InventoryMovement::create([
            'inventory_item_id' => $item->id,
            'company_id' => $item->company_id,
            'user_id' => $actor->id,
            'movement_type' => $movementType,
            'quantity' => $delta,
            'stock_before' => $before,
            'stock_after' => $after,
            'notes' => $payload['notes'] ?? null,
        ]);
        
        $this->notifyLowStockIfNeeded($item->fresh());
        
        return $item->fresh();
    });
}

if ($after < 0) {
    abort(422, 'No puedes retirar más unidades que el stock disponible.');
}

protected $fillable = [
    'inventory_item_id',
    'company_id',
    'user_id',           // Who made the change
    'movement_type',     // 'addition' or 'removal'
    'quantity',          // Amount changed
    'stock_before',      // Stock level before
    'stock_after',       // Stock level after
    'notes',             // Optional reason
];

$movements = InventoryMovement::query()
    ->with(['inventoryItem', 'user'])
    ->where('company_id', $user->company_id)
    ->latest()
    ->limit(12)
    ->get();

public function isLowStock(): bool
{
    return $this->quantity <= $this->low_stock_threshold;
}

private function notifyLowStockIfNeeded(InventoryItem $item): void
{
    if (!$item->isLowStock()) {
        return;
    }
    
    $usersToNotify = User::query()
        ->where('company_id', $item->company_id)
        ->where('is_active', true)
        ->where(function ($query) {
            $query->where('role', 'admin')
                ->orWhere(function ($q) {
                    $q->where('role', 'worker')
                        ->where('can_access_inventory', true);
                });
        })
        ->get();
    
    foreach ($usersToNotify as $user) {
        $alreadyExists = $user->notifications()
            ->where('type', LowStockInventoryNotification::class)
            ->where('data->item_id', $item->id)
            ->where('read_at', null)
            ->exists();
        
        if (!$alreadyExists) {
            $user->notify(new LowStockInventoryNotification($item));
        }
    }
}

public function lowStockItemsForCompany(int $companyId): Collection
{
    return InventoryItem::query()
        ->where('company_id', $companyId)
        ->whereColumn('quantity', '<=', 'low_stock_threshold')
        ->orderBy('quantity')
        ->get();
}

if (!$inventoryItem->is_sale_enabled) {
    abort(422, sprintf(
        'Product %s is not enabled for sale.',
        $inventoryItem->name
    ));
}

if ($quantity > $inventoryItem->quantity) {
    abort(422, sprintf(
        'Requested quantity for %s exceeds available stock (%d).',
        $inventoryItem->name,
        $inventoryItem->quantity
    ));
}

if ($document->document_type === 'invoice') {
    $this->consumeInventoryForInvoice($company, $items, $actor);
}

private function consumeInventoryForInvoice(Company $company, array $items, User $actor): void
{
    foreach ($items as $item) {
        if ($item['item_kind'] !== 'product' || empty($item['inventory_item_id'])) {
            continue;
        }
        
        $inventory = InventoryItem::query()
            ->where('company_id', $company->id)
            ->findOrFail((int) $item['inventory_item_id']);
        
        $qtyToDiscount = (int) ceil((float) $item['quantity']);
        
        app(InventoryService::class)->adjustStock($inventory, $actor, [
            'movement_type' => 'removal',
            'quantity' => $qtyToDiscount,
            'notes' => 'Descuento por facturación emitida',
        ]);
    }
}

public function company(): BelongsTo
{
    return $this->belongsTo(Company::class);
}

public function movements(): HasMany
{
    return $this->hasMany(InventoryMovement::class);
}

public function billingItems(): HasMany
{
    return $this->hasMany(BillingDocumentItem::class);
}