<?php

declare(strict_types=1);

use Core\Mod\Commerce\Models\Entity;
use Core\Mod\Commerce\Models\Inventory;
use Core\Mod\Commerce\Models\InventoryMovement;
use Core\Mod\Commerce\Models\Product;
use Core\Mod\Commerce\Models\Warehouse;
use Core\Mod\Commerce\Services\WarehouseService;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Schema;

uses(RefreshDatabase::class);

beforeEach(function () {
    // Ensure warehouse table has all columns the model expects
    if (! Schema::hasColumn('commerce_warehouses', 'is_primary')) {
        Schema::table('commerce_warehouses', function ($table) {
            if (! Schema::hasColumn('commerce_warehouses', 'description')) {
                $table->string('description')->nullable()->after('name');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'county')) {
                $table->string('county')->nullable()->after('city');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'postcode')) {
                $table->string('postcode')->nullable()->after('county');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'contact_name')) {
                $table->string('contact_name')->nullable()->after('country');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'contact_email')) {
                $table->string('contact_email')->nullable()->after('contact_name');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'contact_phone')) {
                $table->string('contact_phone')->nullable()->after('contact_email');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'type')) {
                $table->string('type')->default(Warehouse::TYPE_OWNED)->after('contact_phone');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'can_ship')) {
                $table->boolean('can_ship')->default(true)->after('type');
            }
            if (! Schema::hasColumn('commerce_warehouses', 'can_pickup')) {
                $table->boolean('can_pickup')->default(false)->after('can_ship');
            }
            $table->boolean('is_primary')->default(false)->after('can_pickup');
            if (! Schema::hasColumn('commerce_warehouses', 'operating_hours')) {
                $table->json('operating_hours')->nullable()->after('is_primary');
            }
        });
    }

    // Ensure inventory table has all columns the model expects
    if (! Schema::hasColumn('commerce_inventory', 'reserved_quantity')) {
        Schema::table('commerce_inventory', function ($table) {
            $table->renameColumn('reserved', 'reserved_quantity');
        });
        Schema::table('commerce_inventory', function ($table) {
            if (! Schema::hasColumn('commerce_inventory', 'incoming_quantity')) {
                $table->integer('incoming_quantity')->default(0)->after('reserved_quantity');
            }
            if (! Schema::hasColumn('commerce_inventory', 'bin_location')) {
                $table->string('bin_location')->nullable()->after('low_stock_threshold');
            }
            if (! Schema::hasColumn('commerce_inventory', 'zone')) {
                $table->string('zone')->nullable()->after('bin_location');
            }
            if (! Schema::hasColumn('commerce_inventory', 'last_restocked_at')) {
                $table->timestamp('last_restocked_at')->nullable()->after('last_counted_at');
            }
            if (! Schema::hasColumn('commerce_inventory', 'unit_cost')) {
                $table->integer('unit_cost')->nullable()->after('last_restocked_at');
            }
            if (! Schema::hasColumn('commerce_inventory', 'metadata')) {
                $table->json('metadata')->nullable()->after('unit_cost');
            }
        });
    }

    // Create inventory movements table if it does not exist
    if (! Schema::hasTable('commerce_inventory_movements')) {
        Schema::create('commerce_inventory_movements', function ($table) {
            $table->id();
            $table->foreignId('inventory_id')->nullable()->constrained('commerce_inventory')->nullOnDelete();
            $table->foreignId('product_id')->constrained('commerce_products')->cascadeOnDelete();
            $table->foreignId('warehouse_id')->constrained('commerce_warehouses')->cascadeOnDelete();
            $table->string('type', 32);
            $table->integer('quantity');
            $table->integer('balance_after')->default(0);
            $table->string('reference')->nullable();
            $table->text('notes')->nullable();
            $table->foreignId('user_id')->nullable()->constrained('users')->nullOnDelete();
            $table->integer('unit_cost')->nullable();
            $table->timestamp('created_at')->nullable();

            $table->index(['product_id', 'type']);
            $table->index(['warehouse_id', 'type']);
            $table->index(['reference']);
        });
    }

    // Create M1 entity
    $this->entity = Entity::createMaster('WH', 'Warehouse Test Co');

    // Create a non-M1 entity for negative testing
    $this->m2Entity = $this->entity->createFacade('SHOP', 'Shop Front');

    // Create product owned by M1
    $this->product = Product::create([
        'sku' => 'WH-TEST-001',
        'owner_entity_id' => $this->entity->id,
        'name' => 'Test Widget',
        'price' => 1500,
        'currency' => 'GBP',
        'type' => Product::TYPE_SIMPLE,
    ]);

    // Create a second product for multi-product tests
    $this->productB = Product::create([
        'sku' => 'WH-TEST-002',
        'owner_entity_id' => $this->entity->id,
        'name' => 'Test Gadget',
        'price' => 2500,
        'currency' => 'GBP',
        'type' => Product::TYPE_SIMPLE,
    ]);

    $this->service = new WarehouseService;
});

