bot-28/tests/Integration/ReportingTest.php

<?php

namespace Tests\Integration;

use App\Services\Reporting\ReportAdmin;
use App\Services\Reporting\ReportReader;
use App\Services\Reporting\ReportSync;
use App\Services\Sharing\ShareDefaults;
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 source adapters, financial reconciliation, filters and aggregation; isolated SQLite only. */
class ReportingTest extends TestCase
{
    private Application $app;
    private ReportSync $sync;
    private ReportReader $reader;
    private ReportAdmin $admin;

    protected function setUp(): void
    {
        Carbon::setTestNow(Carbon::parse('2026-10-26 16:00:00', 'Asia/Shanghai'));
        Facade::clearResolvedInstances(); $this->app = new Application(dirname(__DIR__, 2));
        $this->app->instance('config', new Repository(['app' => ['locale' => 'zh', 'timezone' => 'Asia/Shanghai'], 'third_game' => ['currency' => 'CNY']])); Facade::setFacadeApplication($this->app);
        $db = new Manager($this->app); $db->addConnection(['driver' => 'sqlite', 'database' => ':memory:', 'prefix' => 'bot_']);
        $db->setEventDispatcher(new Dispatcher($this->app)); $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['validator']->setPresenceVerifier(new \Illuminate\Validation\DatabasePresenceVerifier($db->getDatabaseManager()));
        $this->app->instance('log', new \Psr\Log\NullLogger()); $this->app->instance(\Illuminate\Contracts\Routing\ResponseFactory::class, new class {
            public function json($data, $status = 200, $headers = [], $options = 0) { return new JsonResponse($data, $status, $headers, $options); }
        });
        Request::macro('validate', function ($rules) { return app('validator')->make($this->all(), $rules)->validate(); });
        $request = Request::create('/admin/reporting/summary'); $request->user = (object) ['id' => 1, 'username' => 'admin']; $this->app->instance('request', $request);
        foreach ([
            'users' => 'id INTEGER PRIMARY KEY,member_id TEXT,user_id TEXT,username TEXT,first_name TEXT,agent_id INTEGER,"from" INTEGER,created_at TEXT',
            'agents' => 'id INTEGER PRIMARY KEY,username TEXT',
            'share_members' => 'user_id INTEGER PRIMARY KEY,parent_user_id INTEGER,bound_at TEXT',
            'share_policies' => 'id INTEGER PRIMARY KEY AUTOINCREMENT,effective_date TEXT,enabled INTEGER DEFAULT 0,benefit_enabled INTEGER DEFAULT 0,valid_member_min_deposit TEXT,valid_member_min_effective_bet TEXT,rules TEXT',
            'share_system_state' => '"key" TEXT PRIMARY KEY,value TEXT',
            'share_bet_facts' => 'id INTEGER PRIMARY KEY AUTOINCREMENT,user_id INTEGER,member_id TEXT,category TEXT,bet_date TEXT,effective_amount TEXT,settled INTEGER DEFAULT 1,voided INTEGER DEFAULT 0,currency TEXT DEFAULT "CNY"',
            'share_accounts' => 'user_id INTEGER PRIMARY KEY,earned_amount TEXT DEFAULT "0",paid_amount TEXT DEFAULT "0",reserved_amount TEXT DEFAULT "0"',
            'share_settlements' => 'id INTEGER PRIMARY KEY,user_id INTEGER,bet_date TEXT,category TEXT,direct_commission TEXT,indirect_commission TEXT',
            'balance_logs' => 'id INTEGER PRIMARY KEY AUTOINCREMENT,member_id TEXT,amount TEXT,change_type TEXT,related_id INTEGER,type INTEGER DEFAULT 1,created_at TEXT,updated_at TEXT,before_balance TEXT,after_balance TEXT,remark TEXT',
            'withdraws' => 'id INTEGER PRIMARY KEY,member_id TEXT,amount TEXT,to_account TEXT,service_charge TEXT,exchange_rate TEXT,status INTEGER,created_at TEXT,updated_at TEXT',
            'payment_orders' => 'id INTEGER PRIMARY KEY,member_id TEXT,type INTEGER,amount TEXT,fee TEXT,status INTEGER,created_at TEXT,updated_at TEXT',
            'bets' => 'id INTEGER PRIMARY KEY,member_id TEXT,amount TEXT,profit TEXT,status INTEGER,created_at TEXT,updated_at TEXT',
            'share_claims' => 'id INTEGER PRIMARY KEY,user_id INTEGER,status TEXT,credited_log_id INTEGER',
            'share_ledger' => 'id INTEGER PRIMARY KEY,user_id INTEGER,amount TEXT,bet_date TEXT,category TEXT,created_at TEXT',
            'agent_balance_logs' => 'id INTEGER PRIMARY KEY,agent_id INTEGER,type TEXT,amount TEXT,reference_type TEXT,reference_id INTEGER,created_at TEXT',
            'agent_rebate_records' => 'id INTEGER PRIMARY KEY,agent_id INTEGER,platform TEXT,game_type INTEGER,settlement_date TEXT,flow_commission TEXT,profit_commission TEXT,flow_status TEXT,profit_status TEXT,created_at TEXT,updated_at TEXT',
            'operation_audits' => 'id INTEGER PRIMARY KEY AUTOINCREMENT,resource_type TEXT,resource_id INTEGER,action TEXT,changes TEXT,operator_id INTEGER,operator_name TEXT,created_at TEXT DEFAULT CURRENT_TIMESTAMP',
        ] as $name => $columns) DB::statement('CREATE TABLE bot_' . $name . ' (' . $columns . ')');
        (require dirname(__DIR__, 2) . '/database/migrations/2026_10_26_140000_create_reporting_tables.php')->up();
        DB::table('reporting_settings')->where('id', 1)->update(['activity_started_at' => '2026-10-25 00:00:00']);
        DB::table('share_policies')->insert(['effective_date' => '2026-10-01', 'valid_member_min_deposit' => '20', 'valid_member_min_effective_bet' => '100', 'rules' => json_encode(ShareDefaults::rules())]);
        DB::table('share_system_state')->insert(['key' => 'initialized_at', 'value' => '2026-10-01 00:00:00']);
        DB::table('agents')->insert([['id' => 10, 'username' => 'agent10'], ['id' => 20, 'username' => 'agent20']]);
        foreach ([[1, '100', null, 1], [2, '200', 10, 1], [3, '300', 20, 1], [4, '400', 10, 2], [5, '500', null, -1]] as [$id, $member, $agent, $from]) {
            DB::table('users')->insert(['id' => $id, 'member_id' => $member, 'user_id' => 'u' . $member, 'username' => 'member' . $id, 'first_name' => '昵称' . $id, 'agent_id' => $agent, 'from' => $from, 'created_at' => '2026-10-01 00:00:00']);
            DB::table('share_members')->insert(['user_id' => $id, 'parent_user_id' => in_array($id, [2, 3]) ? 1 : null, 'bound_at' => '2026-10-01 00:00:00']);
        }
        $this->sync = new ReportSync(); $this->reader = new ReportReader(); $this->admin = new ReportAdmin();
        $this->ready();
    }
    protected function tearDown(): void { Carbon::setTestNow(); DB::disconnect(); Facade::clearResolvedInstances(); parent::tearDown(); }
    private function today(array $filters = []): array { return $filters + ['start_date' => now('Asia/Shanghai')->toDateString(), 'end_date' => now('Asia/Shanghai')->toDateString()]; }
    private function ready(): void { DB::table('reporting_sync_state')->updateOrInsert(['source' => '__run__'], ['state' => '{"complete":true}', 'updated_at' => now()]); }
    private function context(string $source, int $id, int $user = 2, string $platform = 'H5', ?string $success = null): void
    {
        DB::table('reporting_contexts')->insert(['source' => $source, 'source_id' => (string) $id, 'user_id' => $user, 'agent_id' => $user === 2 ? 10 : null,
            'inviter_id' => $user === 2 ? 1 : null, 'client_platform' => $platform, 'occurred_at' => '2026-10-26 09:00:00', 'succeeded_at' => $success]);
    }
    private function bet(int $id = 1, array $extra = []): void
    {
        DB::table('bets')->insert($extra + ['id' => $id, 'member_id' => '200', 'amount' => '100', 'profit' => '60', 'status' => 2, 'created_at' => '2026-10-26 09:00:00', 'updated_at' => '2026-10-26 10:00:00']);
        $this->context('bets', $id, ($extra['member_id'] ?? '200') === '500' ? 5 : 2, 'H5', '2026-10-26 10:00:00'); $this->sync->publish('bets', $id);
    }
    private function deposit(int $id = 1, string $amount = '1000', string $member = '200'): int
    {
        DB::table('balance_logs')->insert(['id' => $id, 'member_id' => $member, 'amount' => $amount, 'change_type' => '充值', 'created_at' => '2026-10-26 09:00:00', 'updated_at' => '2026-10-26 09:00:00']);
        $this->sync->publish('balance_logs', $id); return (int) DB::table('reporting_events')->where('source', 'balance_logs')->where('source_id', (string) $id)->value('id');
    }
    private function verify(int $id, string $amount = '1000', string $fee = '2'): void
    {
        $this->admin->reconcile(['event_id' => $id, 'actual_amount' => $amount, 'external_fee' => $fee, 'occurred_at' => '2026-10-26 10:00:00', 'currency' => 'CNY', 'evidence' => '到账凭据#' . $id]);
    }
    private function qualificationFact(string $amount = '100', string $date = '2026-10-26', int $user = 2, array $extra = []): int
    {
        return DB::table('share_bet_facts')->insertGetId($extra + ['user_id' => $user, 'member_id' => (string) ($user * 100),
            'category' => 'third:2', 'bet_date' => $date, 'effective_amount' => $amount]);
    }

