<?php

use App\Livewire\Studio\Loyalty\Tier;
use App\Models\Bottle;
use App\Models\Brand;
use App\Models\Customer;
use App\Models\Employee;
use App\Models\Membership;
use App\Models\Order;
use App\Models\OrderItem;
use App\Models\Outlet;
use App\Models\Perfume;
use App\Models\Product;
use App\Models\Tier as TierModel;
use App\Models\TierReward;
use App\Models\User;
use Database\Seeders\RolePermissionSeeder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Illuminate\Support\Facades\Gate;
use Livewire\Livewire;
use Spatie\Permission\Models\Role;

uses(RefreshDatabase::class);

beforeEach(function () {
    $this->seed(RolePermissionSeeder::class);

    $this->user = User::factory()
        ->active()
        ->has(Employee::factory())
        ->create();

    $this->ownerRole = Role::where('name', 'Owner')->first();

    $this->user->roles()->attach($this->ownerRole->id);
});

function mountTierComponent(User $user)
{
    return Livewire::actingAs($user)->test(Tier::class);
}

/*
|--------------------------------------------------------------------------
| Component Rendering & Mount
|--------------------------------------------------------------------------
*/

it('renders page successfully', function () {
    mountTierComponent($this->user)
        ->assertViewIs('livewire.studio.loyalty.tiers')
        ->assertViewHas('pageTitle', 'Tier');
});

it('loads tiers on mount', function () {
    $tier1 = TierModel::factory()->create(['name' => 'Bronze', 'min_spending' => 0, 'max_spending' => 100000]);
    $tier2 = TierModel::factory()->create(['name' => 'Silver', 'min_spending' => 100001, 'max_spending' => 500000]);

    $component = mountTierComponent($this->user);

    expect($component->tiers)->toBeInstanceOf(\Illuminate\Support\Collection::class);
    expect($component->tiers)->toHaveCount(2);
    expect($component->tiers[0]->name)->toBe('Bronze');
    expect($component->tiers[1]->name)->toBe('Silver');
});

it('displays all tiers in the view', function () {
    $tier = TierModel::factory()->create(['name' => 'Gold', 'min_spending' => 1000000, 'max_spending' => 5000000]);

    mountTierComponent($this->user)
        ->assertSee('Gold')
        ->assertSee('1.000.000');
});

it('sorts tiers by min_spending ascending', function () {
    $tier3 = TierModel::factory()->create(['name' => 'Platinum', 'min_spending' => 10000000, 'max_spending' => null]);
    $tier1 = TierModel::factory()->create(['name' => 'Bronze', 'min_spending' => 0, 'max_spending' => 1000000]);
    $tier2 = TierModel::factory()->create(['name' => 'Silver', 'min_spending' => 1000001, 'max_spending' => 5000000]);

    $component = mountTierComponent($this->user);

    expect($component->tiers)->toBeInstanceOf(\Illuminate\Support\Collection::class);
    expect($component->tiers[0]->name)->toBe('Bronze');
    expect($component->tiers[1]->name)->toBe('Silver');
    expect($component->tiers[2]->name)->toBe('Platinum');
});

/*
|--------------------------------------------------------------------------
| Create Tier
|--------------------------------------------------------------------------
*/

it('prevents create when user is unauthorized', function () {
    $this->ownerRole->revokePermissionTo('create tier');

    Gate::define('create tier', fn () => false);

    mountTierComponent($this->user)
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '1000000')
        ->set('form.max_spending', '5000000')
        ->call('create')
        ->assertForbidden();
});

it('can create a tier when authorized', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '1.000.000')
        ->set('form.max_spending', '5.000.000')
        ->call('create')
        ->assertHasNoErrors()
        ->assertSet('tiers', function ($tiers) {
            return $tiers instanceof \Illuminate\Support\Collection &&
                $tiers->count() === 1 &&
                $tiers[0]->name === 'Gold';
        });

    $this->assertDatabaseHas('tiers', [
        'name' => 'Gold',
        'min_spending' => 1000000,
        'max_spending' => null, // reorderTierChain makes last tier null
    ]);
});

