<?php

namespace App\Module\Game\Tests;

use App\Module\Game\Events\TestEvent;
use App\Module\Game\Models\Test;
use App\Module\Game\Test as TestService;
use Illuminate\Foundation\Testing\DatabaseTransactions;
use Illuminate\Support\Facades\Event;
use Tests\TestCase;

class TestEventTest extends TestCase
{
    use DatabaseTransactions;

    protected TestService $service;

    protected function setUp(): void
    {
        parent::setUp();
        $this->service = new TestService();
    }

    /**
     * 测试创建事件
     */
    public function test_created_event(): void
    {
        Event::fake();

        // 创建测试数据
        $test = $this->service->create([
            'name' => '测试数据1',
            'code' => 'TEST001',
            'description' => '这是一个测试数据',
            'data' => ['key' => 'value'],
            'status' => 1
        ]);

        // 断言事件被触发
        Event::assertDispatched(TestEvent::class, function ($event) use ($test) {
            return $event->test->id === $test->id
                && $event->type === 'created'
                && $event->test->name === '测试数据1'
                && $event->test->code === 'TEST001'
                && $event->test->status === 1;
        });
    }

    /**
     * 测试更新事件
     */
    public function test_updated_event(): void
    {
        Event::fake();

        // 创建测试数据
        $test = $this->service->create([
            'name' => '原始数据',
            'code' => 'TEST002',
            'status' => 1
        ]);

        // 更新数据
        $this->service->update($test, [
            'name' => '更新后的数据',
            'status' => 2
        ]);

        // 断言事件被触发
        Event::assertDispatched(TestEvent::class, function ($event) use ($test) {
            return $event->test->id === $test->id
                && $event->type === 'updated'
                && $event->test->name === '更新后的数据'
                && $event->test->status === 2;
        });
    }

    /**
     * 测试软删除事件
     */
    public function test_deleted_event(): void
    {
        Event::fake();

        // 创建测试数据
        $test = $this->service->create([
            'name' => '待删除数据',
            'code' => 'TEST003',
            'status' => 1
        ]);

        // 软删除数据
        $this->service->delete($test);

        // 断言事件被触发
        Event::assertDispatched(TestEvent::class, function ($event) use ($test) {
            return $event->test->id === $test->id
                && $event->type === 'deleted'
                && $event->test->name === '待删除数据'
                && $event->test->trashed();
        });
    }

    /**
     * 测试恢复事件
     */
    public function test_restored_event(): void
    {
        Event::fake();

        // 创建并软删除测试数据
        $test = $this->service->create([
            'name' => '待恢复数据',
            'code' => 'TEST004',
            'status' => 1
        ]);
        $this->service->delete($test);

        // 恢复数据
        $this->service->restore($test);

        // 断言事件被触发
        Event::assertDispatched(TestEvent::class, function ($event) use ($test) {
            return $event->test->id === $test->id
                && $event->type === 'restored'
                && $event->test->name === '待恢复数据'
                && !$event->test->trashed();
        });
    }

    /**
     * 测试强制删除事件
     */
    public function test_force_deleted_event(): void
    {
        Event::fake();

        // 创建测试数据
        $test = $this->service->create([
            'name' => '待强制删除数据',
            'code' => 'TEST005',
            'status' => 1
        ]);

        // 强制删除数据
        $this->service->forceDelete($test);

        // 断言事件被触发
        Event::assertDispatched(TestEvent::class, function ($event) use ($test) {
            return $event->test->id === $test->id
                && $event->type === 'force_deleted'
                && $event->test->name === '待强制删除数据';
        });
    }

    /**
     * 测试事件未被触发
     */
    public function test_event_not_dispatched(): void
    {
        Event::fake();

        // 断言事件未被触发
        Event::assertNotDispatched(TestEvent::class);
    }
}