    public function test_source_projection_is_idempotent_and_cross_day_metrics_use_actual_events(): void
    {
        $this->bet(1, ['created_at' => '2026-10-25 23:00:00']); $this->sync->publish('bets', 1);
        $this->assertSame(1, DB::table('reporting_orders')->count());
        $row = $this->reader->summary($this->today())['summary'];
        $this->assertSame('0.0000000000', $row['bet_amount']); $this->assertSame('100.0000000000', $row['settled_bet_amount']);
        $this->assertSame('60.0000000000', $row['payout_amount']); $this->assertSame('40.0000000000', $row['game_gross_profit']);
        $this->assertSame('40.0000000000', $row['company_profit']);
        $yesterday = $this->reader->summary(['start_date' => '2026-10-25', 'end_date' => '2026-10-25'])['summary'];
        $this->assertSame('100.0000000000', $yesterday['bet_amount']); $this->assertSame('0.0000000000', $yesterday['payout_amount']);
    }

    public function test_missing_fees_and_success_time_never_produce_fabricated_net_values(): void
    {
        $event = $this->deposit(); $this->bet();
        $row = $this->reader->summary($this->today())['summary']; $this->assertNull($row['net_cash_flow']); $this->assertNull($row['company_profit']);
        $this->assertSame(1, $row['quality']['unverified_fees']); $this->assertSame('1000.0000000000', $row['deposit_amount']);
        $this->verify($event); $row = $this->reader->summary($this->today())['summary'];
        $this->assertSame('998.0000000000', $row['net_cash_flow']); $this->assertSame('38.0000000000', $row['company_profit']);
        $before = DB::table('balance_logs')->get()->toArray(); $this->verify($event, '1000', '3'); $this->sync->publish('balance_logs', 1);
        $this->assertSame(1, DB::table('reporting_reconciliations')->count()); $this->assertEquals($before, DB::table('balance_logs')->get()->toArray());
        $this->assertSame('997.0000000000', $this->reader->summary($this->today())['summary']['net_cash_flow']);
    }

    public function test_chain_withdraw_uses_recipient_amount_and_customer_fee_is_not_an_expense(): void
    {
        DB::table('withdraws')->insert(['id' => 1, 'member_id' => '200', 'amount' => '100', 'to_account' => '98', 'service_charge' => '2', 'exchange_rate' => '7', 'status' => 1, 'created_at' => '2026-10-25 08:00:00', 'updated_at' => '2026-10-26 10:00:00']);
        $this->sync->publish('withdraws', 1); $row = $this->reader->summary($this->today())['summary'];
        $this->assertSame(1, $row['quality']['missing_time']); $this->assertNull($row['net_cash_flow']);
        $event = (int) DB::table('reporting_events')->value('id'); $this->verify($event, '686', '1');
        $row = $this->reader->summary($this->today())['summary'];
        $this->assertSame('686.0000000000', $row['withdraw_amount']); $this->assertSame('14.0000000000', $row['customer_fee_income']);
        $this->assertSame('1.0000000000', $row['withdraw_fee']); $this->assertSame('-687.0000000000', $row['net_cash_flow']);
        DB::table('withdraws')->where('id', 1)->update(['status' => 2]); $result = $this->sync->sync(true);
        $this->assertSame(1, $result['errors']); $this->assertNull($this->reader->summary($this->today())['summary']['net_cash_flow']);
        $this->verify($event, '0', '1'); $this->sync->sync(true);
        $this->assertSame('0.0000000000', $this->reader->summary($this->today())['summary']['withdraw_amount']);
    }

    public function test_real_member_agent_sharing_overlap_is_not_added_twice_and_details_are_direct(): void
    {
        $this->bet(); $event = $this->deposit(); $this->verify($event);
        foreach (['business', 'promotion', 'sharing'] as $type) {
            $row = $this->reader->summary(['report_type' => $type])['summary']; $this->assertSame('100.0000000000', $row['bet_amount']);
            $this->assertSame('1000.0000000000', $row['deposit_amount']);
        }
        $this->assertSame('2', $this->reader->details($this->today())['data'][0]['group_id']);
        $this->assertSame('10', $this->reader->details(['report_type' => 'promotion'])['data'][0]['group_id']);
        $this->assertSame('1', $this->reader->details(['report_type' => 'sharing'])['data'][0]['group_id']);
        $category = $this->reader->summary($this->today())['categories'][8]; $this->assertNull($category['deposit_amount']); $this->assertNull($category['company_profit']);
        $this->assertSame('100.0000000000', $category['bet_amount']);
    }