it('can create a tier without max_spending', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', 'Platinum')
        ->set('form.min_spending', '5.000.001')
        ->set('form.max_spending', null)
        ->call('create')
        ->assertHasNoErrors();

    $this->assertDatabaseHas('tiers', [
        'name' => 'Platinum',
        'min_spending' => 5000001,
        'max_spending' => null,
    ]);
});

it('sorts tiers after creating new tier', function () {
    TierModel::factory()->create(['name' => 'Silver', 'min_spending' => 500001, 'max_spending' => 1000000]);
    TierModel::factory()->create(['name' => 'Bronze', 'min_spending' => 0, 'max_spending' => 500000]);

    $component = mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '1.000.001')
        ->set('form.max_spending', '2.000.000')
        ->call('create');

    expect($component->tiers)->toBeInstanceOf(\Illuminate\Support\Collection::class);
    expect($component->tiers[0]->name)->toBe('Bronze');
    expect($component->tiers[1]->name)->toBe('Silver');
    expect($component->tiers[2]->name)->toBe('Gold');
});

it('validates required fields when creating tier', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->call('create')
        ->assertHasErrors([
            'form.name',
            'form.min_spending',
        ]);
});

it('validates name field max length when creating tier', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', str_repeat('a', 51))
        ->set('form.min_spending', '100')
        ->call('create')
        ->assertHasErrors(['form.name']);
});

it('validates min_spending is unsigned integer when creating tier', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '-100')
        ->call('create')
        ->assertHasErrors(['form.min_spending']);
});

it('validates max_spending is unsigned integer when creating tier', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '100')
        ->set('form.max_spending', '-50')
        ->call('create')
        ->assertHasErrors(['form.max_spending']);
});

/*
|--------------------------------------------------------------------------
| Update Tier
|--------------------------------------------------------------------------
*/

it('prevents update when user is unauthorized', function () {
    $this->ownerRole->revokePermissionTo('update tier');
    Gate::define('update tier', fn () => false);

    $tier = TierModel::factory()->create(['name' => 'Bronze', 'min_spending' => 0, 'max_spending' => 100000]);

    mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->set('form.name', 'Gold')
        ->call('update')
        ->assertForbidden();
});

it('can update a tier when authorized', function () {
    $tier = TierModel::factory()->create(['name' => 'Bronze', 'min_spending' => 0, 'max_spending' => 100000]);

    mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->assertSet('form.name', 'Bronze')
        ->assertSet('form.min_spending', formatCurrencyNumber($tier->min_spending))
        ->assertSet('form.max_spending', formatCurrencyNumber($tier->max_spending))
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '1.000.000')
        ->set('form.max_spending', '5.000.000')
        ->call('update')
        ->assertHasNoErrors()
        ->assertSet('tiers', function ($tiers) use ($tier) {
            $updatedTier = $tiers->firstWhere('hash', $tier->hash);

            return $updatedTier->name === 'Gold';
        });

    $tier->refresh();
    expect($tier->name)->toBe('Gold');
    expect($tier->min_spending)->toBe(1000000);
    expect($tier->max_spending)->toBeNull(); // reorderTierChain makes last tier null
});

it('can update tier without max_spending', function () {
    $tier = TierModel::factory()->create(['name' => 'Bronze', 'min_spending' => 0, 'max_spending' => 100000]);

    mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->set('form.max_spending', null)
        ->call('update')
        ->assertHasNoErrors();

    $tier->refresh();
    expect($tier->max_spending)->toBeNull();
});

it('validates required fields when updating tier', function () {
    $tier = TierModel::factory()->create();

    mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->set('form.name', '')
        ->set('form.min_spending', '')
        ->call('update')
        ->assertHasErrors([
            'form.name',
            'form.min_spending',
        ]);
});