// ──────────────────────────────────────────────
// Warehouse Management
// ──────────────────────────────────────────────

describe('WarehouseService', function () {
    describe('createWarehouse()', function () {
        it('creates a warehouse for an M1 entity', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'main',
                'name' => 'Main Warehouse',
                'country' => 'GB',
                'is_active' => true,
            ]);

            expect($warehouse)->toBeInstanceOf(Warehouse::class)
                ->and($warehouse->entity_id)->toBe($this->entity->id)
                ->and($warehouse->code)->toBe('MAIN')
                ->and($warehouse->name)->toBe('Main Warehouse')
                ->and($warehouse->country)->toBe('GB')
                ->and($warehouse->is_active)->toBeTrue();
        });

        it('uppercases the warehouse code', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'london-south',
                'name' => 'London South',
            ]);

            expect($warehouse->code)->toBe('LONDON-SOUTH');
        });

        it('throws exception for non-M1 entity', function () {
            expect(fn () => $this->service->createWarehouse($this->m2Entity, [
                'code' => 'nope',
                'name' => 'Should Fail',
            ]))->toThrow(InvalidArgumentException::class, 'Only M1 (Master) entities can own warehouses.');
        });
    });

    describe('getWarehousesForEntity()', function () {
        it('returns active warehouses ordered by primary first', function () {
            $warehouseA = $this->service->createWarehouse($this->entity, [
                'code' => 'wh-a',
                'name' => 'Warehouse A',
                'is_active' => true,
                'is_primary' => false,
            ]);

            $warehouseB = $this->service->createWarehouse($this->entity, [
                'code' => 'wh-b',
                'name' => 'Warehouse B',
                'is_active' => true,
                'is_primary' => true,
            ]);

            // Inactive warehouse should not appear
            $this->service->createWarehouse($this->entity, [
                'code' => 'wh-c',
                'name' => 'Inactive Warehouse',
                'is_active' => false,
            ]);

            $warehouses = $this->service->getWarehousesForEntity($this->entity);

            expect($warehouses)->toHaveCount(2)
                ->and($warehouses->first()->id)->toBe($warehouseB->id)
                ->and($warehouses->last()->id)->toBe($warehouseA->id);
        });

        it('returns empty collection when no warehouses exist', function () {
            $warehouses = $this->service->getWarehousesForEntity($this->entity);

            expect($warehouses)->toHaveCount(0);
        });
    });

    describe('getPrimaryWarehouse()', function () {
        it('returns the primary warehouse', function () {
            $this->service->createWarehouse($this->entity, [
                'code' => 'secondary',
                'name' => 'Secondary',
                'is_active' => true,
                'is_primary' => false,
            ]);

            $primary = $this->service->createWarehouse($this->entity, [
                'code' => 'primary',
                'name' => 'Primary HQ',
                'is_active' => true,
                'is_primary' => true,
            ]);

            $result = $this->service->getPrimaryWarehouse($this->entity);

            expect($result)->not->toBeNull()
                ->and($result->id)->toBe($primary->id);
        });

        it('returns null when no primary warehouse is set', function () {
            $this->service->createWarehouse($this->entity, [
                'code' => 'noprimary',
                'name' => 'No Primary',
                'is_active' => true,
                'is_primary' => false,
            ]);

            $result = $this->service->getPrimaryWarehouse($this->entity);

            expect($result)->toBeNull();
        });
    });

    describe('setPrimaryWarehouse()', function () {
        it('sets a warehouse as primary and unsets others', function () {
            $warehouseA = $this->service->createWarehouse($this->entity, [
                'code' => 'wh-a',
                'name' => 'Warehouse A',
                'is_active' => true,
                'is_primary' => true,
            ]);

            $warehouseB = $this->service->createWarehouse($this->entity, [
                'code' => 'wh-b',
                'name' => 'Warehouse B',
                'is_active' => true,
                'is_primary' => false,
            ]);

            $this->service->setPrimaryWarehouse($warehouseB);

            $warehouseA->refresh();
            $warehouseB->refresh();

            expect($warehouseB->is_primary)->toBeTrue()
                ->and($warehouseA->is_primary)->toBeFalse();
        });
    });

    // ──────────────────────────────────────────────
    // Inventory Operations
    // ──────────────────────────────────────────────

    describe('getOrCreateInventory()', function () {
        it('creates new inventory record with zero quantities', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'inv',
                'name' => 'Inventory Warehouse',
                'is_active' => true,
            ]);

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);

            expect($inventory)->toBeInstanceOf(Inventory::class)
                ->and($inventory->product_id)->toBe($this->product->id)
                ->and($inventory->warehouse_id)->toBe($warehouse->id)
                ->and($inventory->quantity)->toBe(0)
                ->and($inventory->reserved_quantity)->toBe(0)
                ->and($inventory->incoming_quantity)->toBe(0);
        });

        it('returns existing inventory record on second call', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'inv2',
                'name' => 'Inventory Warehouse 2',
                'is_active' => true,
            ]);

            $first = $this->service->getOrCreateInventory($this->product, $warehouse);
            $second = $this->service->getOrCreateInventory($this->product, $warehouse);

            expect($first->id)->toBe($second->id);
        });
    });

    describe('addStock()', function () {
        it('adds stock and records a movement', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'add',
                'name' => 'Add Stock Warehouse',
                'is_active' => true,
            ]);

            $inventory = $this->service->addStock(
                $this->product,
                $warehouse,
                50,
                InventoryMovement::TYPE_PURCHASE,
                'PO-001',
                'Initial stock purchase'
            );

            expect($inventory->quantity)->toBe(50)
                ->and($inventory->reserved_quantity)->toBe(0);

            // Verify movement was recorded
            $movement = InventoryMovement::where('inventory_id', $inventory->id)->first();
            expect($movement)->not->toBeNull()
                ->and($movement->type)->toBe(InventoryMovement::TYPE_PURCHASE)
                ->and($movement->quantity)->toBe(50)
                ->and($movement->reference)->toBe('PO-001')
                ->and($movement->notes)->toBe('Initial stock purchase');
        });

        it('accumulates stock across multiple additions', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'accum',
                'name' => 'Accumulate Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 30);
            $inventory = $this->service->addStock($this->product, $warehouse, 20);

            expect($inventory->quantity)->toBe(50);

            // Two movements should exist
            $movements = InventoryMovement::where('inventory_id', $inventory->id)->count();
            expect($movements)->toBe(2);
        });

        it('stores unit cost when provided', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'cost',
                'name' => 'Cost Warehouse',
                'is_active' => true,
            ]);

            $inventory = $this->service->addStock(
                $this->product,
                $warehouse,
                10,
                InventoryMovement::TYPE_PURCHASE,
                null,
                null,
                750
            );

            expect($inventory->unit_cost)->toBe(750);
        });
    });

    describe('removeStock()', function () {
        it('removes stock when available quantity is sufficient', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'rem',
                'name' => 'Remove Stock Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 100);

            $result = $this->service->removeStock(
                $this->product,
                $warehouse,
                30,
                InventoryMovement::TYPE_SALE,
                'ORD-001'
            );

            expect($result)->toBeTrue();

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->quantity)->toBe(70);

            // Verify outbound movement
            $movement = InventoryMovement::where('reference', 'ORD-001')->first();
            expect($movement)->not->toBeNull()
                ->and($movement->quantity)->toBe(-30)
                ->and($movement->type)->toBe(InventoryMovement::TYPE_SALE);
        });

        it('returns false when insufficient stock', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'insuf',
                'name' => 'Insufficient Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 10);

            $result = $this->service->removeStock($this->product, $warehouse, 20);

            expect($result)->toBeFalse();

            // Quantity should remain unchanged
            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->quantity)->toBe(10);
        });

        it('accounts for reserved quantity in available check', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'resavail',
                'name' => 'Reserved Availability Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 20);
            $this->service->reserveStock($this->product, $warehouse, 15, 'ORD-RES');

            // Available = 20 - 15 = 5, so removing 10 should fail
            $result = $this->service->removeStock($this->product, $warehouse, 10);
            expect($result)->toBeFalse();

            // Removing 5 should succeed
            $result = $this->service->removeStock($this->product, $warehouse, 5);
            expect($result)->toBeTrue();
        });
    });

    // ──────────────────────────────────────────────
    // Stock Reservation & Fulfilment
    // ──────────────────────────────────────────────

    describe('reserveStock()', function () {
        it('reserves stock for an order', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'res',
                'name' => 'Reserve Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 50);

            $result = $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-100');

            expect($result)->toBeTrue();

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->reserved_quantity)->toBe(10)
                ->and($inventory->getAvailableQuantity())->toBe(40);

            // Verify reservation movement
            $movement = InventoryMovement::where('reference', 'ORD-100')
                ->where('type', InventoryMovement::TYPE_RESERVED)
                ->first();
            expect($movement)->not->toBeNull()
                ->and($movement->quantity)->toBe(-10)
                ->and($movement->notes)->toContain('Reserved for order ORD-100');
        });

        it('returns false when insufficient available stock', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'res2',
                'name' => 'Reserve Warehouse 2',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 5);

            $result = $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-BIG');

            expect($result)->toBeFalse();

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->reserved_quantity)->toBe(0);
        });

        it('allows multiple reservations up to available stock', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'multi',
                'name' => 'Multi Reserve Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 30);

            $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-A');
            $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-B');

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->reserved_quantity)->toBe(20)
                ->and($inventory->getAvailableQuantity())->toBe(10);

            // Third reservation for 15 should fail (only 10 available)
            $result = $this->service->reserveStock($this->product, $warehouse, 15, 'ORD-C');
            expect($result)->toBeFalse();
        });
    });

    describe('releaseStock()', function () {
        it('releases reserved stock', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'rel',
                'name' => 'Release Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 50);
            $this->service->reserveStock($this->product, $warehouse, 20, 'ORD-REL');

            $this->service->releaseStock($this->product, $warehouse, 20, 'ORD-REL');

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->reserved_quantity)->toBe(0)
                ->and($inventory->getAvailableQuantity())->toBe(50);

            // Verify release movement
            $movement = InventoryMovement::where('reference', 'ORD-REL')
                ->where('type', InventoryMovement::TYPE_RELEASED)
                ->first();
            expect($movement)->not->toBeNull()
                ->and($movement->quantity)->toBe(20)
                ->and($movement->notes)->toContain('Released from order ORD-REL');
        });
    });

    describe('fulfillStock()', function () {
        it('converts reserved stock to a sale', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'ful',
                'name' => 'Fulfil Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 100);
            $this->service->reserveStock($this->product, $warehouse, 25, 'ORD-FUL');

            $result = $this->service->fulfillStock($this->product, $warehouse, 25, 'ORD-FUL');

            expect($result)->toBeTrue();

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            // quantity should decrease by 25, reserved should decrease by 25
            expect($inventory->quantity)->toBe(75)
                ->and($inventory->reserved_quantity)->toBe(0);

            // Verify fulfilment movement
            $movement = InventoryMovement::where('reference', 'ORD-FUL')
                ->where('type', InventoryMovement::TYPE_SALE)
                ->first();
            expect($movement)->not->toBeNull()
                ->and($movement->quantity)->toBe(-25);
        });

        it('returns false when reserved quantity is insufficient', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'ful2',
                'name' => 'Fulfil Warehouse 2',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 50);
            $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-SMALL');

            $result = $this->service->fulfillStock($this->product, $warehouse, 20, 'ORD-SMALL');

            expect($result)->toBeFalse();

            // Nothing should change
            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->quantity)->toBe(50)
                ->and($inventory->reserved_quantity)->toBe(10);
        });
    });

    // ──────────────────────────────────────────────
    // Stock Transfer
    // ──────────────────────────────────────────────

    describe('transferStock()', function () {
        it('transfers stock between warehouses', function () {
            $warehouseA = $this->service->createWarehouse($this->entity, [
                'code' => 'src',
                'name' => 'Source Warehouse',
                'is_active' => true,
            ]);

            $warehouseB = $this->service->createWarehouse($this->entity, [
                'code' => 'dst',
                'name' => 'Destination Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouseA, 100);

            $result = $this->service->transferStock(
                $this->product,
                $warehouseA,
                $warehouseB,
                40,
                'Redistribution to new warehouse'
            );

            expect($result)->toBeTrue();

            $fromInventory = $this->service->getOrCreateInventory($this->product, $warehouseA);
            $toInventory = $this->service->getOrCreateInventory($this->product, $warehouseB);

            expect($fromInventory->quantity)->toBe(60)
                ->and($toInventory->quantity)->toBe(40);

            // Verify transfer movements
            $outMovement = InventoryMovement::where('warehouse_id', $warehouseA->id)
                ->where('type', InventoryMovement::TYPE_TRANSFER_OUT)
                ->first();
            $inMovement = InventoryMovement::where('warehouse_id', $warehouseB->id)
                ->where('type', InventoryMovement::TYPE_TRANSFER_IN)
                ->first();

            expect($outMovement)->not->toBeNull()
                ->and($outMovement->quantity)->toBe(-40)
                ->and($outMovement->notes)->toBe('Redistribution to new warehouse')
                ->and($inMovement)->not->toBeNull()
                ->and($inMovement->quantity)->toBe(40)
                ->and($inMovement->notes)->toBe('Redistribution to new warehouse');

            // Both should share the same TRANSFER reference
            expect($outMovement->reference)->toStartWith('TRANSFER-')
                ->and($outMovement->reference)->toBe($inMovement->reference);
        });

        it('returns false when source has insufficient stock', function () {
            $warehouseA = $this->service->createWarehouse($this->entity, [
                'code' => 'src2',
                'name' => 'Source 2',
                'is_active' => true,
            ]);

            $warehouseB = $this->service->createWarehouse($this->entity, [
                'code' => 'dst2',
                'name' => 'Destination 2',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouseA, 10);

            $result = $this->service->transferStock($this->product, $warehouseA, $warehouseB, 50);

            expect($result)->toBeFalse();

            // Source stock should be unchanged
            $fromInventory = $this->service->getOrCreateInventory($this->product, $warehouseA);
            expect($fromInventory->quantity)->toBe(10);
        });
    });

    // ──────────────────────────────────────────────
    // Stock Count Adjustment
    // ──────────────────────────────────────────────

    describe('adjustStock()', function () {
        it('adjusts stock upward and returns positive difference', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'adj',
                'name' => 'Adjustment Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 40);

            $difference = $this->service->adjustStock($this->product, $warehouse, 55, 'Physical count +15');

            expect($difference)->toBe(15);

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->quantity)->toBe(55);

            // Verify count movement
            $movement = InventoryMovement::where('type', InventoryMovement::TYPE_COUNT)
                ->where('inventory_id', $inventory->id)
                ->first();
            expect($movement)->not->toBeNull()
                ->and($movement->quantity)->toBe(15)
                ->and($movement->reference)->toStartWith('COUNT-');
        });

        it('adjusts stock downward and returns negative difference', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'adj2',
                'name' => 'Adjustment Warehouse 2',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 50);

            $difference = $this->service->adjustStock($this->product, $warehouse, 42);

            expect($difference)->toBe(-8);

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->quantity)->toBe(42);
        });

        it('uses default notes when none provided', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'adj3',
                'name' => 'Adjustment Warehouse 3',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 10);
            $this->service->adjustStock($this->product, $warehouse, 15);

            $movement = InventoryMovement::where('type', InventoryMovement::TYPE_COUNT)->first();
            expect($movement->notes)->toBe('Physical count adjustment');
        });
    });

    // ──────────────────────────────────────────────
    // Query Methods
    // ──────────────────────────────────────────────

    describe('getTotalStock()', function () {
        it('sums stock across all warehouses', function () {
            $warehouseA = $this->service->createWarehouse($this->entity, [
                'code' => 'ts-a',
                'name' => 'Total Stock A',
                'is_active' => true,
            ]);

            $warehouseB = $this->service->createWarehouse($this->entity, [
                'code' => 'ts-b',
                'name' => 'Total Stock B',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouseA, 30);
            $this->service->addStock($this->product, $warehouseB, 70);

            $total = $this->service->getTotalStock($this->product);

            expect($total)->toBe(100);
        });

        it('returns zero when no inventory exists', function () {
            $total = $this->service->getTotalStock($this->product);

            expect($total)->toBe(0);
        });
    });

    describe('getTotalAvailableStock()', function () {
        it('subtracts reserved quantities from total', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'avail',
                'name' => 'Available Stock Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 80);
            $this->service->reserveStock($this->product, $warehouse, 30, 'ORD-AVL');

            $available = $this->service->getTotalAvailableStock($this->product);

            expect($available)->toBe(50);
        });

        it('returns zero when all stock is reserved', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'allres',
                'name' => 'All Reserved Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 20);
            $this->service->reserveStock($this->product, $warehouse, 20, 'ORD-ALL');

            $available = $this->service->getTotalAvailableStock($this->product);

            expect($available)->toBe(0);
        });
    });

    describe('getStockByWarehouse()', function () {
        it('returns inventory records with warehouse relation', function () {
            $warehouseA = $this->service->createWarehouse($this->entity, [
                'code' => 'sbw-a',
                'name' => 'Stock By WH A',
                'is_active' => true,
            ]);

            $warehouseB = $this->service->createWarehouse($this->entity, [
                'code' => 'sbw-b',
                'name' => 'Stock By WH B',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouseA, 25);
            $this->service->addStock($this->product, $warehouseB, 75);

            $stock = $this->service->getStockByWarehouse($this->product);

            expect($stock)->toHaveCount(2);

            // Each record should have warehouse loaded
            $stock->each(function ($inv) {
                expect($inv->relationLoaded('warehouse'))->toBeTrue()
                    ->and($inv->warehouse)->toBeInstanceOf(Warehouse::class);
            });
        });
    });

    describe('findBestWarehouse()', function () {
        it('returns primary warehouse when it has sufficient stock', function () {
            $primary = $this->service->createWarehouse($this->entity, [
                'code' => 'best-p',
                'name' => 'Primary Best',
                'is_active' => true,
                'is_primary' => true,
                'can_ship' => true,
            ]);

            $secondary = $this->service->createWarehouse($this->entity, [
                'code' => 'best-s',
                'name' => 'Secondary Best',
                'is_active' => true,
                'is_primary' => false,
                'can_ship' => true,
            ]);

            $this->service->addStock($this->product, $primary, 50);
            $this->service->addStock($this->product, $secondary, 50);

            $best = $this->service->findBestWarehouse($this->product, 10);

            expect($best)->not->toBeNull()
                ->and($best->id)->toBe($primary->id);
        });

        it('returns null when no warehouse can fulfil the quantity', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'best-n',
                'name' => 'Not Enough',
                'is_active' => true,
                'can_ship' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 5);

            $best = $this->service->findBestWarehouse($this->product, 50);

            expect($best)->toBeNull();
        });

        it('excludes warehouses that cannot ship', function () {
            $noShip = $this->service->createWarehouse($this->entity, [
                'code' => 'nosh',
                'name' => 'No Ship Warehouse',
                'is_active' => true,
                'can_ship' => false,
            ]);

            $this->service->addStock($this->product, $noShip, 100);

            $best = $this->service->findBestWarehouse($this->product, 10);

            expect($best)->toBeNull();
        });
    });

    describe('getLowStockProducts()', function () {
        it('returns inventory records below threshold', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'low',
                'name' => 'Low Stock Warehouse',
                'is_active' => true,
            ]);

            // Product with 3 units (default threshold is 5)
            $this->service->addStock($this->product, $warehouse, 3);

            // Product with plenty of stock
            $this->service->addStock($this->productB, $warehouse, 100);

            $lowStock = $this->service->getLowStockProducts($this->entity);

            expect($lowStock)->toHaveCount(1)
                ->and($lowStock->first()->product_id)->toBe($this->product->id);
        });
    });

    describe('getOutOfStockProducts()', function () {
        it('returns inventory records with zero or negative available quantity', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'oos',
                'name' => 'Out of Stock Warehouse',
                'is_active' => true,
            ]);

            // Product with zero stock
            $this->service->getOrCreateInventory($this->product, $warehouse);

            // Product with stock
            $this->service->addStock($this->productB, $warehouse, 50);

            $outOfStock = $this->service->getOutOfStockProducts($this->entity);

            expect($outOfStock)->toHaveCount(1)
                ->and($outOfStock->first()->product_id)->toBe($this->product->id);
        });
    });

    describe('getMovementHistory()', function () {
        it('returns movements ordered by newest first', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'hist',
                'name' => 'History Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 100);
            $this->service->removeStock($this->product, $warehouse, 20, InventoryMovement::TYPE_SALE, 'ORD-H1');
            $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-H2');

            $history = $this->service->getMovementHistory($this->product);

            expect($history)->toHaveCount(3)
                ->and($history->first()->created_at->gte($history->last()->created_at))->toBeTrue();
        });

        it('respects the limit parameter', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'lim',
                'name' => 'Limit Warehouse',
                'is_active' => true,
            ]);

            // Create several movements
            $this->service->addStock($this->product, $warehouse, 100);
            $this->service->removeStock($this->product, $warehouse, 10);
            $this->service->removeStock($this->product, $warehouse, 10);
            $this->service->removeStock($this->product, $warehouse, 10);

            $history = $this->service->getMovementHistory($this->product, 2);

            expect($history)->toHaveCount(2);
        });
    });

    // ──────────────────────────────────────────────
    // Full Lifecycle Integration
    // ──────────────────────────────────────────────

    describe('full order lifecycle', function () {
        it('handles reserve -> fulfil workflow', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'life',
                'name' => 'Lifecycle Warehouse',
                'is_active' => true,
            ]);

            // Receive stock
            $this->service->addStock($this->product, $warehouse, 50);

            // Customer places order: reserve
            $reserved = $this->service->reserveStock($this->product, $warehouse, 5, 'ORD-LIFE');
            expect($reserved)->toBeTrue();

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->quantity)->toBe(50)
                ->and($inventory->reserved_quantity)->toBe(5)
                ->and($inventory->getAvailableQuantity())->toBe(45);

            // Ship order: fulfil
            $fulfilled = $this->service->fulfillStock($this->product, $warehouse, 5, 'ORD-LIFE');
            expect($fulfilled)->toBeTrue();

            $inventory->refresh();
            expect($inventory->quantity)->toBe(45)
                ->and($inventory->reserved_quantity)->toBe(0)
                ->and($inventory->getAvailableQuantity())->toBe(45);
        });

        it('handles reserve -> release workflow (cancelled order)', function () {
            $warehouse = $this->service->createWarehouse($this->entity, [
                'code' => 'canc',
                'name' => 'Cancel Warehouse',
                'is_active' => true,
            ]);

            $this->service->addStock($this->product, $warehouse, 30);
            $this->service->reserveStock($this->product, $warehouse, 10, 'ORD-CANC');

            $inventory = $this->service->getOrCreateInventory($this->product, $warehouse);
            expect($inventory->getAvailableQuantity())->toBe(20);

            // Order cancelled: release
            $this->service->releaseStock($this->product, $warehouse, 10, 'ORD-CANC');

            $inventory->refresh();
            expect($inventory->quantity)->toBe(30)
                ->and($inventory->reserved_quantity)->toBe(0)
                ->and($inventory->getAvailableQuantity())->toBe(30);
        });
    });
});