    public function test_valid_members_use_both_sharing_thresholds_inclusively(): void
    {
        $this->bet(); $this->deposit(1, '19.99'); $fact = $this->qualificationFact('100');
        $this->assertSame(0, $this->reader->summary($this->today())['summary']['valid_member_count']);
        DB::table('balance_logs')->where('id', 1)->update(['amount' => '20']);
        DB::table('share_bet_facts')->where('id', $fact)->update(['effective_amount' => '99.99']);
        $this->assertSame(0, $this->reader->summary($this->today())['summary']['valid_member_count']);
        DB::table('share_bet_facts')->where('id', $fact)->update(['effective_amount' => '100']);
        $report = $this->reader->summary($this->today());
        $this->assertSame(1, $report['summary']['valid_member_count']);
        $this->assertSame('20.0000000000', $report['valid_deposit_min']);
        $this->assertSame('100.0000000000', $report['valid_effective_bet_min']);
        $this->assertSame(['id' => 1, 'effective_date' => '2026-10-01', 'min_deposit' => '20.0000000000',
            'min_effective_bet' => '100.0000000000', 'date' => '2026-10-26', 'available' => true, 'unavailable_reasons' => []], $report['valid_member_policy']);
        // Presentation switches and the retired report-only value do not change qualification.
        DB::table('reporting_settings')->where('id', 1)->update(['valid_deposit_min' => '9999']);
        DB::table('share_policies')->update(['enabled' => 0, 'benefit_enabled' => 0]);
        $this->assertSame(1, $this->reader->summary($this->today())['summary']['valid_member_count']);
    }

    public function test_qualification_is_cumulative_before_start_and_independent_of_report_filters_and_payment_verification(): void
    {
        $this->bet(); $this->bet(2, ['member_id' => '500']);
        DB::table('balance_logs')->insert([
            ['member_id' => '200', 'type' => 1, 'amount' => '8', 'change_type' => '充值', 'created_at' => '2026-10-01 10:00:00'],
            ['member_id' => '200', 'type' => 1, 'amount' => '12', 'change_type' => '三方充值', 'created_at' => '2026-10-25 10:00:00'],
        ]);
        $this->qualificationFact('50', '2026-10-01'); $this->qualificationFact('50', '2026-10-25', 2, ['category' => 'self:sport']);
        // Report events and their manual reconciliation are not the sharing deposit source.
        $event = $this->deposit(10, '1'); $this->verify($event, '0', '0');
        $input = ['platform' => 'H5', 'category' => 'self:lottery', 'settlement_status' => 'settled'];
        $report = $this->reader->summary($input);
        $this->assertSame(1, $report['summary']['valid_member_count']);
        $this->assertSame(1, collect($report['categories'])->keyBy('group_id')['self:lottery']['valid_member_count']);
        $this->assertSame(1, $this->reader->details($input + ['member_account' => 'member2'])['data'][0]['valid_member_count']);
        $this->assertSame(1, $this->reader->details($input + ['report_type' => 'promotion', 'agent_account' => 'agent10'])['data'][0]['valid_member_count']);
        $this->assertSame(1, $this->reader->details($input + ['report_type' => 'sharing', 'inviter_account' => 'member1'])['data'][0]['valid_member_count']);
        $this->assertSame(0, $this->reader->summary(['platform' => 'PC'])['summary']['valid_member_count']);
    }

    public function test_qualification_excludes_future_non_deposit_and_ineligible_facts(): void
    {
        $this->bet();
        foreach ([[1, '充值', '19', '2026-10-26 23:59:59'], [1, '充值', '1000', '2026-10-27 00:00:00'],
            [2, '充值', '1000', '2026-10-25 10:00:00'], [1, '人工加款', '1000', '2026-10-25 10:00:00'],
            [1, '充值', '-1000', '2026-10-25 10:00:00']] as [$type, $kind, $amount, $at]) {
            DB::table('balance_logs')->insert(['member_id' => '200', 'type' => $type, 'change_type' => $kind, 'amount' => $amount, 'created_at' => $at]);
        }
        $fact = $this->qualificationFact('99');
        $this->qualificationFact('1000', '2026-10-27');
        $this->qualificationFact('1000', '2026-10-25', 2, ['settled' => 0]);
        $this->qualificationFact('1000', '2026-10-25', 2, ['voided' => 1]);
        $this->qualificationFact('1000', '2026-10-25', 2, ['currency' => 'USDT']);
        $this->assertSame(0, $this->reader->summary($this->today())['summary']['valid_member_count']);
        DB::table('balance_logs')->insert(['member_id' => '200', 'type' => 1, 'change_type' => '三方充值', 'amount' => '1', 'created_at' => '2026-10-26 23:59:59']);
        $this->assertSame(0, $this->reader->summary($this->today())['summary']['valid_member_count']);
        DB::table('share_bet_facts')->where('id', $fact)->update(['effective_amount' => '100']);
        $this->assertSame(1, $this->reader->summary($this->today())['summary']['valid_member_count']);
    }

    public function test_pending_sharing_policy_never_applies_before_its_effective_date(): void
    {
        $this->bet(); $this->deposit(1, '20'); $this->qualificationFact();
        DB::table('share_policies')->insert(['effective_date' => '2026-10-27', 'valid_member_min_deposit' => '200', 'valid_member_min_effective_bet' => '1000', 'rules' => '{}']);
        $report = $this->reader->summary($this->today());
        $this->assertSame(1, $report['summary']['valid_member_count']); $this->assertSame(1, $report['valid_member_policy']['id']);
        $this->assertSame('20.0000000000', $this->admin->settings()['valid_deposit_min']);
        Carbon::setTestNow(Carbon::parse('2026-10-27 16:00:00', 'Asia/Shanghai'));
        $report = $this->reader->summary(['start_date' => '2026-10-26', 'end_date' => '2026-10-27']);
        $this->assertSame(0, $report['summary']['valid_member_count']); $this->assertSame(2, $report['valid_member_policy']['id']);
        $historical = $this->reader->summary(['start_date' => '2026-10-26', 'end_date' => '2026-10-26']);
        $this->assertSame(1, $historical['summary']['valid_member_count']); $this->assertSame(1, $historical['valid_member_policy']['id']);
    }

    public function test_zero_sharing_thresholds_are_preserved_and_candidate_population_is_unchanged(): void
    {
        $this->bet(1, ['status' => 1, 'profit' => '0']);
        DB::table('share_policies')->update(['valid_member_min_deposit' => '0', 'valid_member_min_effective_bet' => '0']);
        $report = $this->reader->summary($this->today());
        $this->assertSame(1, $report['summary']['valid_member_count']); $this->assertSame(4, $report['summary']['member_count']);
        $this->assertSame('0.0000000000', $report['valid_deposit_min']); $this->assertSame('0.0000000000', $report['valid_effective_bet_min']);
        $this->assertSame(0, $this->reader->summary(['settlement_status' => 'settled'])['summary']['valid_member_count']);
    }