it('validates name field max length when updating tier', function () {
    $tier = TierModel::factory()->create();

    mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->set('form.name', str_repeat('a', 51))
        ->call('update')
        ->assertHasErrors(['form.name']);
});

it('resets validation and error bag when opening modal', function () {
    $tier = TierModel::factory()->create();

    $component = mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->set('form.name', '')
        ->call('update')
        ->assertHasErrors(['form.name']);

    $component->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->assertHasNoErrors();
});

/*
|--------------------------------------------------------------------------
| Delete Tier
|--------------------------------------------------------------------------
*/

it('can delete a tier when authorized', function () {
    $tier = TierModel::factory()->create(['name' => 'Bronze']);

    mountTierComponent($this->user)
        ->call('delete', $tier)
        ->assertHasNoErrors()
        ->assertSet('tiers', function ($tiers) use ($tier) {
            return ! $tiers->contains(function ($t) use ($tier) {
                return $t->hash === $tier->hash;
            });
        });

    expect(TierModel::count())->toBe(0);
    $this->assertSoftDeleted('tiers', ['id' => $tier->id]);
});

it('cascades delete to memberships when deleting tier', function () {
    $tier = TierModel::factory()->create();
    $user = User::factory()->create();
    $customer = Customer::factory()->create(['user_id' => $user->id]);
    $membership = Membership::create([
        'user_id' => $user->id,
        'tier_id' => $tier->id,
        'total_spending' => 100000,
    ]);

    mountTierComponent($this->user)
        ->call('delete', $tier)
        ->assertHasNoErrors();

    expect(Membership::count())->toBe(0);
    $this->assertSoftDeleted('memberships', ['id' => $membership->id]);
});

/*
|--------------------------------------------------------------------------
| Load Tiers
|--------------------------------------------------------------------------
*/

it('loads tiers with membership count', function () {
    $tier = TierModel::factory()->create();
    $user1 = User::factory()->create();
    $user2 = User::factory()->create();
    $customer1 = Customer::factory()->create(['user_id' => $user1->id]);
    $customer2 = Customer::factory()->create(['user_id' => $user2->id]);

    Membership::create(['user_id' => $user1->id, 'tier_id' => $tier->id, 'total_spending' => 100000]);
    Membership::create(['user_id' => $user2->id, 'tier_id' => $tier->id, 'total_spending' => 200000]);

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);
    expect($loadedTier->total_members)->toBe('2');
});

it('loads tiers with rewards count', function () {
    $tier = TierModel::factory()->create();
    TierReward::create(['tier_id' => $tier->id, 'name' => 'Reward 1', 'points' => 100]);
    TierReward::create(['tier_id' => $tier->id, 'name' => 'Reward 2', 'points' => 200]);
    TierReward::create(['tier_id' => $tier->id, 'name' => 'Reward 3', 'points' => 300]);

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);

    expect($loadedTier['total_rewards'])->toBe('3');
});

