<?php

use App\Enums\OrderChannel;
use App\Enums\OrderStatus;
use App\Enums\PaymentMethod;
use App\Enums\PriceType;
use App\Models\Order;
use App\Models\OrderItem;
use App\Models\Product;
use App\Settings\GeneralSettings;

use function Pest\Laravel\actingAs;
use function Pest\Laravel\assertDatabaseHas;
use function Pest\Laravel\assertSoftDeleted;
use function Pest\Laravel\deleteJson;
use function Pest\Laravel\get;
use function Pest\Laravel\patchJson;
use function Pest\Laravel\postJson;

/*
|--------------------------------------------------------------------------
| Order Module Tests
|--------------------------------------------------------------------------
*/

describe('Order Module - Authorization', function () {
    it('redirects to login when accessing order index unauthenticated', function () {
        get(route('order.index'))
            ->assertRedirect(route('login'));
    });

    it('returns 403 when user has no permission to view orders', function () {
        actingAs(createUnauthorizedUser())
            ->get(route('order.index'))
            ->assertStatus(403);
    });
});

describe('Order Module - Authorized Actions', function () {
    beforeEach(function () {
        $user = createAuthorizedUser([
            'View:Order',
            'Create:Order',
            'Edit:Order',
            'Delete:Order',
            'DeleteAny:Order',
        ]);
        actingAs($user);

        $settings = app(GeneralSettings::class);
        $settings->site_name = 'VN Grup';
        $settings->site_phone = '08123456789';
        $settings->site_address = 'Jl. Test No. 1';
        $settings->site_description = 'Test Description';
        $settings->save();
    });

    it('can access order index page', function () {
        Order::factory()->create();

        get(route('order.index'))
            ->assertOk()
            ->assertInertia(fn ($page) => $page
                ->component('admin/manage/order/index')
                ->has('orders', fn ($page) => $page
                    ->has('data.0.user')
                    ->has('data.0.cogs_formatted')
                    ->has('data.0.payment_formatted')
                    ->has('data.0.created_at_formatted')
                    ->etc()
                )
            );
    });

    it('can access order create page', function () {
        get(route('order.create'))
            ->assertOk()
            ->assertInertia(fn ($page) => $page
                ->component('admin/manage/order/create')
                ->has('products')
                ->has('cartItems')
                ->where('orderStatus', function ($status) {
                    return collect($status)->every(fn ($item) => $item['value'] !== OrderStatus::CANCELLED->value);
                })
            );
    });

    it('can access order show page', function () {
        $order = Order::factory()
            ->has(OrderItem::factory()->count(2), 'items')
            ->create();

        get(route('order.show', $order))
            ->assertOk()
            ->assertInertia(fn ($page) => $page
                ->component('admin/manage/order/show')
                ->has('order', fn ($page) => $page
                    ->where('id', $order->id)
                    ->has('items', 2)
                    ->has('items.0.product')
                    ->has('user')
                    ->etc()
                )
                ->has('setting')
            );
    });

    it('can access order edit page', function () {
        $order = Order::factory()->create();

        get(route('order.edit', $order))
            ->assertOk()
            ->assertInertia(fn ($page) => $page
                ->component('admin/manage/order/edit')
                ->has('order')
                ->has('products')
                ->has('orderStatus')
                ->has('orderChannels')
                ->has('paymentMethods')
                ->has('priceTypes')
            );
    });

    it('can manage cart items', function () {
        $product = Product::factory()->create(['stock' => 10]);

        // 1. Add to cart
        postJson(route('order.addToCart'), [
            'product_id' => $product->id,
            'qty' => 2,
            'price' => 10000,
            'price_type' => PriceType::RETAIL->value,
        ])->assertRedirect();

        assertDatabaseHas('order_items', [
            'user_id' => auth()->id(),
            'order_id' => null,
            'product_id' => $product->id,
            'qty' => 2,
        ]);

        $cartItem = OrderItem::where('product_id', $product->id)->whereNull('order_id')->first();

        // 2. Update cart item
        patchJson(route('order.updateCartItem', $cartItem), [
            'product_id' => $product->id,
            'qty' => 5,
            'price' => 10000,
            'price_type' => PriceType::RETAIL->value,
        ])->assertRedirect();

        expect($cartItem->fresh()->qty)->toBe(5);

        // 3. Remove from cart
        deleteJson(route('order.removeFromCart', $cartItem))->assertRedirect();
        assertSoftDeleted('order_items', ['id' => $cartItem->id]);
    });

    it('can store a new order', function () {
        $product = Product::factory()->create(['stock' => 10]);

        // Update existing PURCHASE price from factory to ensure COGS calculation is predictable
        $product->prices()->where('price_type', PriceType::PURCHASE->value)->update([
            'price' => 8000,
        ]);

        $data = [
            'customer_name' => 'John Doe',
            'subtotal' => 20000,
            'discount' => 2000,
            'payment' => 18000,
            'payment_method' => PaymentMethod::CASH->value,
            'order_status' => OrderStatus::PENDING->value,
            'order_channel' => OrderChannel::STORE->value,
            'items' => [
                [
                    'product_id' => $product->id,
                    'qty' => 2,
                    'price' => 10000,
                    'total' => 20000,
                    'price_type' => PriceType::RETAIL->value,
                ],
            ],
        ];

        postJson(route('order.store'), $data)
            ->assertRedirect(route('order.index'))
            ->assertSessionHas('success');

        assertDatabaseHas('orders', [
            'customer_name' => 'John Doe',
            'subtotal' => 20000,
            'discount' => 2000,
            'total' => 18000,
            'payment' => 18000,
            'payment_method' => PaymentMethod::CASH->value,
            'order_status' => OrderStatus::PENDING->value,
            'order_channel' => OrderChannel::STORE->value,
            'cogs' => 16000, // 8000 * 2
        ]);

        // Check stock decrement
        expect($product->fresh()->stock)->toBe(8);

        // Check order items
        assertDatabaseHas('order_items', [
            'product_id' => $product->id,
            'qty' => 2,
            'price' => 10000,
        ]);
    });

    it('validates order creation', function () {
        postJson(route('order.store'), [])
            ->assertStatus(422)
            ->assertJsonValidationErrors(['customer_name', 'items']);
    });

    it('returns flash error when stock is insufficient on order store', function () {
        $product = Product::factory()->create(['stock' => 1]);

        $data = [
            'customer_name' => 'John Doe',
            'subtotal' => 20000,
            'discount' => 0,
            'payment' => 20000,
            'payment_method' => PaymentMethod::CASH->value,
            'order_status' => OrderStatus::PENDING->value,
            'order_channel' => OrderChannel::STORE->value,
            'items' => [
                [
                    'product_id' => $product->id,
                    'qty' => 5, // lebih dari stok
                    'price' => 10000,
                    'total' => 50000,
                    'price_type' => PriceType::RETAIL->value,
                ],
            ],
        ];

        postJson(route('order.store'), $data)
            ->assertRedirect()
            ->assertSessionHas('error');

        expect($product->fresh()->stock)->toBe(1);
    });

    it('returns flash error when stock is insufficient on order update', function () {
        $product = Product::factory()->create(['stock' => 2]);
        $order = Order::factory()->create();

        $newData = [
            'customer_name' => 'Updated Customer',
            'subtotal' => 30000,
            'discount' => 0,
            'payment' => 30000,
            'payment_method' => PaymentMethod::CASH->value,
            'order_status' => OrderStatus::PROCESSING->value,
            'order_channel' => OrderChannel::STORE->value,
            'items' => [
                [
                    'product_id' => $product->id,
                    'qty' => 10, // lebih dari stok
                    'price' => 3000,
                    'total' => 30000,
                    'price_type' => PriceType::RETAIL->value,
                ],
            ],
        ];

        patchJson(route('order.update', $order), $newData)
            ->assertRedirect()
            ->assertSessionHas('error');

        expect($product->fresh()->stock)->toBe(2);
    });

    it('can update an order', function () {
        $product1 = Product::factory()->create(['stock' => 10]);
        $product2 = Product::factory()->create(['stock' => 10]);

        $order = Order::create([
            'customer_name' => 'Old Customer',
            'cogs' => 0,
            'subtotal' => 10000,
            'discount' => 0,
            'payment' => 10000,
            'total' => 10000,
            'payment_method' => PaymentMethod::CASH->value,
            'order_status' => OrderStatus::PENDING->value,
            'order_channel' => OrderChannel::STORE->value,
        ]);

        $order->items()->create([
            'user_id' => auth()->id(),
            'product_id' => $product1->id,
            'qty' => 1,
            'price' => 10000,
            'total' => 10000,
            'price_type' => PriceType::RETAIL->value,
        ]);

        // Initial stock check
        $product1->decrement('stock', 1);

        $newData = [
            'customer_name' => 'Updated Customer',
            'subtotal' => 15000,
            'discount' => 0,
            'payment' => 15000,
            'payment_method' => PaymentMethod::CASH->value,
            'order_status' => OrderStatus::PROCESSING->value,
            'order_channel' => OrderChannel::STORE->value,
            'items' => [
                [
                    'product_id' => $product2->id,
                    'qty' => 3,
                    'price' => 5000,
                    'total' => 15000,
                    'price_type' => PriceType::RETAIL->value,
                ],
            ],
        ];

        patchJson(route('order.update', $order), $newData)
            ->assertRedirect(route('order.index'))
            ->assertSessionHas('success');

        // Check data updated
        assertDatabaseHas('orders', [
            'id' => $order->id,
            'customer_name' => 'Updated Customer',
            'order_status' => OrderStatus::PROCESSING->value,
            'payment' => 15000,
            'total' => 15000,
        ]);

        // Check stock: product1 should be restored (10), product2 should be decremented (7)
        expect($product1->fresh()->stock)->toBe(10);
        expect($product2->fresh()->stock)->toBe(7);
    });

    it('restores stock and preserves items when order status is changed to gagal', function () {
        $product = Product::factory()->create(['stock' => 10]);
        $order = Order::factory()->create(['order_status' => OrderStatus::PENDING->value]);

        $item = $order->items()->create([
            'user_id' => auth()->id(),
            'product_id' => $product->id,
            'qty' => 3,
            'price' => 1000,
            'total' => 3000,
            'price_type' => PriceType::RETAIL->value,
        ]);

        $product->decrement('stock', 3);
        expect($product->fresh()->stock)->toBe(7);

        $newData = [
            'customer_name' => $order->customer_name,
            'subtotal' => 3000,
            'discount' => 0,
            'payment' => 3000,
            'payment_method' => $order->payment_method,
            'order_status' => OrderStatus::CANCELLED->value, // Change to Gagal
            'order_channel' => $order->order_channel,
            'items' => [
                // Even if we send items, they shouldn't be deleted/updated based on my early return
                [
                    'product_id' => $product->id,
                    'qty' => 5, // different qty
                    'price' => 1000,
                    'total' => 5000,
                    'price_type' => PriceType::RETAIL->value,
                ],
            ],
        ];

        patchJson(route('order.update', $order), $newData)
            ->assertRedirect();

        // Stock should be restored (7 + 3 = 10)
        expect($product->fresh()->stock)->toBe(10);

        // Items should be preserved (original item with qty 3, NOT deleted/recreated with qty 5)
        expect($order->items()->count())->toBe(1);
        expect($order->items()->first()->qty)->toBe(3);
        expect($order->items()->first()->id)->toBe($item->id); // Same ID means not deleted/recreated
    });

    it('can delete an order and restore stock', function () {
        $product = Product::factory()->create(['stock' => 5]);
        $order = Order::factory()->create();
        $order->items()->create([
            'user_id' => auth()->id(),
            'product_id' => $product->id,
            'qty' => 2,
            'price' => 1000,
            'total' => 2000,
            'price_type' => PriceType::RETAIL->value,
        ]);

        deleteJson(route('order.destroy', $order))
            ->assertRedirect()
            ->assertSessionHas('success');

        assertSoftDeleted('orders', ['id' => $order->id]);

        // Stock should be restored (5 + 2 = 7)
        expect($product->fresh()->stock)->toBe(7);
    });

    it('can delete orders in bulk', function () {
        $orders = Order::factory()->count(3)->create();
        $ids = $orders->pluck('id')->toArray();

        deleteJson(route('order.bulkDestroy'), ['ids' => $ids])
            ->assertRedirect()
            ->assertSessionHas('success');

        foreach ($ids as $id) {
            assertSoftDeleted('orders', ['id' => $id]);
        }
    });
});

describe('Order Module - Unauthorized Actions', function () {
    beforeEach(function () {
        actingAs(createUnauthorizedUser());
    });

    it('cannot view an order without permission', function () {
        $order = Order::factory()->create();
        get(route('order.show', $order))
            ->assertStatus(403);
    });

    it('cannot store an order without permission', function () {
        postJson(route('order.store'), ['customer_name' => 'Unauthorized'])
            ->assertStatus(403);
    });

    it('cannot update an order without permission', function () {
        $order = Order::factory()->create();
        patchJson(route('order.update', $order), ['customer_name' => 'Unauthorized'])
            ->assertStatus(403);
    });

    it('cannot delete an order without permission', function () {
        $order = Order::factory()->create();
        deleteJson(route('order.destroy', $order))
            ->assertStatus(403);
    });
});