    public function test_missing_policy_threshold_and_sharing_data_produce_null_not_an_independent_default(): void
    {
        $this->bet(); $this->deposit(); $this->qualificationFact();
        DB::table('share_policies')->update(['valid_member_min_effective_bet' => null]);
        $report = $this->reader->summary($this->today());
        $this->assertNull($report['summary']['valid_member_count']); $this->assertNull($report['valid_effective_bet_min']);
        $this->assertFalse($report['valid_member_policy']['available']);
        $this->assertContains('incomplete_qualification_policy', $report['valid_member_policy']['unavailable_reasons']);
        DB::table('share_policies')->delete();
        $report = $this->reader->summary($this->today());
        $this->assertNull($report['summary']['valid_member_count']); $this->assertNull($report['valid_deposit_min']);
        $this->assertContains('no_effective_policy', $report['valid_member_policy']['unavailable_reasons']);
        DB::table('share_policies')->insert(['effective_date' => '2026-10-01', 'valid_member_min_deposit' => '20', 'valid_member_min_effective_bet' => '100', 'rules' => '{}']);
        DB::table('share_system_state')->delete();
        $report = $this->reader->summary($this->today());
        $this->assertNull($report['summary']['valid_member_count']);
        $this->assertContains('relations_not_initialized', $report['valid_member_policy']['unavailable_reasons']);
        DB::table('share_system_state')->insert(['key' => 'initialized_at', 'value' => '2026-10-01']);
        Schema::drop('share_bet_facts');
        $report = $this->reader->summary($this->today());
        $this->assertNull($report['summary']['valid_member_count']);
        $this->assertContains('missing_table:share_bet_facts', $report['valid_member_policy']['unavailable_reasons']);
    }

    public function test_report_qualification_reads_do_not_settle_or_write_and_old_settings_post_is_rejected(): void
    {
        $this->bet(); $this->deposit(1, '20'); $this->qualificationFact();
        $tables = ['reporting_settings', 'reporting_orders', 'reporting_events', 'share_policies', 'share_system_state', 'share_bet_facts',
            'balance_logs', 'share_accounts', 'share_settlements', 'share_ledger', 'share_claims', 'operation_audits'];
        $before = []; foreach ($tables as $table) $before[$table] = DB::table($table)->get()->toJson();
        for ($i = 0; $i < 2; ++$i) {
            $this->assertSame(1, $this->reader->summary($this->today())['summary']['valid_member_count']);
            $this->assertSame(1, $this->reader->details($this->today())['data'][0]['valid_member_count']);
            $settings = $this->admin->settings();
            $this->assertSame('20.0000000000', $settings['valid_deposit_min']);
            $this->assertSame('100.0000000000', $settings['valid_effective_bet_min']);
            $this->assertSame('2026-10-25 00:00:00', $settings['activity_started_at']);
        }
        try { $this->admin->settings(['valid_deposit_min' => '19.99']); $this->fail('Expected read-only settings rejection'); }
        catch (ValidationException $e) { $this->assertStringContainsString('/admin/shareEarning/settings/save', $e->validator->errors()->first()); }
        foreach ($tables as $table) $this->assertSame($before[$table], DB::table($table)->get()->toJson(), $table . ' must remain unchanged');
    }

    public function test_platform_settlement_filters_tg_virtual_exclusion_and_rank_pagination(): void
    {
        $this->bet(); $this->bet(2, ['member_id' => '500', 'amount' => '200']);
        $this->bet(3, ['status' => 1, 'profit' => '0']);
        DB::table('bets')->insert(['id' => 4, 'member_id' => '400', 'amount' => '99999', 'profit' => '0', 'status' => 1, 'created_at' => '2026-10-26 09:00:00']); $this->sync->publish('bets', 4);
        $this->assertSame(3, DB::table('reporting_orders')->count());
        $this->assertSame('0.0000000000', $this->reader->summary(['platform' => 'PC'])['summary']['bet_amount']);
        $this->assertSame('100.0000000000', $this->reader->summary(['settlement_status' => 'pending'])['summary']['bet_amount']);
        $this->assertNull($this->reader->summary(['settlement_status' => 'pending'])['summary']['company_profit']);
        $ranks = $this->reader->details(['metric' => 'bet_amount', 'page' => 2, 'limit' => 1], true);
        $this->assertSame(2, $ranks['total']); $this->assertSame(2, $ranks['data'][0]['rank']);
    }

    public function test_activity_intervals_merge_devices_split_idle_and_history_is_explicitly_missing(): void
    {
        foreach ([['a', '10:00:00'], ['b', '10:00:00'], ['a', '10:01:00'], ['b', '10:01:00'], ['a', '10:20:00'], ['a', '10:21:00']] as [$session, $at]) {
            DB::table('reporting_activity')->insert(['user_id' => 2, 'agent_id' => 10, 'inviter_id' => 1, 'client_platform' => 'H5', 'session_hash' => $session, 'observed_at' => '2026-10-26 ' . $at]);
        }
        $row = $this->reader->summary($this->today())['summary'];
        $this->assertSame(2, $row['activity_minutes']); $this->assertSame(1, $row['active_member_count']); $this->assertSame(4, $row['member_count']);
        $this->assertSame('0.250000', $row['active_rate']);
        $old = $this->reader->summary(['start_date' => '2026-10-24', 'end_date' => '2026-10-26'])['summary'];
        $this->assertNull($old['activity_minutes']); $this->assertSame(2, $old['known_activity_minutes']);
    }

    public function test_full_sync_and_repeated_sync_do_not_change_source_data_or_double_count(): void
    {
        $this->bet(); $this->deposit(); $before = DB::table('balance_logs')->get()->toArray();
        $first = $this->sync->sync(true); $second = $this->sync->sync(true);
        $this->assertSame(0, $first['errors']); $this->assertSame(0, $second['errors']);
        $this->assertSame(1, DB::table('reporting_orders')->count()); $this->assertSame(1, DB::table('reporting_events')->count());
        $this->assertEquals($before, DB::table('balance_logs')->get()->toArray());
    }

    private function activityObservation(string $at, ?int $agent = 10, ?int $inviter = 1, string $session = 'a'): void
    {
        DB::table('reporting_activity')->insert(['user_id' => 2, 'agent_id' => $agent, 'inviter_id' => $inviter,
            'client_platform' => 'H5', 'session_hash' => $session, 'observed_at' => $at]);
    }

    public function test_activity_snapshot_survives_agent_reassignment_in_summary_details_and_filters(): void
    {
        $this->activityObservation('2026-10-26 10:00:00'); $this->activityObservation('2026-10-26 10:02:00');
        $before = $this->reader->summary($this->today(['report_type' => 'promotion', 'agent_account' => 'agent10']))['summary'];
        DB::table('users')->where('id', 2)->update(['agent_id' => 20]);
        $after = $this->reader->summary($this->today(['report_type' => 'promotion', 'agent_account' => 'agent10']))['summary'];
        $this->assertSame(2, $before['activity_minutes']); $this->assertSame(2, $after['activity_minutes']);
        $this->assertSame(1, $after['active_member_count']); $this->assertFalse($after['activity_population_complete']); $this->assertNull($after['active_rate']);
        $other = $this->reader->summary($this->today(['report_type' => 'promotion', 'agent_account' => 'agent20']))['summary'];
        $this->assertSame(0, $other['activity_minutes']); $this->assertSame(0, $other['active_member_count']);
        $details = $this->reader->details($this->today(['report_type' => 'promotion']));
        $this->assertSame(1, $details['total']); $this->assertSame('10', $details['data'][0]['group_id']); $this->assertSame(2, $details['data'][0]['activity_minutes']);
        $byGroup = $this->reader->summary($this->today(['report_type' => 'promotion', 'group_id' => '10']))['summary'];
        $this->assertSame(2, $byGroup['activity_minutes']);
        $business = $this->reader->summary($this->today(['agent_account' => 'agent10']))['summary']; $this->assertSame(2, $business['activity_minutes']);

        $this->activityObservation('2026-10-26 11:00:00', 20); $this->activityObservation('2026-10-26 11:03:00', 20);
        $groups = collect($this->reader->details($this->today(['report_type' => 'promotion']))['data'])->keyBy('group_id');
        $this->assertSame(2, $groups[10]['activity_minutes']); $this->assertSame(3, $groups[20]['activity_minutes']);
        $this->assertSame('0.500000', $groups[20]['active_rate']);
        $all = $this->reader->summary($this->today())['summary']; $this->assertSame(5, $all['activity_minutes']); $this->assertSame(1, $all['active_member_count']);
        $this->assertSame('0.250000', $all['active_rate']);
    }