it('loads top member stats when tier has memberships', function () {
    $outlet = Outlet::factory()->operational()->create();
    $tier = TierModel::factory()->create(['name' => 'Gold']);
    $user1 = User::factory()->create();
    $user2 = User::factory()->create();
    $customer1 = Customer::factory()->create(['user_id' => $user1->id, 'name' => 'John Doe']);
    $customer2 = Customer::factory()->create(['user_id' => $user2->id, 'name' => 'Jane Doe']);

    // Create memberships with different total_spending
    $membership1 = Membership::create([
        'user_id' => $user1->id,
        'tier_id' => $tier->id,
        'total_spending' => 5000000, // Higher spending
    ]);

    $membership2 = Membership::create([
        'user_id' => $user2->id,
        'tier_id' => $tier->id,
        'total_spending' => 2000000, // Lower spending
    ]);

    // Create orders for user1 (top member)
    $order1 = Order::create([
        'outlet_id' => $outlet->id,
        'customer_id' => $customer1->id,
        'user_id' => $user1->id,
        'invoice_number' => 'INV-001',
        'cogs' => 50000,
        'subtotal' => 100000,
        'discount' => 10000,
        'total' => 90000,
        'ordered_at' => now(),
    ]);

    $order2 = Order::create([
        'outlet_id' => $outlet->id,
        'customer_id' => $customer1->id,
        'user_id' => $user1->id,
        'invoice_number' => 'INV-002',
        'cogs' => 25000,
        'subtotal' => 50000,
        'discount' => 5000,
        'total' => 45000,
        'ordered_at' => now(),
    ]);

    // Create order items for order1
    $brand = Brand::factory()->create();
    $perfume1 = Perfume::create([
        'brand_id' => $brand->id,
        'name' => 'Test Perfume 1',
        'slug' => 'test-perfume-1',
        'sku' => 'TP1-0001',
        'cost_price' => 10000,
        'sale_price' => 50000,
    ]);
    $product1 = Product::create([
        'name' => 'Test Product 1',
        'slug' => 'test-product-1',
        'sku' => 'PR1-0001',
        'cost_price' => 5000,
        'sale_price' => 25000,
    ]);
    $bottle1 = Bottle::factory()->create();

    OrderItem::create([
        'order_id' => $order1->id,
        'user_id' => $user1->id,
        'orderable_type' => Perfume::class,
        'orderable_id' => $perfume1->id,
        'cogs' => 10000,
        'unit_price' => 50000,
        'quantity' => 2,
    ]);

    OrderItem::create([
        'order_id' => $order1->id,
        'user_id' => $user1->id,
        'orderable_type' => Product::class,
        'orderable_id' => $product1->id,
        'cogs' => 5000,
        'unit_price' => 25000,
        'quantity' => 3,
    ]);

    OrderItem::create([
        'order_id' => $order1->id,
        'user_id' => $user1->id,
        'orderable_type' => Bottle::class,
        'orderable_id' => $bottle1->id,
        'cogs' => 3000,
        'unit_price' => 15000,
        'quantity' => 1,
    ]);

    // Create order items for order2
    $perfume2 = Perfume::create([
        'brand_id' => $brand->id,
        'name' => 'Test Perfume 2',
        'slug' => 'test-perfume-2',
        'sku' => 'TP2-0001',
        'cost_price' => 10000,
        'sale_price' => 50000,
    ]);
    OrderItem::create([
        'order_id' => $order2->id,
        'user_id' => $user1->id,
        'orderable_type' => Perfume::class,
        'orderable_id' => $perfume2->id,
        'cogs' => 10000,
        'unit_price' => 50000,
        'quantity' => 1,
    ]);

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);
    expect($loadedTier->top_member)->not->toBeNull();
    expect($loadedTier->top_member['name'])->toBe('John Doe');
    expect($loadedTier->top_member['spending'])->toContain('5.000.000');
    expect($loadedTier->top_member['total_orders'])->toBe('2');
    expect($loadedTier->top_member['items']['total_perfume'])->toBe('3');
    expect($loadedTier->top_member['items']['total_product'])->toContain('3');
    expect($loadedTier->top_member['items']['total_bottle'])->toContain('1');
});

it('shows null top member when tier has no memberships', function () {
    $tier = TierModel::factory()->create();

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);
    expect($loadedTier->top_member)->toBeNull();
});

it('reloads tiers when data:tiersUpdated event is dispatched', function () {
    $tier1 = TierModel::factory()->create(['name' => 'Bronze']);
    $component = mountTierComponent($this->user);

    expect($component->tiers)->toHaveCount(1);

    $tier2 = TierModel::factory()->create(['name' => 'Silver']);

    $component->dispatch('data:tiersUpdated')
        ->assertSet('tiers', function ($tiers) {
            return $tiers->count() === 2;
        });
});

