bot-28/tests/Integration/ActivityCatalogTest.php

<?php

namespace Tests\Integration;

use App\Constants\HttpStatus;
use App\Http\Controllers\admin\ActivityReward as AdminActivityReward;
use App\Models\ActivityReward;
use App\Services\ActivityRewardService;
use App\Services\Sharing\ShareDefaults;
use App\Support\ActivityCatalog;
use Carbon\Carbon;
use Illuminate\Config\Repository;
use Illuminate\Database\Capsule\Manager;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Events\Dispatcher;
use Illuminate\Foundation\Application;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Routing\Router;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Facade;
use Illuminate\Support\Facades\Schema;
use Illuminate\Translation\ArrayLoader;
use Illuminate\Translation\Translator;
use Illuminate\Validation\Factory;
use Illuminate\Validation\ValidationException;
use PHPUnit\Framework\TestCase;

/** Real controllers and service validation against SQLite only; no application boot or external databases. */
class ActivityCatalogTest extends TestCase
{
    private Application $app;

    protected function setUp(): void
    {
        Facade::clearResolvedInstances();
        $this->app = new Application(dirname(__DIR__, 2));
        $this->app->instance('config', new Repository([
            'app' => ['locale' => 'zh', 'url' => 'https://activity.example.test', 'timezone' => 'Asia/Shanghai'],
        ]));
        Facade::setFacadeApplication($this->app);
        $db = new Manager($this->app);
        $db->addConnection(['driver' => 'sqlite', 'database' => ':memory:', 'prefix' => 'bot_']);
        $db->setAsGlobal(); $db->bootEloquent();
        $this->app->instance('db', $db->getDatabaseManager());
        $this->app->bind('db.schema', fn () => $db->schema());
        $translator = new Translator(new ArrayLoader(), 'zh');
        $this->app->instance('translator', $translator);
        $this->app->instance('validator', new Factory($translator, $this->app));
        $this->app->instance(\Illuminate\Contracts\Routing\ResponseFactory::class, new \Tests\Support\JsonResponseFactory());
        Request::macro('validate', function (array $rules) {
            return app('validator')->make($this->all(), $rules)->validate();
        });
        $db->schema()->create('activity_rewards', function (Blueprint $t) {
            $t->id(); $t->string('title'); $t->string('sub_title');
            $t->integer('start_time'); $t->integer('end_time'); $t->integer('status')->default(1);
            $t->integer('type')->default(1); $t->string('lang')->default('zh');
            foreach (['detail_image', 'pc_image', 'detail_banner', 'pc_banner', 'content', 'params'] as $field) {
                $t->text($field)->nullable();
            }
            $t->timestamps();
        });
        (require dirname(__DIR__, 2) . '/database/migrations/2026_10_13_120000_add_activity_eligibility_fields.php')->up();
        (require dirname(__DIR__, 2) . '/database/migrations/2026_10_14_120000_add_activity_reward_quotas.php')->up();
        $this->migration()->up();
        (require dirname(__DIR__, 2) . '/database/migrations/2026_10_28_120000_add_activity_click_behavior.php')->up();
        (require dirname(__DIR__, 2) . '/database/migrations/2026_10_28_130000_add_activity_click_position.php')->up();
        Schema::create('announcements', function (Blueprint $t) { $t->id(); $t->string('click_type'); $t->string('link', 2048)->nullable(); });
        (require dirname(__DIR__, 2) . '/database/migrations/2026_10_30_120000_add_platform_links_to_announcements_and_activities.php')->up();
        $this->request('');
    }

    protected function tearDown(): void
    {
        Carbon::setTestNow();
        DB::disconnect(); Facade::clearResolvedInstances(); parent::tearDown();
    }

    private function migration()
    {
        return require dirname(__DIR__, 2) . '/database/migrations/2026_10_25_120000_add_game_category_to_activity_rewards.php';
    }

    private function request(string $action, array $params = [], string $method = 'GET'): void
    {
        $this->app->instance('request', Request::create('/admin/ActivityReward/' . $action, $method, $params));
    }

    private function form(array $overrides = []): array
    {
        return $overrides + [
            'title' => '活动分类测试', 'sub_title' => '分类说明', 'type' => 3, 'status' => 1, 'lang' => 'zh',
            'start_time' => '2026-10-01 12:00:00', 'end_time' => '2026-12-31 12:00:00',
            'detail_image' => '/app.png', 'pc_image' => '/pc.png',
            'detail_banner' => '/app-banner.png', 'pc_banner' => '/pc-banner.png',
        ];
    }

    private function save(array $params = []): array
    {
        $this->request('submit', $this->form($params), 'POST');
        return (new AdminActivityReward())->store()->getData(true);
    }

    private function listing(array $filters = []): array
    {
        $this->request('', $filters + ['page' => 1, 'limit' => 100]);
        $result = (new AdminActivityReward())->index()->getData(true);
        $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
        return $result['data'];
    }

    private function rawActivity(array $overrides = []): int
    {
        $data = $this->form($overrides);
        $data['start_time'] = strtotime($data['start_time']);
        $data['end_time'] = strtotime($data['end_time']);
        if (isset($data['publish_platforms']) && is_array($data['publish_platforms'])) {
            $data['publish_platforms'] = json_encode($data['publish_platforms']);
        }
        return DB::table('activity_rewards')->insertGetId($data);
    }