    public function test_agent_transition_with_overlapping_devices_counts_each_second_only_once(): void
    {
        $this->activityObservation('2026-10-26 10:00:00', 10, 1, 'a');
        $this->activityObservation('2026-10-26 10:01:00', 20, 1, 'b');
        $this->activityObservation('2026-10-26 10:02:00', 20, 1, 'a');
        $this->activityObservation('2026-10-26 10:03:00', 20, 1, 'b');
        DB::table('users')->where('id', 2)->update(['agent_id' => 20]);
        $groups = collect($this->reader->details($this->today(['report_type' => 'promotion']))['data'])->keyBy('group_id');
        $this->assertSame(1, $groups[10]['activity_minutes']); $this->assertSame(2, $groups[20]['activity_minutes']);
        $all = $this->reader->summary($this->today())['summary']; $this->assertSame(3, $all['activity_minutes']); $this->assertSame(1, $all['active_member_count']);
        $this->assertSame(1, $this->reader->summary($this->today(['report_type' => 'promotion', 'agent_account' => 'agent10']))['summary']['activity_minutes']);
        $this->assertSame(2, $this->reader->summary($this->today(['report_type' => 'promotion', 'agent_account' => 'agent20']))['summary']['activity_minutes']);
    }

    public function test_activity_uses_inviter_snapshot_and_does_not_inherit_current_null_attribution(): void
    {
        $this->activityObservation('2026-10-26 10:00:00'); $this->activityObservation('2026-10-26 10:04:00');
        DB::table('share_members')->where('user_id', 2)->update(['parent_user_id' => 3]);
        $groups = collect($this->reader->details($this->today(['report_type' => 'sharing']))['data'])->keyBy('group_id');
        $this->assertSame(4, $groups[1]['activity_minutes']); $this->assertArrayNotHasKey(3, $groups->all());
        $this->assertSame(4, $this->reader->summary($this->today(['report_type' => 'sharing', 'inviter_account' => 'member1']))['summary']['activity_minutes']);
        $this->assertSame(0, $this->reader->summary($this->today(['report_type' => 'sharing', 'inviter_account' => 'member3']))['summary']['activity_minutes']);

        DB::table('reporting_activity')->delete();
        $this->activityObservation('2026-10-26 11:00:00', null, null); $this->activityObservation('2026-10-26 11:02:00', null, null);
        $this->assertSame(2, $this->reader->summary($this->today())['summary']['activity_minutes']);
        $this->assertSame(0, $this->reader->summary($this->today(['report_type' => 'promotion']))['summary']['activity_minutes']);
        $this->assertSame(0, $this->reader->summary($this->today(['report_type' => 'sharing']))['summary']['activity_minutes']);
    }

    public function test_activity_interval_crossing_query_start_keeps_the_starting_snapshot(): void
    {
        $this->activityObservation('2026-10-25 23:59:00', 10); $this->activityObservation('2026-10-26 00:01:00', 20);
        DB::table('users')->where('id', 2)->update(['agent_id' => 20]);
        $groups = collect($this->reader->details($this->today(['report_type' => 'promotion']))['data'])->keyBy('group_id');
        $this->assertSame(1, $groups[10]['activity_minutes']); $this->assertSame(0, $groups[20]['activity_minutes']);
        $this->assertSame(1, $this->reader->summary($this->today())['summary']['activity_minutes']);
    }

    public function test_order_time_reconciliation_survives_reimport_and_does_not_settle_source(): void
    {
        DB::table('bets')->insert(['id' => 1, 'member_id' => '200', 'amount' => '100', 'profit' => '60', 'status' => 2, 'created_at' => '2026-10-25 09:00:00', 'updated_at' => '2026-10-26 10:00:00']);
        $this->sync->publish('bets', 1); $this->assertNull($this->reader->summary($this->today())['summary']['company_profit']);
        $id = (int) DB::table('reporting_orders')->value('id'); $before = (array) DB::table('bets')->first();
        $this->admin->reconcileOrder(['id' => $id, 'settled_at' => '2026-10-26 10:00:00', 'evidence' => '开奖结算日志']); $this->sync->publish('bets', 1);
        $this->assertSame('40.0000000000', $this->reader->summary($this->today())['summary']['company_profit']);
        $this->assertSame($before, (array) DB::table('bets')->first());
    }

    public function test_new_routes_have_admin_auth_and_only_operators_can_write_reconciliations(): void
    {
        $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'; });
        foreach (['options', 'leaderboard', 'fund-flow', 'summary', 'details', 'orders', 'settings', 'payment-reconciliation'] as $action) {
            $r = $router->getRoutes()->match(Request::create('/admin/reporting/' . $action));
            $this->assertContains('admin.jwt', $r->middleware()); $this->assertContains('check.button.uri', $r->middleware());
        }
        foreach (['settings', 'payment-reconciliation', 'order-reconciliation'] as $action) $this->assertContains('operations.admin', $router->getRoutes()->match(Request::create('/admin/reporting/' . $action, 'POST'))->middleware());
    }

    public function test_share_accrual_and_claim_are_separate_and_agent_cost_only_counts_actual_credit(): void
    {
        $this->bet();
        DB::table('share_ledger')->insert([['id' => 1, 'user_id' => 1, 'amount' => '20', 'bet_date' => '2026-10-26', 'category' => 'self:lottery', 'created_at' => '2026-10-26 10:00:00'],
            ['id' => 2, 'user_id' => 1, 'amount' => '-3', 'bet_date' => '2026-10-26', 'category' => 'self:lottery', 'created_at' => '2026-10-26 11:00:00']]);
        DB::table('share_claims')->insert(['id' => 1, 'user_id' => 1, 'status' => 'approved', 'credited_log_id' => 10]);
        DB::table('balance_logs')->insert(['id' => 10, 'member_id' => '100', 'amount' => '5', 'change_type' => '分享佣金领取', 'created_at' => '2026-10-26 11:00:00']);
        DB::table('agent_rebate_records')->insert(['id' => 1, 'agent_id' => 10, 'platform' => 'pc28', 'game_type' => 3, 'settlement_date' => '2026-10-26', 'flow_commission' => '7', 'profit_commission' => '2', 'flow_status' => 'credited', 'profit_status' => 'pending', 'created_at' => '2026-10-26 10:00:00']);
        DB::table('agent_balance_logs')->insert(['id' => 1, 'agent_id' => 10, 'type' => 'commission', 'amount' => '7', 'reference_type' => 'agent_rebate_record', 'reference_id' => 1, 'created_at' => '2026-10-26 11:00:00']);
        foreach ([['share_ledger', 1], ['share_ledger', 2], ['balance_logs', 10], ['agent_rebate_records', 1], ['agent_balance_logs', 1]] as [$source, $id]) $this->sync->publish($source, $id);
        $row = $this->reader->summary($this->today())['summary'];
        $this->assertSame('17.0000000000', $row['share_accrual']); $this->assertSame('5.0000000000', $row['share_commission']);
        $this->assertSame('9.0000000000', $row['agent_accrual']); $this->assertSame('7.0000000000', $row['agent_commission']);
        $this->assertSame('28.0000000000', $row['company_profit']);
        foreach ([false, true] as $ranking) {
            $details = $this->reader->details($this->today(), $ranking);
            $this->assertArrayNotHasKey('unallocated', $details);
            $this->assertNotContains('unallocated', array_column($details['data'], 'group_id'));
            $this->assertSame(2, $details['total']);
        }
        $this->assertSame('7.0000000000', $this->reader->summary($this->today())['summary']['agent_commission']);
        $this->assertSame('28.0000000000', $this->reader->summary($this->today())['summary']['company_profit']);
        $this->assertSame('5.0000000000', $this->reader->summary(['report_type' => 'sharing'])['summary']['share_commission']);
    }

