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 App\Services\ThirdGameCommissionService;
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\Attributes\DataProvider;
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 \Tests\Support\JsonResponseFactory());
        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();
        Schema::table('reporting_orders', fn (Blueprint $table) => $table->text('third_game_commission')->nullable());
        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']);
    }

    private function f1LotteryWithoutCompletionContext(): void
    {
        DB::statement('CREATE TABLE bot_lhc_order (id INTEGER PRIMARY KEY,member_id TEXT,ordernum TEXT,amount TEXT,total_amount TEXT,win_amount TEXT,type INTEGER,lottery_status INTEGER,is_faker INTEGER DEFAULT 0,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)');
        $betAt = Carbon::parse('2026-10-26 09:00:00', 'Asia/Shanghai')->timestamp;
        DB::table('lhc_order')->insert(['id' => 1, 'member_id' => '200', 'ordernum' => 'F1-live', 'amount' => '50', 'total_amount' => '100',
            'win_amount' => '190', 'type' => 6, 'lottery_status' => 2, 'created_at' => $betAt, 'updated_at' => $betAt + 3600]);
        DB::table('lhc_order_item')->insert([
            ['id' => 1, 'member_id' => '200', 'ordernum' => 'F1-live', 'lottery_status' => 2, 'win_amount' => '190', 'updated_at' => $betAt + 3600],
            ['id' => 2, 'member_id' => '200', 'ordernum' => 'F1-live', 'lottery_status' => 1, 'win_amount' => '0', 'updated_at' => $betAt + 3600],
        ]);
        $this->context('lhc_order', 1);
    }

    private function f1PayoutReceipt(array $extra = []): void
    {
        DB::table('balance_logs')->insert($extra + ['member_id' => '200', 'type' => 1, 'related_id' => 1, 'amount' => '190',
            'before_balance' => '100', 'after_balance' => '290', 'change_type' => '极速28中奖', 'created_at' => '2026-10-26 10:00:00']);
    }

    public function test_f1_wallet_receipt_restores_funds_business_category_and_sharing_settlement_totals(): void
    {
        $this->f1LotteryWithoutCompletionContext(); $this->f1PayoutReceipt();
        $before = DB::table('lhc_order')->get()->toJson();
        $this->sync->publish('lhc_order', 1); $this->sync->publish('lhc_order', 1);
        $funds = $this->reader->funds($this->today());
        $business = $this->reader->summary($this->today());
        $category = collect($business['categories'])->keyBy('group_id')['self:lottery'];
        $sharing = $this->reader->summary($this->today(['report_type' => 'sharing']));
        foreach ([$funds['summary'], $funds['data'][0], $business['summary'], $category, $sharing['summary']] as $row) {
            $this->assertSame('100.0000000000', $row['bet_amount']);
            $this->assertSame('100.0000000000', $row['settled_bet_amount']);
            $this->assertSame('190.0000000000', $row['payout_amount']);
            $this->assertSame('-90.0000000000', $row['game_gross_profit']);
        }
        $this->assertSame('F1彩票', $category['label']);
        $groups = $this->reader->details($this->today(['report_type' => 'sharing']))['data'];
        $this->assertSame('1', $groups[0]['group_id']);
        $this->assertSame('190.0000000000', $groups[0]['payout_amount']);
        $this->assertSame(2, DB::table('reporting_orders')->count());
        $this->assertSame('2026-10-26 10:00:00', DB::table('reporting_orders')->value('settled_at'));
        $this->assertSame($before, DB::table('lhc_order')->get()->toJson());
    }

    public function test_bulk_settlement_capture_preserves_event_attribution_and_records_actual_transition_once(): void
    {
        $this->f1LotteryWithoutCompletionContext();
        $this->sync->publish('lhc_order', 1);
        $this->assertSame('0.0000000000', $this->reader->funds($this->today())['summary']['payout_amount']);
        $before = DB::table('lhc_order')->get()->toJson();
        DB::table('users')->where('id', 2)->update(['agent_id' => 20]);
        \App\Services\Reporting\ReportContext::lotterySettled(1);
        Carbon::setTestNow(Carbon::parse('2026-10-26 16:10:00', 'Asia/Shanghai'));
        \App\Services\Reporting\ReportContext::lotterySettled(1);
        $context = DB::table('reporting_contexts')->where('source', 'lhc_order')->first();
        $this->assertSame('2026-10-26 16:00:00', $context->succeeded_at);
        $this->assertSame(10, (int) $context->agent_id); $this->assertSame(1, (int) $context->inviter_id);
        $this->assertSame('H5', $context->client_platform);
        $this->sync->publish('lhc_order', 1);
        $row = $this->reader->funds($this->today())['summary'];
        $this->assertSame('100.0000000000', $row['settled_bet_amount']);
        $this->assertSame('190.0000000000', $row['payout_amount']);
        $this->assertSame('-90.0000000000', $row['game_gross_profit']);
        $this->assertSame($before, DB::table('lhc_order')->get()->toJson());
    }

    public static function invalidF1Receipts(): array
    {
        return [
            [['related_id' => 999]], [['member_id' => '100']], [['type' => 2]],
            [['amount' => '191', 'after_balance' => '291']], [['after_balance' => '999']],
            [['created_at' => '2026-10-25 10:00:00']], [['change_type' => '充值']],
        ];
    }

    #[DataProvider('invalidF1Receipts')]
    public function test_unrelated_or_unbalanced_receipts_do_not_fabricate_lottery_settlement_time(array $receipt): void
    {
        $this->f1LotteryWithoutCompletionContext(); $this->f1PayoutReceipt($receipt);
        $this->sync->publish('lhc_order', 1);
        $this->assertNull(DB::table('reporting_orders')->value('settled_at'));
        $row = $this->reader->funds($this->today())['summary'];
        $this->assertSame('100.0000000000', $row['bet_amount']);
        $this->assertSame('0.0000000000', $row['payout_amount']);
        $this->assertGreaterThan(0, $row['quality']['missing_time']);
    }

    public function test_verified_lottery_time_takes_priority_over_payout_receipt_time(): void
    {
        $this->f1LotteryWithoutCompletionContext(); $this->f1PayoutReceipt();
        DB::table('reporting_contexts')->where('source', 'lhc_order')->update(['settlement_verified' => 1, 'succeeded_at' => '2026-10-26 11:30:00']);
        $this->sync->publish('lhc_order', 1);
        $this->assertSame('2026-10-26 11:30:00', DB::table('reporting_orders')->value('settled_at'));
    }

    public function test_bulk_lottery_loss_is_counted_as_settled_gross_profit_without_a_prize_receipt(): void
    {
        $this->f1LotteryWithoutCompletionContext();
        DB::table('lhc_order')->where('id', 1)->update(['lottery_status' => 1, 'win_amount' => '0']);
        DB::table('lhc_order_item')->update(['lottery_status' => 1, 'win_amount' => '0']);
        \App\Services\Reporting\ReportContext::lotterySettled(1);
        $this->sync->publish('lhc_order', 1);
        $row = $this->reader->funds($this->today())['summary'];
        $this->assertSame('100.0000000000', $row['settled_bet_amount']);
        $this->assertSame('0.0000000000', $row['payout_amount']);
        $this->assertSame('100.0000000000', $row['game_gross_profit']);
    }

    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->assertSame('1000.0000000000', $row['known_net_cash_flow']);
        $this->assertSame('40.0000000000', $row['known_company_profit']);
        $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']);
    }

    public function test_category_column_options_only_hide_fields_not_applicable_to_game_categories(): void
    {
        $this->bet();
        $this->verify($this->deposit());
        $hidden = $this->admin->options()['category_hidden_fields'];
        $this->assertEqualsCanonicalizing([
            'deposit_amount', 'withdraw_amount', 'member_withdraw_amount', 'agent_withdraw_amount', 'deposit_fee', 'withdraw_fee',
            'customer_fee_income', 'configured_fee', 'bonus_amount', 'manual_credit', 'manual_debit',
            'net_cash_flow', 'company_profit', 'known_net_cash_flow', 'known_company_profit',
        ], $hidden);
        $report = $this->reader->summary($this->today());
        $category = collect($report['categories'])->firstWhere('group_id', 'self:lottery');
        $details = $this->reader->details($this->today(['category' => 'self:lottery']))['data'][0];
        foreach ($hidden as $field) {
            $this->assertNotNull($report['summary'][$field]);
            $this->assertNull($category[$field]);
            $this->assertNull($details[$field]);
        }
        $this->assertSame('100.0000000000', $category['bet_amount']);
        $this->assertSame('100.0000000000', $details['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']);
        $this->assertSame('0.250000', $row['known_active_rate']);
        foreach ([[], ['start_date' => '2026-10-24', 'end_date' => '2026-10-26']] as $filters) {
            $partial = $this->reader->summary($filters)['summary'];
            $this->assertNull($partial['activity_minutes']);
            $this->assertNull($partial['active_rate']);
            $this->assertSame(2, $partial['known_activity_minutes']);
            $this->assertSame('0.250000', $partial['known_active_rate']);
        }
        $beforeCollection = $this->reader->summary(['start_date' => '2026-10-24', 'end_date' => '2026-10-24'])['summary'];
        $this->assertSame(0, $beforeCollection['active_member_count']);
        $this->assertNull($beforeCollection['known_active_rate']);
    }

    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());
    }

    public function test_lottery_parent_is_published_once_across_child_chunks_and_parent_scan(): void
    {
        $this->f1LotteryWithoutCompletionContext();
        for ($id = 3; $id <= 230; ++$id) DB::table('lhc_order_item')->insert([
            'id' => $id, 'member_id' => '200', 'ordernum' => 'F1-live', 'lottery_status' => 1, 'win_amount' => '0', 'updated_at' => now()->timestamp,
        ]);
        DB::table('lhc_order')->where('id', 1)->update(['total_amount' => '11500']);
        $result = $this->sync->sync();
        $this->assertSame(0, $result['errors']);
        $this->assertSame(1, $result['published']);
        $this->assertSame(230, DB::table('reporting_orders')->count());
        Carbon::setTestNow(now('Asia/Shanghai')->addMinutes(10));
        DB::table('lhc_order_item')->where('id', 230)->update(['win_amount' => '68', 'lottery_status' => 2, 'updated_at' => now()->timestamp]);
        $this->assertSame(1, $this->sync->sync()['published']);
        $this->assertSame('68', (string) DB::table('reporting_orders')->where('source_id', '230')->value('payout_amount'));
    }

    public function test_source_cursor_advances_past_errors_and_failed_rows_retry_without_replaying_good_history(): void
    {
        foreach (range(1, 4) as $id) DB::table('bets')->insert(['id' => $id, 'member_id' => $id === 4 ? 'missing' : '200',
            'amount' => '100', 'profit' => '60', 'status' => 2, 'created_at' => '2026-10-01 09:00:00', 'updated_at' => '2026-10-01 10:00:00']);
        $this->assertSame(1, $this->sync->sync()['errors']);
        $cursor = json_decode(DB::table('reporting_sync_state')->where('source', 'bets')->value('state'), true);
        $this->assertSame(4, $cursor['last_id']);
        Carbon::setTestNow(now('Asia/Shanghai')->addHour());
        DB::table('bets')->insert(['id' => 5, 'member_id' => '200', 'amount' => '100', 'profit' => '60', 'status' => 2,
            'created_at' => '2026-10-01 09:00:00', 'updated_at' => '2026-10-01 10:00:00']);
        $result = $this->sync->sync();
        $this->assertSame(2, $result['scanned']);
        $this->assertSame(1, $result['errors']);
        $this->assertSame('errors', $result['sources']['bets']);
        $this->assertSame(4, DB::table('reporting_orders')->count());
        DB::table('bets')->where('id', 4)->update(['member_id' => '200']);
        Carbon::setTestNow(now('Asia/Shanghai')->addMinute());
        $result = $this->sync->sync();
        $this->assertSame(1, $result['scanned']);
        $this->assertSame(0, $result['errors']);
        $this->assertSame(5, DB::table('reporting_orders')->count());
        $this->assertSame(0, DB::table('reporting_errors')->count());
    }

    public function test_missing_timestamps_use_bounded_rotating_checks_and_still_apply_old_corrections(): void
    {
        DB::statement('CREATE TABLE bot_jisu_game_order (id INTEGER PRIMARY KEY,member_id TEXT,amount TEXT,win_amount TEXT,status INTEGER,created_at TEXT)');
        foreach (range(1, 405) as $id) {
            DB::table('bets')->insert(['id' => $id, 'member_id' => '200', 'amount' => '100', 'profit' => '60', 'status' => 2,
                'created_at' => '2026-10-01 09:00:00', 'updated_at' => null]);
            DB::table('jisu_game_order')->insert(['id' => $id, 'member_id' => '200', 'amount' => '100', 'win_amount' => '60', 'status' => 2, 'created_at' => '2026-10-01 09:00:00']);
        }
        $this->assertSame(810, $this->sync->sync()['scanned']);
        DB::table('bets')->where('id', 405)->update(['profit' => '25']);
        DB::table('jisu_game_order')->where('id', 405)->update(['win_amount' => '35']);
        foreach ([400, 400, 10, 400] as $expected) {
            Carbon::setTestNow(now('Asia/Shanghai')->addMinute());
            $result = $this->sync->sync();
            $this->assertSame($expected, $result['scanned']);
            $this->assertSame(0, $result['errors']);
        }
        $this->assertSame('25', (string) DB::table('reporting_orders')->where('source', 'bets')->where('source_id', '405')->value('payout_amount'));
        $this->assertSame('35', (string) DB::table('reporting_orders')->where('source', 'jisu_game_order')->where('source_id', '405')->value('payout_amount'));
    }

    public function test_missing_source_errors_do_not_starve_later_retries_and_keep_run_incomplete(): void
    {
        DB::table('bets')->insert(['id' => 205, 'member_id' => '200', 'amount' => '100', 'profit' => '60', 'status' => 2,
            'created_at' => '2026-10-01 09:00:00', 'updated_at' => '2026-10-01 10:00:00']);
        DB::table('reporting_sync_state')->insert(['source' => 'bets', 'state' => json_encode(['last_id' => 205, 'checked_at' => now()->toDateTimeString()]), 'updated_at' => now()]);
        foreach (range(1, 205) as $id) DB::table('reporting_errors')->insert(['source' => 'bets', 'source_id' => (string) $id,
            'reason' => 'previous error', 'created_at' => '2026-10-01 10:00:00', 'updated_at' => '2026-10-01 10:00:00']);
        $first = $this->sync->sync();
        $this->assertSame(0, $first['published']);
        $this->assertSame(205, $first['errors']);
        Carbon::setTestNow(now('Asia/Shanghai')->addMinute());
        $second = $this->sync->sync();
        $this->assertSame(1, $second['published']);
        $this->assertSame(204, $second['errors']);
        $this->assertSame('errors', $second['sources']['bets']);
        $state = json_decode(DB::table('reporting_sync_state')->where('source', '__run__')->value('state'), true);
        $this->assertFalse($state['complete']);
        $this->assertSame(1, DB::table('reporting_orders')->count());
    }

    public function test_unchanged_projections_keep_timestamps_and_skip_updates(): void
    {
        $this->bet(); $this->deposit();
        $beforeOrders = DB::table('reporting_orders')->get()->toArray();
        $beforeEvents = DB::table('reporting_events')->get()->toArray();
        Carbon::setTestNow(now('Asia/Shanghai')->addMinutes(10));
        DB::table('bets')->where('id', 1)->update(['amount' => '100.0000000000']);
        DB::enableQueryLog(); DB::flushQueryLog();
        try {
            $this->assertSame(0, $this->sync->sync(true)['errors']);
            $updates = array_filter(DB::getQueryLog(), fn ($q) => preg_match('/^update "bot_reporting_(orders|events)"/', $q['query']));
            $this->assertSame([], array_values($updates));
        } finally { DB::disableQueryLog(); DB::flushQueryLog(); }
        $this->assertEquals($beforeOrders, DB::table('reporting_orders')->get()->toArray());
        $this->assertEquals($beforeEvents, DB::table('reporting_events')->get()->toArray());
    }

    public function test_sync_index_migration_is_repeatable_and_preserves_existing_indexes_and_data(): void
    {
        $this->bet();
        Schema::table('bets', fn (Blueprint $t) => $t->index(['updated_at', 'id'], 'existing_bets_update_index'));
        $migration = require dirname(__DIR__, 2) . '/database/migrations/2026_11_03_130000_add_sync_performance_indexes.php';
        $migration->up(); $migration->up();
        $plan = DB::select('EXPLAIN QUERY PLAN DELETE FROM bot_reporting_orders WHERE parent_source = ? AND parent_id = ?', ['lhc_order', '1']);
        $this->assertStringContainsString('reporting_orders_parent_lookup', json_encode($plan));
        $this->assertTrue(Schema::hasIndex('reporting_errors', 'reporting_errors_retry_lookup'));
        $migration->down();
        $this->assertTrue(Schema::hasIndex('bets', 'existing_bets_update_index'));
        $this->assertFalse(Schema::hasIndex('reporting_orders', 'reporting_orders_parent_lookup'));
        $this->assertSame(1, DB::table('reporting_orders')->count());
    }

    public function test_command_lock_skips_overlap_and_releases_after_failure(): void
    {
        $lock = new \App\Support\SyncCommandLock();
        $name = 'test:' . bin2hex(random_bytes(8));
        $this->assertSame(7, $lock->run($name, function () use ($lock, $name) {
            $this->assertNull($lock->run($name, function () { $this->fail('Overlapping synchronization ran'); }));
            $this->assertSame(8, $lock->run($name . ':other', fn () => 8));
            return 7;
        }));
        try { $lock->run($name, fn () => throw new \RuntimeException('expected failure')); }
        catch (\RuntimeException $e) { $this->assertSame('expected failure', $e->getMessage()); }
        $this->assertSame(9, $lock->run($name, fn () => 9));
    }

    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']);
        $this->assertNull($after['known_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);
            // Agent-only costs belong to the separate metadata bucket, not a synthetic member row.
            $this->assertSame('7.0000000000', $details['unallocated']['agent_commission']);
            $this->assertSame('9.0000000000', $details['unallocated']['agent_accrual']);
            $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,platform TEXT DEFAULT "pg",player_id TEXT DEFAULT "u2",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 static function thirdPartyReportCases(): array
    {
        $cases = [];
        foreach (range(1, 7) as $type) foreach ([
            'win' => [1, '80', '100', '180', '0', '-80'],
            'loss' => [1, '-100', '100', '0', '0', '100'],
            'push' => [1, '0', '100', '100', '0', '0'],
            'pending' => [0, '0', '0', '0', '0', '0'],
            'void' => [2, '0', '0', '0', '100', '0'],
            'cancelled' => [3, '0', '0', '0', '100', '0'],
        ] as $name => $values) $cases[$type . '-' . $name] = [$type, ...$values];
        return $cases;
    }

    private function commissionOrders(): void
    {
        DB::statement('CREATE TABLE bot_third_game_orders (id INTEGER PRIMARY KEY,order_key TEXT,member_id TEXT,user_id INTEGER,
            platform TEXT,player_id TEXT,game_type INTEGER,game_name TEXT,bet_amount TEXT,valid_amount TEXT,settled_amount TEXT,
            status INTEGER,currency TEXT,bet_time TEXT,last_update_time TEXT,created_at TEXT,updated_at TEXT,
            third_game_commission TEXT)');
    }

    private function commissionOrder(int $id, array $extra = []): void
    {
        $user = $extra['user_id'] ?? 2;
        $order = $extra + ['id' => $id, 'order_key' => hash('sha256', 'commission-' . $id),
            'member_id' => (string) ($user * 100), 'user_id' => $user, 'platform' => 'pg', 'player_id' => 'u' . $user,
            'game_type' => 2, 'game_name' => 'game-' . $id, 'bet_amount' => '100', 'valid_amount' => '95',
            'settled_amount' => '-100', 'status' => 1, 'currency' => 'CNY', 'bet_time' => '2026-10-25 23:00:00',
            'last_update_time' => '2026-10-26 10:00:00', 'created_at' => '2026-10-25 23:00:00', 'updated_at' => '2026-10-26 10:00:00'];
        $ratio = ['pg' => '0.09', 'ag' => '0.20', 'free' => '0'][strtolower($order['platform'])] ?? null;
        $amount = ThirdGameCommissionService::result($order['status'], $order['settled_amount']) === 'loss' && $ratio !== null
            ? ThirdGameCommissionService::charge($order['settled_amount'], $ratio) : null;
        DB::table('third_game_orders')->insert($order + ['third_game_commission' => $amount]);
        $this->sync->publish('third_game_orders', $id);
    }

    public function test_platform_commissions_sum_multiple_games_by_category_and_respect_all_three_report_scopes(): void
    {
        $this->commissionOrders();
        $this->commissionOrder(1);
        $this->commissionOrder(2, ['settled_amount' => '40']);
        $this->commissionOrder(3, ['platform' => 'AG', 'game_type' => 1, 'settled_amount' => '-50']);
        $this->commissionOrder(4, ['platform' => 'ag', 'user_id' => 3, 'settled_amount' => '-20']);
        $this->commissionOrder(5, ['user_id' => 1, 'settled_amount' => '-10']);
        $this->bet();
        $business = $this->reader->summary($this->today());
        $this->assertSame('23.9000000000', $business['summary']['third_game_commission']);
        $this->assertSame('156.1000000000', $business['summary']['company_profit']);
        $categories = collect($business['categories'])->keyBy('group_id');
        $this->assertSame('13.9000000000', $categories['third:2']['third_game_commission']);
        $this->assertSame('76.1000000000', $categories['third:2']['game_net_profit']);
        $this->assertSame('10.0000000000', $categories['third:1']['third_game_commission']);
        $this->assertSame('0.0000000000', $categories['self:lottery']['third_game_commission']);
        foreach (['promotion', 'sharing'] as $type) {
            $report = $this->reader->summary($this->today(['report_type' => $type]));
            $this->assertSame('23.0000000000', $report['summary']['third_game_commission']);
            $this->assertSame(9, count($report['categories']));
        }
        $this->assertSame('19.0000000000', $this->reader->details($this->today(['report_type' => 'promotion', 'group_id' => '10']))['data'][0]['third_game_commission']);
        $range = ['start_date' => '2026-10-25', 'end_date' => '2026-10-26', 'limit' => 1];
        $funds = $this->reader->funds($range);
        $this->assertSame('23.9000000000', $funds['summary']['third_game_commission']);
        $this->assertSame('23.9000000000', $funds['data'][0]['third_game_commission']);
        $this->assertCount(9, $funds['summary']['categories']);
        $this->assertSame('76.1000000000', collect($funds['data'][0]['categories'])->keyBy('group_id')['third:2']['game_net_profit']);
        $previous = $this->reader->funds($range + ['page' => 2]);
        $this->assertSame($funds['summary'], $previous['summary']);
        $this->assertSame('0.0000000000', collect($previous['data'][0]['categories'])->keyBy('group_id')['third:2']['third_game_commission']);
        // Bet on 10-25, settled on 10-26: game result is counted on the settlement day only, never on both days.
        $this->assertSame('0.0000000000', collect($previous['data'][0]['categories'])->keyBy('group_id')['third:2']['game_gross_profit']);
        $this->assertSame('0.0000000000', $previous['data'][0]['game_gross_profit']);
        $this->assertSame('90.0000000000', collect($funds['data'][0]['categories'])->keyBy('group_id')['third:2']['game_gross_profit']);
        $this->assertSame($funds['summary']['game_gross_profit'], $funds['data'][0]['game_gross_profit']);
        $finance = \App\Services\FundsSummaryService::summary('2026-10-26', '2026-10-26');
        $expense = collect($finance['expense'])->keyBy('key');
        $this->assertSame('23.90', $expense['third_game_commission']['amount']);
        $this->assertSame(3, $expense['third_game_commission']['people']);
        $this->assertSame('23.90', $finance['expense_total']);
        $this->assertSame('116.10', $finance['third_game_net_profit']);
        $this->assertSame('0.00', $expense['third_party_fee']['amount']);
    }

    public function test_missing_platform_rates_are_unknown_zero_rates_are_valid_and_cash_flow_is_preserved(): void
    {
        $this->commissionOrders();
        $this->commissionOrder(1, ['platform' => 'free']);
        $this->assertSame('0.0000000000', $this->reader->summary($this->today())['summary']['third_game_commission']);
        $this->commissionOrder(2, ['platform' => 'missing']);
        $this->commissionOrder(3);
        $report = $this->reader->summary($this->today());
        $row = $report['summary'];
        $this->assertNull($row['third_game_commission']);
        $this->assertSame('9.0000000000', $row['known_third_game_commission']);
        $this->assertNull($row['company_profit']);
        $this->assertNull($row['game_net_profit']);
        $this->assertSame('0.0000000000', $row['net_cash_flow']);
        $this->assertSame(1, $row['quality']['missing_platform_ratio']);
        $funds = $this->reader->funds($this->today());
        $category = collect($funds['data'][0]['categories'])->keyBy('group_id')['third:2'];
        $this->assertNull($category['third_game_commission']);
        $this->assertNull($category['game_net_profit']);
        $this->assertSame('9.0000000000', $category['known_third_game_commission']);
        $this->assertSame(1, $category['quality']['missing_platform_ratio']);
        $finance = \App\Services\FundsSummaryService::summary();
        $this->assertNull(collect($finance['expense'])->keyBy('key')['third_game_commission']['amount']);
        $this->assertNull($finance['expense_total']);
        $this->assertNull($finance['third_game_net_profit']);
        $this->assertSame('9.00', $finance['known_expense_total']);
        $this->assertSame('9.0000000000', $finance['third_game_commission_meta']['known_amount']);
    }

    public function test_commission_excludes_pending_void_virtual_and_foreign_orders_and_uses_settlement_date(): void
    {
        $this->commissionOrders();
        $this->commissionOrder(1);
        $this->commissionOrder(2, ['status' => 0]);
        $this->commissionOrder(3, ['status' => 2]);
        $this->commissionOrder(4, ['status' => 3]);
        $this->commissionOrder(5, ['user_id' => 4]);
        $this->commissionOrder(6, ['last_update_time' => '2026-10-25 23:30:00']);
        $this->assertSame('9.0000000000', $this->reader->summary($this->today())['summary']['third_game_commission']);
        $finance = \App\Services\FundsSummaryService::summary('2026-10-26', '2026-10-26');
        $this->assertSame('9.00', $finance['expense_total']);
        $this->commissionOrder(7, ['currency' => 'USD']);
        $finance = \App\Services\FundsSummaryService::summary('2026-10-26', '2026-10-26');
        $this->assertNull($finance['expense_total']);
        $this->assertSame(1, $finance['third_game_commission_meta']['quality']['foreign_currency']);
        $this->assertSame('9.0000000000', $finance['third_game_commission_meta']['known_amount']);
    }

    public function test_report_and_finance_agree_on_verified_dates_skip_foreign_players_and_withhold_profit_on_sync_errors(): void
    {
        $this->commissionOrders();
        $this->commissionOrder(1);
        // An old snapshot of the other environment's player, never given a commission.
        $this->commissionOrder(2, ['player_id' => 'tu2', 'platform' => 'unknown', 'settled_amount' => '-50']);
        $summary = $this->reader->summary($this->today())['summary'];
        $this->assertSame('9.0000000000', $summary['third_game_commission'], 'foreign snapshot is not in the report');
        $this->assertSame('91.0000000000', $summary['game_net_profit']);
        $this->assertSame('9.00', \App\Services\FundsSummaryService::summary('2026-10-26', '2026-10-26')['expense_total']);

        // 结算日核对 moves the order to 10-25 in the report; finance must follow the same date.
        $id = (int) DB::table('reporting_orders')->where('parent_source', 'third_game_orders')->where('parent_id', '1')->value('id');
        $this->admin->reconcileOrder(['id' => $id, 'settled_at' => '2026-10-25 23:30:00', 'evidence' => '对账单']);
        $this->assertSame('0.0000000000', $this->reader->summary($this->today())['summary']['third_game_commission']);
        $this->assertSame('0.00', \App\Services\FundsSummaryService::summary('2026-10-26', '2026-10-26')['expense_total']);
        $this->assertSame('9.00', \App\Services\FundsSummaryService::summary('2026-10-25', '2026-10-25')['expense_total']);

        DB::table('reporting_errors')->insert(['source' => 'third_game_orders', 'source_id' => '1', 'reason' => 'sync failed',
            'created_at' => now(), 'updated_at' => now()]);
        $range = ['start_date' => '2026-10-25', 'end_date' => '2026-10-26'];
        $this->assertNull($this->reader->summary($range)['summary']['game_net_profit']);
        $funds = $this->reader->funds($range);
        $this->assertNull($funds['summary']['game_net_profit']);
        $this->assertNull(collect($funds['data'][0]['categories'])->keyBy('group_id')['third:2']['game_net_profit']);
    }

    public function test_reports_and_finance_read_the_saved_commission_without_requesting_quota(): void
    {
        $this->commissionOrders(); $this->commissionOrder(1);
        $this->app->instance(\Illuminate\Http\Client\Factory::class, new \Illuminate\Http\Client\Factory());
        config(['third_game.api_url' => 'https://supplier.test', 'third_game.sn' => 'test', 'third_game.key' => 'test']);
        \Illuminate\Support\Facades\Http::preventStrayRequests();
        \Illuminate\Support\Facades\Http::fake([]);
        foreach (['business', 'promotion', 'sharing'] as $type) {
            $report = $this->reader->summary($this->today(['report_type' => $type]));
            $this->assertSame('9.0000000000', $report['summary']['third_game_commission']);
        }
        $this->assertSame('9.0000000000', $this->reader->funds($this->today())['summary']['third_game_commission']);
        $this->assertSame('9.00', \App\Services\FundsSummaryService::summary()['expense_total']);
        \Illuminate\Support\Facades\Http::assertNothingSent();
    }

    public function test_finance_commission_keeps_large_decimal_precision_and_reports_missing_source_data(): void
    {
        $this->commissionOrders();
        $this->commissionOrder(1, ['bet_amount' => '99999999999999.1234567891', 'settled_amount' => '-99999999999999.1234567891']);
        $this->assertSame('8999999999999.92', \App\Services\FundsSummaryService::summary()['expense_total']);
        DB::table('third_game_orders')->where('id', 1)->update(['settled_amount' => null]);
        $finance = \App\Services\FundsSummaryService::summary();
        $this->assertNull($finance['expense_total']);
        $this->assertSame(1, $finance['third_game_commission_meta']['quality']['missing_amount']);
        DB::table('third_game_orders')->where('id', 1)->update(['settled_amount' => '-100', 'last_update_time' => null]);
        $finance = \App\Services\FundsSummaryService::summary('2026-10-26', '2026-10-26');
        $this->assertNull($finance['expense_total']);
        $this->assertSame(1, $finance['third_game_commission_meta']['quality']['missing_time']);
    }

    #[DataProvider('thirdPartyReportCases')]
    public function test_third_party_categories_use_provider_settlement_time_and_preserve_net_payout_math(int $type, int $status, string $net, string $stake, string $payout, string $refund, string $gross): void
    {
        DB::statement('CREATE TABLE bot_third_game_orders (id INTEGER PRIMARY KEY,order_key TEXT,member_id TEXT,user_id INTEGER,platform TEXT DEFAULT "pg",player_id TEXT DEFAULT "u2",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)');
        DB::table('third_game_orders')->insert(['id' => 1, 'order_key' => str_repeat('b', 64), 'member_id' => '200', 'user_id' => 2, 'game_type' => $type,
            'bet_amount' => '100', 'settled_amount' => $net, 'status' => $status, 'currency' => 'CNY', 'bet_time' => '2026-10-25 23:00:00',
            'last_update_time' => '2026-10-26 10:00:00', 'created_at' => '2026-10-26 12:00:00', 'updated_at' => '2026-10-26 13:00:00']);
        $this->sync->publish('third_game_orders', 1); $this->sync->publish('third_game_orders', 1);
        $day = $this->reader->funds($this->today())['summary'];
        $report = $this->reader->summary($this->today());
        $category = collect($report['categories'])->keyBy('group_id')['third:' . $type];
        foreach ([$day, $category, $this->reader->summary($this->today(['report_type' => 'sharing']))['summary']] as $row) {
            $this->assertSame('0.0000000000', $row['bet_amount']);
            $this->assertSame(bcadd($stake, '0', 10), $row['settled_bet_amount']);
            $this->assertSame(bcadd($payout, '0', 10), $row['payout_amount']);
            $this->assertSame(bcadd($refund, '0', 10), $row['refund_amount']);
            $this->assertSame(bcadd($gross, '0', 10), $row['game_gross_profit']);
        }
        $previous = $this->reader->summary(['start_date' => '2026-10-25', 'end_date' => '2026-10-25'])['summary'];
        $this->assertSame('100.0000000000', $previous['bet_amount']);
        $this->assertSame('0.0000000000', $previous['payout_amount']);
        $this->assertSame(1, DB::table('reporting_orders')->count());
        $this->assertSame($status === 0 ? null : '2026-10-26 10:00:00', DB::table('reporting_orders')->value('settled_at'));
    }

    public static function sportsReportCases(): array
    {
        return [
            'win' => [1, 1, 0, '180', '0', '100', '180', '0', '-80'],
            'loss' => [1, 1, 0, '0', '0', '100', '0', '0', '100'],
            'half-loss' => [1, 1, 1, '0', '50', '50', '0', '50', '50'],
            'push' => [1, 1, 1, '0', '100', '0', '0', '100', '0'],
            'awaiting-payout' => [1, 2, 0, '180', '0', '0', '0', '0', '0'],
            'void' => [2, 0, 2, '0', '100', '0', '0', '100', '0'],
        ];
    }

    #[DataProvider('sportsReportCases')]
    public function test_f1_sports_uses_official_settlement_or_refund_time(int $status, int $settlement, int $returnStatus, string $win, string $returned, string $stake, string $payout, string $refund, string $gross): void
    {
        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,return_operation_time INTEGER)');
        DB::table('sport_order')->insert(['id' => 1, 'user_id' => '200', 'amount' => '100', 'win_amount' => $win, 'return_amount' => $returned,
            'status' => $status, 'pay_status' => 1, 'settlement_status' => $settlement, 'return_status' => $returnStatus,
            'create_time' => Carbon::parse('2026-10-25 23:00:00', 'Asia/Shanghai')->timestamp,
            'update_time' => Carbon::parse('2026-10-26 13:00:00', 'Asia/Shanghai')->timestamp,
            'settlement_time' => $status === 2 ? null : Carbon::parse('2026-10-26 10:00:00', 'Asia/Shanghai')->timestamp,
            'return_operation_time' => $status === 2 ? Carbon::parse('2026-10-26 11:00:00', 'Asia/Shanghai')->timestamp : null]);
        $this->sync->publish('sport_order', 1);
        $category = collect($this->reader->summary($this->today())['categories'])->keyBy('group_id')['self:sport'];
        foreach ([$category, $this->reader->funds($this->today())['summary']] as $row) {
            $this->assertSame(bcadd($stake, '0', 10), $row['settled_bet_amount']);
            $this->assertSame(bcadd($payout, '0', 10), $row['payout_amount']);
            $this->assertSame(bcadd($refund, '0', 10), $row['refund_amount']);
            $this->assertSame(bcadd($gross, '0', 10), $row['game_gross_profit']);
        }
        $this->assertSame($settlement === 2 ? null : ($status === 2 ? '2026-10-26 11:00:00' : '2026-10-26 10:00:00'), DB::table('reporting_orders')->value('settled_at'));
    }

    public function test_legacy_sport_game_job_captures_losses_as_well_as_wins_for_reporting(): void
    {
        DB::statement('CREATE TABLE bot_sport_game_order (id INTEGER PRIMARY KEY,member_id TEXT,gameplay_id INTEGER,amount TEXT,odds TEXT,status INTEGER,win_amount TEXT,profit_and_loss TEXT,created_at TEXT,updated_at TEXT)');
        DB::statement('CREATE TABLE bot_wallets (id INTEGER PRIMARY KEY,member_id TEXT,available_balance TEXT,frozen_balance TEXT,created_at TEXT,updated_at TEXT)');
        DB::table('wallets')->insert(['id' => 1, 'member_id' => '200', 'available_balance' => '100', 'frozen_balance' => '0']);
        DB::table('sport_game_order')->insert([
            ['id' => 1, 'member_id' => '200', 'gameplay_id' => 1, 'amount' => '100', 'odds' => '1.8', 'status' => 0, 'created_at' => '2026-10-26 09:00:00'],
            ['id' => 2, 'member_id' => '200', 'gameplay_id' => 2, 'amount' => '50', 'odds' => '1.8', 'status' => 0, 'created_at' => '2026-10-26 09:00:00'],
        ]);
        $this->context('sport_game_order', 1); $this->context('sport_game_order', 2);
        (new \App\Jobs\SportGameOrderJob(1))->handle();
        $this->sync->publish('sport_game_order', 1); $this->sync->publish('sport_game_order', 2);
        $row = $this->reader->funds($this->today())['summary'];
        $this->assertSame('150.0000000000', $row['settled_bet_amount']);
        $this->assertSame('180.0000000000', $row['payout_amount']);
        $this->assertSame('-30.0000000000', $row['game_gross_profit']);
        $this->assertSame('280.00', bcadd((string) DB::table('wallets')->where('id', 1)->value('available_balance'), '0', 2));
        $this->assertSame(0, DB::transactionLevel());
    }

    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']]]; }
}