    public function test_ordinary_activities_return_and_save_all_platforms(): void
    {
        $platforms = ['PC', 'H5', 'APP'];
        foreach ([null, [], ['H5'], ['APP']] as $legacyPlatforms) {
            $this->rawActivity(['type' => 2, 'publish_platforms' => $legacyPlatforms]);
        }
        $before = DB::table('activity_rewards')->orderBy('id')->get()->toJson();
        foreach ([[], ['platform' => 'pc'], ['platform' => 'h5']] as $filters) {
            $page = $this->listing($filters);
            $this->assertSame(4, $page['total']);
            foreach ($page['data'] as $row) {
                $this->assertSame($platforms, $row['publish_platforms']);
                $this->assertSame('全部平台', $row['platform_label']);
            }
        }
        $this->assertSame($before, DB::table('activity_rewards')->orderBy('id')->get()->toJson());

        foreach ([[], ['publish_platforms' => ['H5']]] as $config) {
            $result = $this->save(['type' => 2] + $config);
            $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
            $id = DB::table('activity_rewards')->latest('id')->value('id');
            $this->assertSame($platforms, json_decode(DB::table('activity_rewards')->where('id', $id)->value('publish_platforms'), true));
            $result = $this->save(['id' => $id, 'type' => 2, 'title' => '编辑普通活动']);
            $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
            $this->assertSame($platforms, ActivityReward::findOrFail($id)->publish_platforms);
        }

        $restricted = $this->rawActivity(['type' => 3, 'publish_platforms' => ['H5']]);
        $this->assertSame(['H5'], ActivityReward::findOrFail($restricted)->publish_platforms);
        $this->assertSame('H5', ActivityReward::findOrFail($restricted)->platform_label);
        $this->assertNotContains($restricted, array_column($this->listing(['platform' => 'pc'])['data'], 'id'));
        $unrestricted = $this->rawActivity(['type' => 3, 'publish_platforms' => []]);
        $this->assertSame('全部平台', ActivityReward::findOrFail($unrestricted)->platform_label);
    }

    public function test_ordinary_platform_migration_normalizes_only_type_two_and_is_repeatable(): void
    {
        $ids = [];
        foreach ([null, [], ['H5'], ['APP'], ['PC', 'H5', 'APP']] as $platforms) {
            $ids[] = $this->rawActivity(['type' => 2, 'publish_platforms' => $platforms]);
        }
        foreach ([1, 3, 4, 5, 6] as $type) {
            $this->rawActivity(['type' => $type, 'publish_platforms' => ['H5']]);
        }
        $others = DB::table('activity_rewards')->where('type', '!=', 2)->orderBy('id')->get()->toJson();
        $ordinary = DB::table('activity_rewards')->where('type', 2)->orderBy('id')->get()->map(function ($row) {
            unset($row->publish_platforms);
            return $row;
        })->toJson();
        $migration = require dirname(__DIR__, 2) . '/database/migrations/2026_11_07_150000_normalize_ordinary_activity_platforms.php';
        foreach ([1, 2] as $run) {
            $migration->up();
            foreach ($ids as $id) {
                $this->assertSame(['PC', 'H5', 'APP'], json_decode(DB::table('activity_rewards')->where('id', $id)->value('publish_platforms'), true));
            }
            $this->assertSame($others, DB::table('activity_rewards')->where('type', '!=', 2)->orderBy('id')->get()->toJson());
            $this->assertSame($ordinary, DB::table('activity_rewards')->where('type', 2)->orderBy('id')->get()->map(function ($row) {
                unset($row->publish_platforms);
                return $row;
            })->toJson());
        }
    }

    public function test_expiry_updates_only_ended_published_activities_and_is_repeatable(): void
    {
        Carbon::setTestNow(Carbon::parse('2026-11-05 12:00:00', 'Asia/Shanghai'));
        $expired = [];
        foreach ([1, 2, 3, 4, 5, 6] as $type) {
            $id = $this->rawActivity(['type'=>$type, 'lang'=>$type % 2 ? 'zh' : 'en']);
            DB::table('activity_rewards')->where('id', $id)->update(['end_time'=>now()->timestamp - 1, 'rewarded_count'=>2, 'budget_used'=>'12.34']);
            $expired[] = $id;
        }
        $unchanged = [];
        foreach ([[1, 0], [1, 3600], [0, -1]] as [$status, $offset]) {
            $id = $this->rawActivity(['status'=>$status]);
            DB::table('activity_rewards')->where('id', $id)->update(['end_time'=>now()->timestamp + $offset]);
            $unchanged[] = $id;
        }
        $before = DB::table('activity_rewards')->get()->keyBy('id');
        $this->assertSame(6, ActivityRewardService::expire());
        foreach ($expired as $id) {
            $expected = (array)$before[$id];
            $expected['status'] = 0;
            $expected['updated_at'] = now()->format('Y-m-d H:i:s');
            $this->assertSame($expected, (array)DB::table('activity_rewards')->where('id', $id)->first());
        }
        foreach ($unchanged as $id) $this->assertSame((array)$before[$id], (array)DB::table('activity_rewards')->where('id', $id)->first());
        $this->assertSame(0, ActivityRewardService::expire());
        Carbon::setTestNow(now()->addSecond());
        $this->assertSame(1, ActivityRewardService::expire()); // The end timestamp itself is still inclusive.
    }