    public function test_daily_total_is_for_all_pages_and_source_errors_are_visible_until_fixed(): void
    {
        $this->bet(1, ['created_at' => '2026-10-25 09:00:00']);
        $r = $this->reader->funds(['start_date' => '2026-10-25', 'end_date' => '2026-10-26', 'limit' => 1, 'page' => 2]);
        $this->assertSame(2, $r['total']); $this->assertSame('2026-10-25', $r['data'][0]['group_id']);
        $this->assertSame('100.0000000000', $r['summary']['settled_bet_amount']);
        DB::table('bets')->insert(['id' => 2, 'member_id' => 'missing', 'amount' => '10', 'status' => 1, 'created_at' => '2026-10-26 10:00:00']);
        $r = $this->sync->sync(true); $this->assertSame(1, $r['errors']);
        $this->assertNull($this->reader->summary($this->today())['summary']['company_profit']); $this->assertSame(1, DB::table('reporting_errors')->count());
        DB::table('bets')->where('id', 2)->update(['member_id' => '200']); $this->sync->sync(true);
        $this->assertSame(0, DB::table('reporting_errors')->count()); $this->assertNotNull($this->reader->summary($this->today())['summary']['company_profit']);
    }

    public function test_eloquent_context_observer_records_status_transition_once_and_tg_activity_is_deduplicated(): void
    {
        $withdraw = new \App\Models\Withdraw(); $withdraw->forceFill(['id' => 1, 'member_id' => '200', 'amount' => '10', 'to_account' => '9', 'service_charge' => '1', 'exchange_rate' => '7', 'status' => 0]); $withdraw->save();
        $context = DB::table('reporting_contexts')->where('source', 'withdraws')->first(); $this->assertNotNull($context); $this->assertNull($context->succeeded_at);
        $withdraw->status = 1; $withdraw->save(); $this->assertSame('2026-10-26 16:00:00', DB::table('reporting_contexts')->where('source', 'withdraws')->value('succeeded_at'));
        Carbon::setTestNow(Carbon::parse('2026-10-26 16:10:00', 'Asia/Shanghai')); $withdraw->amount = '11'; $withdraw->save();
        $this->assertSame('2026-10-26 16:00:00', DB::table('reporting_contexts')->where('source', 'withdraws')->value('succeeded_at'));
        $request = Request::create('/api/onMessage', 'POST'); $this->app->instance('request', $request); $user = (object) ['id' => 5, 'agent_id' => null, 'from' => -1];
        \App\Services\Reporting\ReportActivity::telegram($user); \App\Services\Reporting\ReportActivity::telegram($user);
        $this->assertSame(1, DB::table('reporting_activity')->count()); $this->assertSame('unknown', DB::table('reporting_activity')->value('client_platform'));
    }

    public function test_current_game_adapters_cover_parent_children_third_party_and_partial_sports_refunds(): void
    {
        DB::statement('CREATE TABLE bot_lhc_order (id INTEGER PRIMARY KEY,member_id TEXT,ordernum TEXT,amount TEXT,total_amount TEXT,type INTEGER,lottery_status INTEGER,is_faker INTEGER,created_at INTEGER,updated_at INTEGER)');
        DB::statement('CREATE TABLE bot_lhc_order_item (id INTEGER PRIMARY KEY,member_id TEXT,ordernum TEXT,lottery_status INTEGER,win_amount TEXT,updated_at INTEGER)');
        DB::statement('CREATE TABLE bot_sport_order (id INTEGER PRIMARY KEY,user_id TEXT,amount TEXT,win_amount TEXT,return_amount TEXT,status INTEGER,pay_status INTEGER,settlement_status INTEGER,return_status INTEGER,create_time INTEGER,update_time INTEGER,settlement_time INTEGER)');
        DB::statement('CREATE TABLE bot_third_game_orders (id INTEGER PRIMARY KEY,order_key TEXT,member_id TEXT,user_id INTEGER,game_type INTEGER,bet_amount TEXT,settled_amount TEXT,status INTEGER,currency TEXT,bet_time TEXT,last_update_time TEXT,created_at TEXT,updated_at TEXT)');
        $betAt = Carbon::parse('2026-10-26 09:00:00', 'Asia/Shanghai')->timestamp; $settledAt = $betAt + 3600;
        DB::table('lhc_order')->insert(['id' => 1, 'member_id' => '200', 'ordernum' => 'L1', 'amount' => '10', 'total_amount' => '20', 'type' => 6, 'lottery_status' => 2, 'is_faker' => 0, 'created_at' => $betAt, 'updated_at' => $settledAt]);
        DB::table('lhc_order_item')->insert([['id' => 1, 'member_id' => '200', 'ordernum' => 'L1', 'lottery_status' => 1, 'win_amount' => '0', 'updated_at' => $settledAt], ['id' => 2, 'member_id' => '200', 'ordernum' => 'L1', 'lottery_status' => 2, 'win_amount' => '18', 'updated_at' => $settledAt]]);
        $this->context('lhc_order', 1, 2, 'PC', '2026-10-26 10:00:00'); $this->sync->publish('lhc_order', 1);
        DB::table('sport_order')->insert(['id' => 1, 'user_id' => '200', 'amount' => '100', 'win_amount' => '0', 'return_amount' => '50', 'status' => 1, 'pay_status' => 1, 'settlement_status' => 1, 'return_status' => 1, 'create_time' => $betAt, 'update_time' => $settledAt, 'settlement_time' => $settledAt]);
        $this->context('sport_order', 1, 2, 'APP'); $this->sync->publish('sport_order', 1);
        DB::table('third_game_orders')->insert(['id' => 1, 'order_key' => str_repeat('a', 64), 'member_id' => '200', 'user_id' => 2, 'game_type' => 4, 'bet_amount' => '30', 'settled_amount' => '-30', 'status' => 1, 'currency' => 'CNY', 'bet_time' => '2026-10-26 09:00:00', 'last_update_time' => '2026-10-26 10:00:00', 'created_at' => '2026-10-26 09:00:00', 'updated_at' => '2026-10-26 10:00:00']);
        $this->sync->publish('third_game_orders', 1);
        $r = $this->reader->summary($this->today())['summary'];
        $this->assertSame(3, $r['order_count']); $this->assertSame('150.0000000000', $r['bet_amount']);
        $this->assertSame('100.0000000000', $r['settled_bet_amount']); $this->assertSame('18.0000000000', $r['payout_amount']);
        $this->assertSame('50.0000000000', $r['refund_amount']); $this->assertSame('82.0000000000', $r['game_gross_profit']);
        $unknown = $this->reader->summary(['platform' => 'unknown'])['summary']; $this->assertSame('30.0000000000', $unknown['bet_amount']);
        $this->assertSame(0, DB::table('share_bet_facts')->count()); // Reports did not publish sharing facts.
        $this->assertSame(0, $this->sync->sync(true)['errors']);
        Carbon::setTestNow(Carbon::parse('2026-10-26 16:10:00', 'Asia/Shanghai'));
        DB::table('lhc_order_item')->where('id', 2)->update(['win_amount' => '68', 'updated_at' => now()->timestamp]);
        $this->assertSame(0, $this->sync->sync()['errors']);
        $this->assertSame('32.0000000000', $this->reader->summary($this->today())['summary']['game_gross_profit']);
        $this->assertSame(4, DB::table('reporting_orders')->count());
    }