/*
|--------------------------------------------------------------------------
| Modal Management
|--------------------------------------------------------------------------
*/

it('opens modal with correct method and title for create', function () {
    $component = mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier');

    expect($component->method)->toBe('create');
    expect($component->modalTitle)->toBe('Tambah Tier');
});

it('opens modal with correct method and title for update', function () {
    $tier = TierModel::factory()->create();

    $component = mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash);

    expect($component->method)->toBe('update');
    expect($component->modalTitle)->toBe('Ubah Tier');
    expect($component->form->name)->toBe($tier->name);
    expect($component->form->min_spending)->toBe(formatCurrencyNumber($tier->min_spending));
    expect($component->form->max_spending)->toBe($tier->max_spending ? formatCurrencyNumber($tier->max_spending) : null);
});

it('sets form data when opening update modal', function () {
    $tier = TierModel::factory()->create([
        'name' => 'Gold',
        'min_spending' => 1000000,
        'max_spending' => 5000000,
    ]);

    $component = mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash);

    expect($component->form->name)->toBe('Gold');
    expect($component->form->min_spending)->toBe('1.000.000');
    expect($component->form->max_spending)->toBe('5.000.000');
});

/*
|--------------------------------------------------------------------------
| Form Data Formatting
|--------------------------------------------------------------------------
*/

it('formats spending with currency when displaying', function () {
    $tier = TierModel::factory()->create([
        'min_spending' => 1000000,
        'max_spending' => 5000000,
    ]);

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);
    expect(formatCurrencyNumber($loadedTier->min_spending))->toContain('1.000.000');
    expect(formatCurrencyNumber($loadedTier->max_spending))->toContain('5.000.000');
});

it('handles currency formatting in form input', function () {
    mountTierComponent($this->user)
        ->call('openModal', 'create', 'Tambah Tier')
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '1.000.000')
        ->set('form.max_spending', '5.000.000')
        ->call('create')
        ->assertHasNoErrors();

    $tier = TierModel::first();
    expect($tier->min_spending)->toBe(1000000);
    expect($tier->max_spending)->toBeNull(); // ReorderTierChain makes the last tier null
});

/*
|--------------------------------------------------------------------------
| Edge Cases
|--------------------------------------------------------------------------
*/

it('handles tier with null max_spending correctly', function () {
    $tier = TierModel::factory()->create([
        'name' => 'Platinum',
        'min_spending' => 10000000,
        'max_spending' => null,
    ]);

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);
    expect(formatCurrencyNumber($loadedTier->max_spending))->not->toBeNull();
});

it('handles tier with zero min_spending', function () {
    $tier = TierModel::factory()->create([
        'name' => 'Starter',
        'min_spending' => 0,
        'max_spending' => 100000,
    ]);

    $component = mountTierComponent($this->user);

    $loadedTier = $component->tiers->firstWhere('id', $tier->id);
    expect(formatCurrencyNumber($loadedTier->min_spending))->toContain('0');
});

it('handles empty tiers list', function () {
    $component = mountTierComponent($this->user);

    expect($component->tiers)->toBeInstanceOf(Collection::class);
});

it('updates tier array correctly after update', function () {
    $tier = TierModel::factory()->create([
        'name' => 'Bronze',
        'min_spending' => 0,
        'max_spending' => 100000,
    ]);

    $component = mountTierComponent($this->user)
        ->call('openModal', 'update', 'Ubah Tier', $tier->hash)
        ->set('form.name', 'Gold')
        ->set('form.min_spending', '1.000.000')
        ->set('form.max_spending', '5.000.000')
        ->call('update');

    $updatedTier = $component->tiers->firstWhere('hash', $tier->hash);
    expect($updatedTier->name)->toBe('Gold');
    expect($updatedTier->formatted_min_spending)->toContain('1.000.000');
    expect($updatedTier->max_spending)->toBeNull(); // ReorderTierChain makes the last tier null
});