    public function test_admin_list_expires_before_status_filter_count_and_pagination(): void
    {
        Carbon::setTestNow(Carbon::parse('2026-11-05 12:00:00', 'Asia/Shanghai'));
        $expired = [];
        for ($i = 0; $i < 3; ++$i) {
            $id = $this->rawActivity(['sort'=>100]);
            DB::table('activity_rewards')->where('id', $id)->update(['end_time'=>now()->timestamp - 1]);
            $expired[] = $id;
        }
        $active = [$this->rawActivity(), $this->rawActivity()];
        $manual = $this->rawActivity(['status'=>0]);
        $page = $this->listing(['status'=>0, 'page'=>1, 'limit'=>2]);
        $this->assertSame(4, $page['total']);
        $this->assertSame([$expired[2], $expired[1]], array_column($page['data'], 'id'));
        $second = $this->listing(['status'=>0, 'page'=>2, 'limit'=>2]);
        $this->assertSame(4, $second['total']);
        $this->assertSame([$expired[0], $manual], array_column($second['data'], 'id'));
        $up = $this->listing(['status'=>1]);
        $this->assertSame(2, $up['total']);
        $this->assertSame(array_reverse($active), array_column($up['data'], 'id'));
        $this->assertSame(6, $this->listing()['total']);
        $this->assertSame(0, (int)DB::table('activity_rewards')->where('id', $expired[0])->value('status'));
    }

    public function test_scheduled_sync_expires_the_legacy_catalog_without_promotion_tables(): void
    {
        Carbon::setTestNow(Carbon::parse('2026-11-05 12:00:00', 'Asia/Shanghai'));
        $id = $this->rawActivity();
        DB::table('activity_rewards')->where('id', $id)->update(['end_time'=>now()->timestamp - 1]);
        $command = new \App\Console\Commands\SyncPromotions();
        $command->setLaravel($this->app);
        $tester = new \Symfony\Component\Console\Tester\CommandTester($command);
        $this->assertSame(0, $tester->execute([]));
        $this->assertSame(0, (int)DB::table('activity_rewards')->where('id', $id)->value('status'));
        $this->assertStringContainsString('到期下架：1', $tester->getDisplay());
        $this->assertSame(0, $tester->execute([]));
        $this->assertStringContainsString('到期下架：0', $tester->getDisplay());
    }