    public function test_audit_failure_rolls_back_reconciliation_and_foreign_currency_is_not_summed(): void
    {
        $event = $this->deposit();
        DB::statement("CREATE TRIGGER reject_reporting_audit BEFORE INSERT ON bot_operation_audits BEGIN SELECT RAISE(ABORT, 'audit failed'); END");
        try { $this->verify($event); $this->fail('Expected audit failure'); } catch (\Illuminate\Database\QueryException $e) { $this->assertStringContainsString('audit failed', $e->getMessage()); }
        $this->assertSame(0, DB::table('reporting_reconciliations')->count());
        $this->bet(); DB::table('reporting_orders')->update(['currency' => 'USDT']);
        $r = $this->reader->summary($this->today())['summary']; $this->assertSame('0.0000000000', $r['bet_amount']); $this->assertSame(1, $r['quality']['foreign_currency']); $this->assertNull($r['company_profit']);
    }

    public function test_verified_attribution_is_a_reporting_snapshot_and_survives_later_imports(): void
    {
        $event = $this->deposit(); $this->bet();
        $this->admin->reconcile(['event_id' => $event, 'actual_amount' => '1000', 'external_fee' => '0', 'occurred_at' => '2026-10-26 10:00:00',
            'currency' => 'CNY', 'evidence' => '核对原绑定及装置', 'agent_id' => 20, 'inviter_id' => 3, 'client_platform' => 'APP']);
        $this->sync->publish('balance_logs', 1);
        $e = DB::table('reporting_events')->where('id', $event)->first(); $this->assertSame(20, $e->agent_id); $this->assertSame('verified', $e->attribution_quality);
        $this->assertSame('APP', $e->client_platform); $this->assertSame(10, DB::table('users')->where('id', 2)->value('agent_id'));
        $id = (int) DB::table('reporting_orders')->value('id');
        $this->admin->reconcileOrder(['id' => $id, 'agent_id' => 20, 'evidence' => '原始推广凭据']); $this->sync->publish('bets', 1);
        $this->assertSame(20, DB::table('reporting_orders')->value('agent_id'));
        $this->assertSame('1000.0000000000', $this->reader->summary(['report_type' => 'promotion', 'agent_account' => 'agent20'])['summary']['deposit_amount']);
        $this->assertSame(1, $this->reader->events(['group_id' => '2', 'kind' => 'deposit'])['total']);
        $this->assertSame(0, $this->admin->quality([])['total']);
        $this->assertNotEmpty($this->admin->quality([])['sources']);
    }

    private function historicalBet(int $id = 1, string $betAt = '2024-01-01 09:00:00', string $settledAt = '2024-01-02 10:00:00'): void
    {
        $this->bet($id, ['created_at' => $betAt, 'amount' => '40', 'profit' => '20']);
        DB::table('reporting_contexts')->where('source', 'bets')->where('source_id', (string) $id)->update(['succeeded_at' => $settledAt]);
        $this->sync->publish('bets', $id);
    }

    public function test_no_dates_default_to_all_history_and_dates_alone_select_a_period(): void
    {
        $this->historicalBet(); $this->bet(2);
        $default = $this->reader->summary([]);
        $this->assertSame(1, $default['filters']['all_time']); $this->assertSame('2024-01-01', $default['filters']['start_date']);
        $this->assertSame('2026-10-26', $default['filters']['end_date']);
        $this->assertSame('140.0000000000', $default['summary']['bet_amount']);
        $this->assertSame('80.0000000000', $default['summary']['payout_amount']);
        $blank = $this->reader->summary(['start_date' => '', 'end_date' => null]);
        $this->assertSame($default['filters'], $blank['filters']); $this->assertSame($default['summary'], $blank['summary']);
        $range = $this->reader->summary($this->today());
        $this->assertSame(0, $range['filters']['all_time']); $this->assertSame('2026-10-26', $range['filters']['start_date']);
        $this->assertSame('100.0000000000', $range['summary']['bet_amount']);
        $this->assertSame('2026-10-26', $default['valid_member_policy']['date']);
        $this->assertSame($default['summary'], $this->reader->summary(['all_time' => 0])['summary']);
        $this->assertSame($range['summary'], $this->reader->summary($this->today(['all_time' => 1]))['summary']);
        $bounded = $this->reader->params(['start_date' => now('Asia/Shanghai')->subDays(365)->toDateString()]);
        $this->assertSame(now('Asia/Shanghai')->subDays(365)->toDateString(), $bounded['start_date']);
        $this->assertSame(366, $this->admin->options()['max_days']);
    }

    public function test_all_time_funds_paginate_actual_days_and_keep_the_complete_summary(): void
    {
        $this->historicalBet(); $this->bet(2); $event = $this->deposit(); $this->verify($event);
        $first = $this->reader->funds(['limit' => 1]);
        $days = (int) Carbon::parse('2024-01-01')->diffInDays(Carbon::parse('2026-10-27'));
        $this->assertSame($days, $first['total']); $this->assertCount(1, $first['data']); $this->assertSame('2026-10-26', $first['data'][0]['date']);
        $this->assertSame('140.0000000000', $first['summary']['bet_amount']); $this->assertSame('80.0000000000', $first['summary']['payout_amount']);
        $this->assertSame('100.0000000000', $first['data'][0]['bet_amount']); $this->assertSame('60.0000000000', $first['data'][0]['payout_amount']);
        $this->assertSame('998.0000000000', $first['summary']['net_cash_flow']);
        $settled = $this->reader->funds(['limit' => 1, 'page' => $days - 1]);
        $this->assertSame($first['summary'], $settled['summary']); $this->assertSame('2024-01-02', $settled['data'][0]['date']);
        $this->assertSame('0.0000000000', $settled['data'][0]['bet_amount']); $this->assertSame('20.0000000000', $settled['data'][0]['payout_amount']);
        $bet = $this->reader->funds(['limit' => 1, 'page' => $days]);
        $this->assertSame('2024-01-01', $bet['data'][0]['date']); $this->assertSame('40.0000000000', $bet['data'][0]['bet_amount']);
        $this->assertSame('0.0000000000', $bet['data'][0]['payout_amount']);
        $outside = $this->reader->funds(['limit' => 1, 'page' => $days + 1]);
        $this->assertSame([], $outside['data']); $this->assertSame($first['summary'], $outside['summary']); $this->assertSame($days, $outside['total']);
        $bounded = $this->reader->funds(['start_date' => '2026-10-25', 'limit' => 1, 'page' => 2]);
        $this->assertSame(2, $bounded['total']); $this->assertSame('2026-10-25', $bounded['data'][0]['date']);
        $this->assertSame('100.0000000000', $bounded['summary']['bet_amount']);
    }

    public function test_all_time_uses_the_effective_reconciliation_date_and_amount(): void
    {
        $event = $this->deposit();
        DB::table('balance_logs')->where('id', 1)->update(['created_at' => '2019-01-01 09:00:00']); $this->sync->publish('balance_logs', 1);
        $this->admin->reconcile(['event_id' => $event, 'actual_amount' => '500', 'external_fee' => '3', 'occurred_at' => '2022-02-03 10:00:00',
            'currency' => 'CNY', 'evidence' => '历史到账凭据']);
        $all = $this->reader->summary([]);
        $this->assertSame('2022-02-03', $all['filters']['start_date']); $this->assertSame('500.0000000000', $all['summary']['deposit_amount']);
        $this->assertSame('497.0000000000', $all['summary']['net_cash_flow']);
        $this->assertSame('0.0000000000', $this->reader->summary($this->today())['summary']['deposit_amount']);
        $funds = $this->reader->funds(['limit' => 1,
            'page' => (int) Carbon::parse('2022-02-03')->diffInDays(Carbon::parse('2026-10-26')) + 1]);
        $this->assertSame('2022-02-03', $funds['data'][0]['date']); $this->assertSame('500.0000000000', $funds['data'][0]['deposit_amount']);
        $events = $this->reader->events([]);
        $this->assertSame(1, $events['total']); $this->assertSame('2022-02-03 10:00:00', $events['data'][0]['verified_at']);
        $this->assertSame($all['filters']['start_date'], $events['filters']['start_date']); $this->assertSame(1, $events['filters']['all_time']);
    }

    public function test_all_time_does_not_substitute_the_application_date_for_unknown_payment_time(): void
    {
        DB::table('withdraws')->insert(['id' => 1, 'member_id' => '200', 'amount' => '100', 'to_account' => '98', 'service_charge' => '2',
            'exchange_rate' => '7', 'status' => 1, 'created_at' => '2001-01-01 08:00:00']);
        $this->sync->publish('withdraws', 1);
        $all = $this->reader->summary([]);
        $this->assertSame('2026-10-01', $all['filters']['start_date']); $this->assertSame(1, $all['summary']['quality']['missing_time']);
        $this->assertSame('0.0000000000', $all['summary']['withdraw_amount']); $this->assertNull($all['summary']['net_cash_flow']);
        $funds = $this->reader->funds(['limit' => 100]);
        $this->assertSame(26, $funds['total']); $this->assertCount(26, $funds['data']);
        foreach ($funds['data'] as $day) {
            $this->assertSame('0.0000000000', $day['withdraw_amount']); $this->assertSame(1, $day['quality']['missing_time']); $this->assertNull($day['net_cash_flow']);
        }
        $events = $this->reader->events([]);
        $this->assertSame(1, $events['total']); $this->assertNull($events['data'][0]['occurred_at']);
        $this->assertSame('2001-01-01 08:00:00', $events['data'][0]['candidate_at']);
    }

    public function test_all_time_first_day_uses_real_members_and_activity_and_empty_data_falls_back_to_today(): void
    {
        DB::table('users')->update(['created_at' => '2026-10-26 00:00:00']);
        DB::table('users')->where('from', 2)->update(['created_at' => '1999-01-01 00:00:00']);
        $this->assertSame('2026-10-26', $this->reader->params([])['start_date']);
        DB::table('users')->where('id', 2)->update(['created_at' => '2023-01-01 00:00:00']);
        $this->assertSame('2023-01-01', $this->reader->params([])['start_date']);
        $this->activityObservation('2022-01-01 10:00:00'); $this->activityObservation('2022-01-01 10:02:00');
        $all = $this->reader->summary([]);
        $this->assertSame('2022-01-01', $all['filters']['start_date']); $this->assertSame(2, $all['summary']['known_activity_minutes']);
        $this->assertNull($all['summary']['activity_minutes']);
        DB::table('reporting_activity')->delete(); DB::table('users')->delete();
        $empty = $this->reader->funds([]);
        $this->assertSame('2026-10-26', $empty['filters']['start_date']); $this->assertSame(1, $empty['total']); $this->assertCount(1, $empty['data']);
        $this->assertSame('0.0000000000', $empty['summary']['bet_amount']);
    }

    public function test_all_time_preserves_account_platform_settlement_and_ranking_filters(): void
    {
        $this->historicalBet(); $this->bet(2, ['member_id' => '500', 'amount' => '200']);
        $this->bet(3, ['status' => 1, 'amount' => '30', 'profit' => '0']); $this->deposit();
        foreach (['member_account' => 'member2', 'agent_account' => 'agent10', 'inviter_account' => 'member1'] as $filter => $value) {
            $this->assertSame('70.0000000000', $this->reader->summary([$filter => $value])['summary']['bet_amount']);
        }
        $this->assertSame('40.0000000000', $this->reader->summary(['member_account' => 'member2', 'settlement_status' => 'settled'])['summary']['bet_amount']);
        $this->assertSame('0.0000000000', $this->reader->summary(['platform' => 'APP'])['summary']['bet_amount']);
        $this->assertSame('0.0000000000', $this->reader->summary(['category' => 'self:sport'])['summary']['bet_amount']);
        $ranks = $this->reader->details(['metric' => 'bet_amount', 'page' => 2, 'limit' => 1], true);
        $this->assertSame(2, $ranks['total']); $this->assertSame('2', $ranks['data'][0]['group_id']); $this->assertSame(2, $ranks['data'][0]['rank']);
        $orders = $this->reader->orders(['member_account' => 'member2', 'page' => 2, 'limit' => 1]);
        $this->assertSame(2, $orders['total']); $this->assertSame('2024-01-01 09:00:00', $orders['data'][0]['bet_at']);
        $this->assertSame(1, $orders['filters']['all_time']); $this->assertSame('2024-01-01', $orders['filters']['start_date']);
        $this->assertSame(0, $this->reader->events(['member_account' => 'member5'])['total']);
        $this->assertSame(1, $this->reader->events(['member_account' => 'member2', 'kind' => 'deposit'])['total']);
    }

    /** @dataProvider invalidQueries */
    public function test_invalid_filters_do_not_query_unbounded_dates(array $input): void { $this->expectException(ValidationException::class); $this->reader->summary($input); }
    public static function invalidQueries(): array { return [[['start_date' => '2026-02-30']], [['end_date' => '2026-10-27']], [['start_date' => '2020-01-01']],
        [['platform' => 'ios']], [['settlement_status' => 'paid']], [['limit' => 999]], [['start_date' => []]], [['end_date' => []]],
        [['start_date' => '2026-10-26', 'end_date' => '2026-10-25']], [['end_date' => '2026-02-30']],
        [['start_date' => '2025-01-01', 'end_date' => '2026-10-26']], [['start_date' => 'not-a-date', 'end_date' => '2026-10-26']]]; }
}