    public function test_dual_routes_round_trip_through_admin_save_and_listing_with_cover_and_detail(): void
    {
        foreach (['cover', 'detail'] as $position) {
            $saved = $this->save(['type' => 2, 'click_type' => 'internal', 'link_pc' => '/pc/promotion?id=5', 'link_h5' => '/h5/promotion?id=5', 'click_position' => $position]);
            $this->assertSame(HttpStatus::OK, $saved['code'], $saved['msg']);
            $row = $this->listing()['data'][0]; $id = $row['id'];
            $this->assertNull($row['link']); $this->assertTrue($row['can_jump']);
            $this->assertSame('/pc/promotion?id=5', $row['link_pc']); $this->assertSame('/h5/promotion?id=5', $row['link_h5']);
            $this->assertSame($position, $row['click_position']);
            $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'title' => '仅改标题'])['code']);
            $this->assertSame('/h5/promotion?id=5', ActivityReward::findOrFail($id)->link_h5);
            $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'link_h5' => '/mobile'])['code']);
            $this->assertSame('/pc/promotion?id=5', ActivityReward::findOrFail($id)->link_pc);
            $this->assertSame('/mobile', ActivityReward::findOrFail($id)->link_h5);
            $before = DB::table('activity_rewards')->where('id', $id)->first();
            foreach (['link_pc', 'link_h5'] as $field) {
                foreach ([null, '', '//external.test', '/\\bad', 'https://example.com', ['bad'], '/' . str_repeat('x', 2048)] as $value) {
                    $this->assertSame(HttpStatus::CUSTOM_ERROR, $this->save(['id' => $id, $field => $value])['code']);
                    $this->assertEquals($before, DB::table('activity_rewards')->where('id', $id)->first());
                }
            }
            $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'click_type' => 'external', 'link' => 'https://example.com'])['code']);
            $external = ActivityReward::findOrFail($id)->toArray();
            $this->assertSame('https://example.com', $external['link']);
            $this->assertNull($external['link_pc']); $this->assertNull($external['link_h5']);
            $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'click_type' => 'none'])['code']);
            $plain = ActivityReward::findOrFail($id)->toArray();
            foreach (['link', 'link_pc', 'link_h5', 'click_position'] as $field) $this->assertNull($plain[$field]);
            $this->assertFalse($plain['can_jump']);
        }
        $this->assertSame(HttpStatus::CUSTOM_ERROR, $this->save(['click_type' => 'internal', 'link_pc' => '/pc', 'click_position' => 'cover'])['code']);
    }

    public function test_bot_member_list_resolves_the_dual_route_for_pc_h5_and_app(): void
    {
        $this->assertSame(HttpStatus::OK, $this->save(['type' => 1, 'click_type' => 'internal', 'link_pc' => '/pc/promo', 'link_h5' => '/h5/promo', 'click_position' => 'cover',
            'start_time' => '2000-01-01', 'end_time' => '2099-12-31'])['code']);
        foreach (['PC' => '/pc/promo', 'H5' => '/h5/promo', 'APP' => '/h5/promo', 'h5' => '/h5/promo', '' => '/pc/promo'] as $platform => $target) {
            $request = Request::create('/api/ActivityReward', 'GET', ['platform' => $platform === 'PC' ? 'H5' : 'PC']);
            if ($platform !== '') $request->headers->set('Platform', $platform);
            $this->app->instance('request', $request);
            $body = (new \App\Http\Controllers\api\ActivityReward())->index()->getData(true);
            $this->assertSame(0, $body['code'], $body['msg']);
            $this->assertSame($target, $body['data'][0]['link']);
            $this->assertTrue($body['data'][0]['can_jump']);
            $this->assertArrayNotHasKey('link_pc', $body['data'][0]);
            $this->assertArrayNotHasKey('link_h5', $body['data'][0]);
        }
    }

    public function test_activity_options_keep_only_f1_lottery_without_changing_financial_categories(): void
    {
        $this->rawActivity(['type' => 1]);
        $before = DB::table('activity_rewards')->get()->toJson();
        $this->request('options');
        $body = (new AdminActivityReward())->options()->getData(true);
        $this->assertSame(HttpStatus::OK, $body['code'], $body['msg']);
        $financialCategories = ['third:1' => '真人', 'third:2' => '电子', 'third:3' => '彩票',
            'third:4' => '体育', 'third:5' => '电竞', 'third:6' => '捕鱼', 'third:7' => '棋牌',
            'self:sport' => 'F1体育', 'self:lottery' => 'F1彩票'];
        $this->assertSame($financialCategories, ShareDefaults::categories());
        $this->assertCount(9, ShareDefaults::categories());
        $this->assertArrayNotHasKey('other', ShareDefaults::categories());
        $this->assertArrayNotHasKey('hot', ShareDefaults::categories());
        $activityCategories = $financialCategories;
        unset($activityCategories['third:3']);
        $this->assertSame(['hot' => '热门'] + $activityCategories + ['other' => '其他'], ActivityCatalog::gameTypes());
        $expectedGames = [];
        foreach (['hot' => '热门'] + $activityCategories + ['other' => '其他'] as $value => $label) $expectedGames[] = compact('value', 'label');
        $this->assertCount(10, $expectedGames);
        $this->assertSame($expectedGames, $body['data']['game_types']);
        $this->assertNotContains('third:3', array_column($body['data']['game_types'], 'value'));
        $this->assertNotContains('彩票', array_column($body['data']['game_types'], 'label'));
        $this->assertContains(['value' => 'self:lottery', 'label' => 'F1彩票'], $body['data']['game_types']);
        $this->assertNotContains('', array_column($body['data']['game_types'], 'value'));
        $this->assertNotContains('wallet', array_column($body['data']['game_types'], 'value'));
        $this->assertNotContains('all', array_column($body['data']['game_types'], 'value'));
        $this->assertSame([
            ['value' => 2, 'label' => '普通活动'],
            ['value' => 3, 'label' => '即充即送'],
            ['value' => 4, 'label' => '老用户召集令'],
            ['value' => 5, 'label' => 'USDT使用教学'],
            ['value' => 6, 'label' => '余额宝'],
        ], $body['data']['activity_types']);
        $this->assertNotContains(1, array_column($body['data']['activity_types'], 'value'));
        $router = new Router(new Dispatcher($this->app), $this->app);
        $this->app->instance('router', $router);
        $router->group(['prefix' => 'admin'], function () {
            require dirname(__DIR__, 2) . '/routes/admin.php';
        });
        $route = $router->getRoutes()->match(Request::create('/admin/ActivityReward/options', 'GET'));
        $this->assertSame(AdminActivityReward::class . '@options', $route->getAction('uses'));
        $this->assertContains('admin.jwt', $route->middleware());
        $this->assertContains('check.button.uri', $route->middleware());
        $this->assertSame($before, DB::table('activity_rewards')->get()->toJson());
        $this->assertSame(0, DB::table('activity_reward_recipients')->count());
    }

    public function test_removed_banners_are_not_required_saved_or_returned_and_images_remain(): void
    {
        $input = $this->form(); unset($input['detail_banner'], $input['pc_banner']);
        $this->request('submit', $input, 'POST');
        $body = (new AdminActivityReward())->store()->getData(true);
        $this->assertSame(HttpStatus::OK, $body['code']);
        $id = (int) DB::table('activity_rewards')->value('id');
        $this->assertSame('', DB::table('activity_rewards')->where('id', $id)->value('detail_banner'));
        $this->assertSame('', DB::table('activity_rewards')->where('id', $id)->value('pc_banner'));
        $this->assertSame('/app.png', DB::table('activity_rewards')->where('id', $id)->value('detail_image'));
        $this->assertSame('/pc.png', DB::table('activity_rewards')->where('id', $id)->value('pc_image'));
        DB::table('activity_rewards')->where('id', $id)->update(['detail_banner' => '/old.png', 'pc_banner' => '/old-pc.png']);
        $body = $this->save(['id' => $id, 'detail_banner' => ['ignored legacy input'], 'pc_banner' => ['ignored legacy input']]);
        $this->assertSame(HttpStatus::OK, $body['code']);
        $this->assertSame('/old.png', DB::table('activity_rewards')->where('id', $id)->value('detail_banner'));
        $this->assertSame('/old-pc.png', DB::table('activity_rewards')->where('id', $id)->value('pc_banner'));
        foreach (['detail_image', 'pc_image'] as $required) {
            $missing = $this->form(['id' => $id]); unset($missing[$required]);
            $this->request('submit', $missing, 'POST');
            $this->assertSame(HttpStatus::CUSTOM_ERROR, (new AdminActivityReward())->store()->getData(true)['code']);
        }
        foreach ([ActivityReward::findOrFail($id)->toArray(), $this->listing()['data'][0]] as $row) {
            $this->assertArrayNotHasKey('detail_banner', $row); $this->assertArrayNotHasKey('pc_banner', $row);
            $this->assertArrayHasKey('detail_image', $row); $this->assertArrayHasKey('pc_image', $row);
        }
    }

    public function test_activity_click_behavior_saves_preserves_and_clears_for_normal_and_type_two_activities(): void
    {
        $this->request('options');
        $this->assertSame(\App\Support\AnnouncementCatalog::options(\App\Support\AnnouncementCatalog::CLICKS),
            (new AdminActivityReward())->options()->getData(true)['data']['click_types']);
        foreach ([2, 3] as $type) {
            $body = $this->save(['type' => $type]);
            $this->assertSame(HttpStatus::OK, $body['code']);
            $id = (int) DB::table('activity_rewards')->latest('id')->value('id');
            $this->assertSame('none', DB::table('activity_rewards')->where('id', $id)->value('click_type'));
            foreach (['external' => 'https://example.com/promotion?from=activity', 'internal' => '/promotion/detail?id=3'] as $mode => $link) {
                $body = $this->save(['id' => $id, 'type' => $type, 'click_type' => $mode, 'link' => $link, 'click_position' => $mode === 'external' ? 'cover' : 'detail']);
                $this->assertSame(HttpStatus::OK, $body['code'], $body['msg']);
                $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'type' => $type, 'title' => '只改标题'])['code']);
                $row = collect($this->listing()['data'])->keyBy('id')->get($id);
                $this->assertSame($mode, $row['click_type']); $this->assertSame($link, $row['link']); $this->assertTrue($row['can_jump']);
                $this->assertSame($mode === 'external' ? 'cover' : 'detail', $row['click_position']);
            }
            $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'type' => $type, 'click_type' => 'none', 'link' => ['unused'], 'click_position' => ['unused']])['code']);
            $row = ActivityReward::findOrFail($id)->toArray();
            $this->assertSame('none', $row['click_type']); $this->assertNull($row['link']); $this->assertFalse($row['can_jump']);
            $this->assertNull($row['click_position']);
            $this->assertNull(DB::table('activity_rewards')->where('id', $id)->value('click_position'));
            $this->assertNull(DB::table('activity_rewards')->where('id', $id)->value('link'));
        }
    }

    public function test_nonempty_links_require_a_trigger_position_and_can_switch_position_independently(): void
    {
        $this->request('options');
        $this->assertSame([['value' => 'cover', 'label' => '活动列表封面'], ['value' => 'detail', 'label' => '活动详情按钮']],
            (new AdminActivityReward())->options()->getData(true)['data']['click_positions']);
        foreach (['external' => 'https://example.com', 'internal' => '/detail'] as $mode => $link) {
            foreach ([null, '', 'invalid', ['cover']] as $position) {
                $this->assertSame(HttpStatus::CUSTOM_ERROR, $this->save(['click_type' => $mode, 'link' => $link, 'click_position' => $position])['code']);
            }
            $this->assertSame(HttpStatus::CUSTOM_ERROR, $this->save(['click_type' => $mode, 'link' => $link])['code']);
            $this->assertSame(0, DB::table('activity_rewards')->count());
        }
        $this->save(['click_type' => 'internal', 'link' => '/detail', 'click_position' => 'cover']);
        $id = (int) DB::table('activity_rewards')->value('id');
        $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'click_position' => 'detail'])['code']);
        $row = ActivityReward::findOrFail($id)->toArray();
        $this->assertSame('detail', $row['click_position']); $this->assertSame('/detail', $row['link']);
        $this->assertSame('internal', $row['click_type']); $this->assertTrue($row['can_jump']);
    }

    public function test_trigger_position_migration_keeps_old_links_on_the_cover(): void
    {
        $migration = require dirname(__DIR__, 2) . '/database/migrations/2026_10_28_130000_add_activity_click_position.php';
        $migration->down();
        $linked = $this->rawActivity(['click_type' => 'external', 'link' => 'https://example.com']);
        $plain = $this->rawActivity();
        $before = DB::table('activity_rewards')->orderBy('id')->get();
        $migration->up();
        $this->assertSame('cover', DB::table('activity_rewards')->where('id', $linked)->value('click_position'));
        $this->assertNull(DB::table('activity_rewards')->where('id', $plain)->value('click_position'));
        foreach ($before as $old) {
            $new = DB::table('activity_rewards')->where('id', $old->id)->first();
            foreach ((array) $old as $field => $value) $this->assertSame($value, $new->$field);
        }
    }

    public function test_invalid_activity_links_do_not_modify_the_activity(): void
    {
        $this->save(['click_type' => 'internal', 'link' => '/original', 'click_position' => 'cover']);
        $id = (int) DB::table('activity_rewards')->value('id');
        $before = DB::table('activity_rewards')->where('id', $id)->first();
        foreach ([['click_type' => 'activity'], ['click_type' => null], ['click_type' => ['none']],
            ['click_type' => 'external', 'link' => null], ['click_type' => 'external', 'link' => 'javascript:alert(1)'],
            ['click_type' => 'external', 'link' => 'https://user:pass@example.com'], ['click_type' => 'external', 'link' => '/relative'],
            ['click_type' => 'internal', 'link' => '//example.com'], ['click_type' => 'internal', 'link' => '/\\evil'],
            ['click_type' => 'internal', 'link' => 'https://example.com'], ['click_type' => 'external', 'link' => ['bad']]] as $values) {
            $body = $this->save(['id' => $id] + $values + ['click_position' => 'cover']);
            $this->assertSame(HttpStatus::CUSTOM_ERROR, $body['code']);
            $this->assertEquals($before, DB::table('activity_rewards')->where('id', $id)->first());
        }
    }

    public function test_hot_category_is_saved_filtered_and_preserved_when_editing_other_fields(): void
    {
        $this->assertSame(HttpStatus::OK, $this->save(['game_category' => 'hot'])['code']);
        $id = (int) DB::table('activity_rewards')->value('id');
        $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'title' => '热门活动'])['code']);
        $row = $this->listing(['game_category' => 'hot']);
        $this->assertSame(1, $row['total']);
        $this->assertSame('hot', $row['data'][0]['game_category']);
        $this->assertSame('热门', $row['data'][0]['game_category_name']);
        $this->assertSame(0, $this->listing(['game_category' => 'other'])['total']);
    }

    public function test_new_omission_is_null_edit_omission_preserves_category_and_explicit_values_clear_it(): void
    {
        $result = $this->save();
        $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
        $id = DB::table('activity_rewards')->value('id');
        $this->assertNull(DB::table('activity_rewards')->where('id', $id)->value('game_category'));
        $this->assertNull(ActivityReward::findOrFail($id)->toArray()['game_category_name']);
        $result = $this->save(['id' => $id, 'game_category' => 'third:1', 'sort' => 37, 'publish_platforms' => ['PC']]);
        $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
        $result = $this->save(['id' => $id, 'title' => '只修改标题']);
        $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
        $row = ActivityReward::findOrFail($id)->toArray();
        $this->assertSame('third:1', $row['game_category']);
        $this->assertSame('真人', $row['game_category_name']);
        $this->assertSame('即充即送', $row['type_name']);
        $this->assertSame(37, $row['sort']);
        $this->assertSame(['PC'], $row['publish_platforms']);
        foreach ([null, ''] as $clear) {
            $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'game_category' => 'self:sport'])['code']);
            $result = $this->save(['id' => $id, 'game_category' => $clear]);
            $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
            $this->assertNull(DB::table('activity_rewards')->where('id', $id)->value('game_category'));
            $row = collect($this->listing()['data'])->keyBy('id')->get($id);
            $this->assertNull($row['game_category']);
            $this->assertNull($row['game_category_name']);
        }
        $this->assertSame(1, DB::table('activity_rewards')->count());
        $this->assertSame(0, DB::table('activity_reward_recipients')->count());
    }

    public function test_every_game_category_is_saved_and_named_for_normal_and_type_two_activities(): void
    {
        foreach ([2 => '普通活动', 3 => '即充即送'] as $type => $typeName) {
            foreach (ActivityCatalog::gameTypes() as $category => $label) {
                $result = $this->save(['type' => $type, 'game_category' => $category]);
                $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
                $row = ActivityReward::query()->latest('id')->firstOrFail()->toArray();
                $this->assertSame($type, (int) $row['type']);
                $this->assertSame($typeName, $row['type_name']);
                $this->assertSame($category, $row['game_category']);
                $this->assertSame($label, $row['game_category_name']);
            }
        }
        $this->assertSame(20, $this->listing()['total']);
    }

    public function test_other_category_is_preserved_on_omitted_edit_and_can_be_cleared_for_type_two_and_three(): void
    {
        foreach ([2, 3] as $type) {
            $result = $this->save(['type' => $type, 'game_category' => 'other']);
            $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
            $id = DB::table('activity_rewards')->latest('id')->value('id');
            $this->assertSame('other', DB::table('activity_rewards')->where('id', $id)->value('game_category'));
            $result = $this->save(['id' => $id, 'type' => $type, 'title' => '编辑其他分类活动']);
            $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
            $page = $this->listing(['game_category' => 'other', 'type' => (string) $type]);
            $this->assertSame(1, $page['total']);
            $this->assertSame($id, $page['data'][0]['id']);
            $this->assertSame('other', $page['data'][0]['game_category']);
            $this->assertSame('其他', $page['data'][0]['game_category_name']);
            $this->assertSame('其他', ActivityReward::findOrFail($id)->toArray()['game_category_name']);
            foreach ([null, ''] as $clear) {
                $this->assertSame(HttpStatus::OK, $this->save(['id' => $id, 'type' => $type, 'game_category' => 'other'])['code']);
                $result = $this->save(['id' => $id, 'type' => $type, 'game_category' => $clear]);
                $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
                $this->assertNull(DB::table('activity_rewards')->where('id', $id)->value('game_category'));
                $row = collect($this->listing()['data'])->keyBy('id')->get($id);
                $this->assertNull($row['game_category']);
                $this->assertNull($row['game_category_name']);
                $this->assertSame(0, $this->listing(['game_category' => 'other', 'type' => (string) $type])['total']);
            }
        }
        $this->assertSame(2, DB::table('activity_rewards')->count());
        $this->assertSame(0, DB::table('activity_reward_recipients')->count());
    }

    public function test_invalid_categories_are_rejected_by_controller_and_service_even_for_type_two(): void
    {
        $id = $this->rawActivity(['game_category' => 'third:1']);
        $before = DB::table('activity_rewards')->get()->toJson();
        foreach (['unknown', 'third:3', 'third:8', 'wallet', 'all', '其他', '1', 1, ['third:1']] as $category) {
            foreach ([2, 3] as $type) {
                $result = $this->save(['id' => $id, 'type' => $type, 'title' => '不应保存', 'game_category' => $category]);
                $this->assertSame(HttpStatus::CUSTOM_ERROR, $result['code']);
                try {
                    ActivityRewardService::submit($this->form(['id' => $id, 'type' => $type, 'game_category' => $category]));
                    $this->fail('Expected direct service category validation');
                } catch (ValidationException $e) {
                    $this->assertArrayHasKey('game_category', $e->errors());
                }
            }
            $this->request('', ['page' => 1, 'limit' => 10, 'game_category' => $category]);
            $result = (new AdminActivityReward())->index()->getData(true);
            $this->assertSame(HttpStatus::CUSTOM_ERROR, $result['code']);
        }
        $this->assertSame($before, DB::table('activity_rewards')->get()->toJson());
    }

    public function test_combined_category_filters_apply_before_count_and_pagination_with_type_two_platform_exception(): void
    {
        $base = ['title' => '目标活动', 'type' => 3, 'status' => 0, 'lang' => 'zh', 'game_category' => 'third:1', 'publish_platforms' => ['PC']];
        $matching = [];
        for ($i = 1; $i <= 5; $i++) $matching[] = $this->rawActivity(['sort' => $i] + $base);
        foreach ([['game_category' => 'third:2'], ['publish_platforms' => ['H5']], ['status' => 1],
            ['lang' => 'en'], ['title' => '其他活动'], ['type' => 4], ['game_category' => null]] as $extra) {
            $this->rawActivity($extra + ['sort' => 100] + $base);
        }
        $ordinary = $this->rawActivity(['type' => 2, 'publish_platforms' => ['H5'], 'sort' => 101] + $base);
        $before = DB::table('activity_rewards')->orderBy('id')->get()->toJson();
        $matching = array_reverse($matching);
        $filters = ['title' => '目标', 'type' => '3', 'status' => '0', 'lang' => 'zh', 'platform' => 'pc', 'game_category' => 'third:1', 'limit' => 2];
        $seen = [];
        foreach ([1, 2, 3, 4] as $page) {
            $result = $this->listing($filters + ['page' => $page]);
            $this->assertSame(5, $result['total']);
            $this->assertSame(array_slice($matching, ($page - 1) * 2, 2), array_column($result['data'], 'id'));
            foreach ($result['data'] as $row) {
                $this->assertSame('third:1', $row['game_category']);
                $this->assertSame('真人', $row['game_category_name']);
                $this->assertSame('即充即送', $row['type_name']);
            }
            $seen = array_merge($seen, array_column($result['data'], 'id'));
        }
        $this->assertSame($matching, $seen);
        $ordinaryPage = $this->listing(['type' => '2', 'platform' => 'pc', 'status' => '0', 'lang' => 'zh', 'game_category' => 'third:1']);
        $this->assertSame(1, $ordinaryPage['total']);
        $this->assertSame([$ordinary], array_column($ordinaryPage['data'], 'id'));
        $this->assertSame('普通活动', $ordinaryPage['data'][0]['type_name']);
        $all = $this->listing();
        foreach ([null, ''] as $category) {
            $result = $this->listing(['game_category' => $category]);
            $this->assertSame($all['total'], $result['total']);
            $this->assertSame(array_column($all['data'], 'id'), array_column($result['data'], 'id'));
        }
        $this->assertSame($before, DB::table('activity_rewards')->orderBy('id')->get()->toJson());
    }

    public function test_other_category_filter_combines_with_existing_filters_before_count_and_pagination(): void
    {
        $base = ['title' => '目标其他活动', 'type' => 3, 'status' => 0, 'lang' => 'zh', 'game_category' => 'other', 'publish_platforms' => ['H5']];
        $matching = [];
        for ($i = 1; $i <= 5; $i++) $matching[] = $this->rawActivity(['sort' => $i] + $base);
        foreach ([['game_category' => 'third:1'], ['game_category' => null], ['publish_platforms' => ['PC']],
            ['status' => 1], ['lang' => 'en'], ['title' => '不同标题'], ['type' => 4]] as $extra) {
            $this->rawActivity($extra + ['sort' => 100] + $base);
        }
        $before = DB::table('activity_rewards')->orderBy('id')->get()->toJson();
        $matching = array_reverse($matching);
        $filters = ['title' => '目标', 'type' => '3', 'status' => '0', 'lang' => 'zh', 'platform' => 'h5', 'game_category' => 'other', 'limit' => 2];
        $seen = [];
        foreach ([1, 2, 3, 4] as $page) {
            $result = $this->listing($filters + ['page' => $page]);
            $this->assertSame(5, $result['total']);
            $this->assertSame(array_slice($matching, ($page - 1) * 2, 2), array_column($result['data'], 'id'));
            foreach ($result['data'] as $row) {
                $this->assertSame('other', $row['game_category']);
                $this->assertSame('其他', $row['game_category_name']);
            }
            $seen = array_merge($seen, array_column($result['data'], 'id'));
        }
        $this->assertSame($matching, $seen);
        $all = $this->listing();
        $this->assertSame(12, $all['total']);
        foreach ([null, ''] as $category) {
            $page = $this->listing(['game_category' => $category]);
            $this->assertSame($all['total'], $page['total']);
            $this->assertSame(array_column($all['data'], 'id'), array_column($page['data'], 'id'));
        }
        $defaultRows = array_filter($all['data'], fn ($row) => $row['game_category'] === null);
        $this->assertCount(1, $defaultRows);
        $this->assertNull(array_values($defaultRows)[0]['game_category_name']);
        $this->assertSame($before, DB::table('activity_rewards')->orderBy('id')->get()->toJson());
    }

    public function test_legacy_type_one_remains_readable_and_editable_without_becoming_an_option(): void
    {
        $result = $this->save(['type' => 1]);
        $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
        $id = DB::table('activity_rewards')->value('id');
        DB::table('activity_rewards')->where('id', $id)->update(['budget_used' => '12.34', 'rewarded_count' => 2]);
        $result = $this->save(['id' => $id, 'type' => 1, 'title' => '旧类型活动', 'game_category' => 'self:lottery']);
        $this->assertSame(HttpStatus::OK, $result['code'], $result['msg']);
        $row = $this->listing(['type' => '1'])['data'][0];
        $this->assertSame(1, (int) $row['type']);
        $this->assertNull($row['type_name']);
        $this->assertSame('self:lottery', $row['game_category']);
        $this->assertSame('F1彩票', $row['game_category_name']);
        $this->assertSame('12.34', $row['budget_used']);
        $this->assertSame(2, $row['rewarded_count']);
        $legacy = $this->rawActivity(['type' => 99, 'game_category' => null]);
        $this->assertNull(ActivityReward::findOrFail($legacy)->toArray()['type_name']);
        $this->request('options');
        $options = (new AdminActivityReward())->options()->getData(true)['data']['activity_types'];
        $this->assertSame([2, 3, 4, 5, 6], array_column($options, 'value'));
    }

    public function test_lottery_merge_migration_preserves_activities_and_their_business_settings(): void
    {
        $ordinary = $this->rawActivity(['type' => 2, 'game_category' => 'third:3', 'params' => '{"reward_ratio":5,"game_category":"third:3"}']);
        $promotion = $this->rawActivity(['type' => 3, 'game_category' => 'third:3', 'sort' => 21, 'show_ineligible' => false]);
        $existingF1 = $this->rawActivity(['game_category' => 'self:lottery']);
        $unrelated = $this->rawActivity(['game_category' => 'third:1']);
        $before = DB::table('activity_rewards')->orderBy('id')->get()->keyBy('id');
        $migration = require dirname(__DIR__, 2) . '/database/migrations/2026_11_02_120000_merge_activity_lottery_category.php';
        $migration->up();
        $this->assertSame(0, DB::table('activity_rewards')->where('game_category', 'third:3')->count());
        foreach ([$ordinary, $promotion, $existingF1, $unrelated] as $id) {
            $expected = (array) $before[$id];
            if (in_array($id, [$ordinary, $promotion], true)) $expected['game_category'] = 'self:lottery';
            $this->assertSame($expected, (array) DB::table('activity_rewards')->where('id', $id)->first());
        }
        $result = $this->listing(['game_category' => 'self:lottery']);
        $this->assertSame(3, $result['total']);
        foreach ($result['data'] as $row) $this->assertSame('F1彩票', $row['game_category_name']);
        $this->assertSame(HttpStatus::OK, $this->save(['game_category' => 'self:lottery'])['code']);
        $this->assertSame(4, $this->listing(['game_category' => 'self:lottery'])['total']);
        $snapshot = DB::table('activity_rewards')->orderBy('id')->get()->toJson();
        $migration->up(); $migration->down();
        $this->assertSame($snapshot, DB::table('activity_rewards')->orderBy('id')->get()->toJson());
    }

    public function test_category_migration_adds_nullable_index_without_changing_existing_rows_and_rolls_back(): void
    {
        $this->migration()->down();
        $this->assertFalse(Schema::hasColumn('activity_rewards', 'game_category'));
        $id = $this->rawActivity(['type' => 1, 'sort' => 19]);
        $before = (array) DB::table('activity_rewards')->find($id);
        $this->migration()->up();
        $after = (array) DB::table('activity_rewards')->find($id);
        $this->assertNull($after['game_category']);
        unset($after['game_category']);
        $this->assertSame($before, $after);
        $column = collect(DB::select('PRAGMA table_info(bot_activity_rewards)'))->firstWhere('name', 'game_category');
        $this->assertSame(0, (int) $column->notnull);
        $indexes = DB::select("SELECT sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ?", ['bot_activity_rewards']);
        $this->assertNotEmpty(array_filter($indexes, fn ($index) => str_contains((string) $index->sql, 'game_category')));
        $newId = $this->rawActivity();
        $this->assertNull(DB::table('activity_rewards')->where('id', $newId)->value('game_category'));
        $this->migration()->down();
        $this->assertFalse(Schema::hasColumn('activity_rewards', 'game_category'));
        $this->assertTrue(Schema::hasColumn('activity_rewards', 'reward_quota'));
        $this->assertSame($before, (array) DB::table('activity_rewards')->find($id));
        $this->assertSame(2, DB::table('activity_rewards')->count());
    }
}