bot-28/tests/Integration/SharingBetFactsTest.php

<?php

namespace Tests\Integration;

use App\Console\Commands\RecalculateShareRebates;
use App\Services\Sharing\BetFactSynchronizer;
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\Support\Facades\DB;
use Illuminate\Support\Facades\Facade;
use Illuminate\Support\Facades\Schema;
use PHPUnit\Framework\TestCase;

class SharingBetFactsTest extends TestCase
{
    protected function setUp(): void
    {
        parent::setUp();
        Carbon::setTestNow(Carbon::parse('2026-10-24 12:00:00', 'Asia/Shanghai'));
        Facade::clearResolvedInstances();
        $app = new Application(dirname(__DIR__, 2));
        $app->instance('config', new Repository(['app' => ['timezone' => 'Asia/Shanghai']]));
        Facade::setFacadeApplication($app);
        $db = new Manager($app);
        $db->addConnection(['driver' => 'sqlite', 'database' => ':memory:', 'prefix' => 'bot_']);
        $db->setEventDispatcher(new Dispatcher($app)); $db->setAsGlobal(); $db->bootEloquent();
        $app->instance('db', $db->getDatabaseManager());
        $app->bind('db.schema', fn () => $db->schema());
        Schema::create('users', function (Blueprint $t) { $t->id(); $t->string('member_id'); $t->integer('from')->default(1); });
        DB::table('users')->insert([['id' => 1, 'member_id' => '10001', 'from' => -1], ['id' => 2, 'member_id' => '20002', 'from' => 2]]);
        Schema::create('lhc_order', function (Blueprint $t) {
            $t->id(); $t->string('member_id'); $t->string('ordernum'); $t->integer('type'); $t->integer('lottery_status');
            $t->decimal('amount', 24, 10); $t->decimal('total_amount', 24, 10)->nullable(); $t->bigInteger('created_at'); $t->bigInteger('updated_at');
            $t->decimal('coupon_discount', 14, 2)->default(0);
        });
        Schema::create('lhc_order_item', function (Blueprint $t) {
            $t->id(); $t->string('member_id'); $t->string('ordernum'); $t->integer('lottery_status');
            $t->decimal('win_amount', 24, 10)->nullable(); $t->decimal('profit_and_loss', 24, 10)->nullable(); $t->bigInteger('updated_at');
            $t->decimal('coupon_discount', 14, 2)->default(0);
        });
        Schema::create('sport_game_order', function (Blueprint $t) {
            $t->id(); $t->string('member_id'); $t->integer('status'); $t->decimal('amount', 24, 10); $t->decimal('win_amount', 24, 10)->default(0); $t->timestamps();
            $t->decimal('coupon_discount', 14, 2)->default(0);
        });
        Schema::create('sport_order', function (Blueprint $t) {
            $t->id(); $t->string('user_id'); $t->integer('status'); $t->integer('pay_status'); $t->integer('return_status')->default(0);
            $t->integer('settlement_status'); $t->decimal('amount', 24, 10); $t->decimal('win_amount', 24, 10)->default(0);
            $t->decimal('return_amount', 24, 10)->default(0); $t->bigInteger('create_time'); $t->bigInteger('update_time');
            $t->bigInteger('settlement_time'); $t->bigInteger('return_operation_time')->nullable();
        });
        Schema::create('third_game_orders', function (Blueprint $t) {
            $t->id(); $t->string('order_key'); $t->unsignedBigInteger('user_id')->nullable(); $t->string('member_id');
            $t->integer('game_type'); $t->integer('status'); $t->decimal('bet_amount', 24, 10)->nullable(); $t->decimal('settled_amount', 24, 10)->nullable();
            $t->string('currency'); $t->dateTime('bet_time'); $t->dateTime('last_update_time');
        });
        Schema::create('balance_logs', function (Blueprint $t) {
            $t->id(); $t->string('member_id'); $t->unsignedBigInteger('related_id'); $t->string('change_type'); $t->decimal('amount', 24, 10);
        });
        Schema::create('share_bet_facts', function (Blueprint $t) {
            $t->id(); $t->string('source'); $t->string('source_id'); $t->unsignedBigInteger('user_id'); $t->string('member_id');
            $t->string('category'); $t->dateTime('bet_at'); $t->date('bet_date'); $t->dateTime('settled_at')->nullable();
            foreach (['bet_amount', 'net_profit', 'effective_amount'] as $col) $t->decimal($col, 24, 10);
            $t->boolean('settled'); $t->boolean('voided'); $t->string('currency'); $t->string('source_version'); $t->timestamps(); $t->unique(['source', 'source_id']);
        });
        Schema::create('share_system_state', function (Blueprint $t) { $t->string('key')->primary(); $t->text('value'); $t->timestamps(); });
        DB::table('share_system_state')->insert(['key' => 'relations_lock', 'value' => '1']);
        Schema::create('rebates', function (Blueprint $t) {
            $t->id(); $t->string('member_id'); $t->date('date'); $t->decimal('betting_amount', 24, 2);
            $t->decimal('effective_betting_amount', 24, 2); $t->decimal('profit', 24, 2)->default(0); $t->integer('status'); $t->timestamps();
        });
    }

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

    private function lottery(int $status = 2): void
    {
        $time = Carbon::parse('2026-10-24 00:10:00', 'Asia/Shanghai')->timestamp;
        DB::table('lhc_order')->insert(['id' => 10, 'member_id' => '10001', 'ordernum' => 'current-lottery', 'type' => 5,
            'lottery_status' => $status, 'amount' => 100, 'total_amount' => 200, 'created_at' => $time, 'updated_at' => $time + 3600]);
        DB::table('lhc_order_item')->insert([
            ['id' => 101, 'member_id' => '10001', 'ordernum' => 'current-lottery', 'lottery_status' => 2, 'win_amount' => 150, 'profit_and_loss' => 50, 'updated_at' => $time + 3600],
            ['id' => 102, 'member_id' => '10001', 'ordernum' => 'current-lottery', 'lottery_status' => 1, 'win_amount' => 0, 'profit_and_loss' => -100, 'updated_at' => $time + 3600],
        ]);
    }

    public function test_preview_then_sync_uses_child_bets_and_repeated_sync_is_idempotent(): void
    {
        $this->lottery();
        $sync = new BetFactSynchronizer();
        $this->assertSame(2, $sync->sync()['created']);
        $this->assertSame(0, DB::table('share_bet_facts')->count());
        $this->assertSame(2, $sync->sync(null, null, true)['created']);
        $this->assertEquals(150, DB::table('share_bet_facts')->sum('effective_amount'));
        $this->assertSame('2026-10-24', DB::table('share_bet_facts')->first()->bet_date);
        $this->assertSame(['2026-10-24'], json_decode(DB::table('share_system_state')->where('key', 'facts_dirty_dates')->value('value'), true));
        $again = $sync->sync(null, null, true);
        $this->assertSame(0, $again['created']); $this->assertSame(0, $again['updated']);
        $this->assertSame(2, DB::table('share_bet_facts')->count());
    }

    public function test_coupon_orders_use_paid_stake_for_net_profit_and_effective_bet(): void
    {
        // 2 numbers x 100 with a 60 coupon split 30/30: paid 70 each, payouts still on the full 100.
        $this->lottery();
        DB::table('lhc_order')->where('id', 10)->update(['coupon_discount' => 60]);
        DB::table('lhc_order_item')->update(['coupon_discount' => 30]);
        DB::table('sport_game_order')->insert([
            ['id' => 1, 'member_id' => '10001', 'status' => 2, 'amount' => 100, 'win_amount' => 200, 'coupon_discount' => 50, 'created_at' => '2026-10-24 10:00:00', 'updated_at' => '2026-10-24 11:00:00'],
            ['id' => 2, 'member_id' => '10001', 'status' => 1, 'amount' => 100, 'win_amount' => 0, 'coupon_discount' => 50, 'created_at' => '2026-10-24 10:00:00', 'updated_at' => '2026-10-24 11:00:00'],
        ]);
        $result = (new BetFactSynchronizer())->sync(null, null, true);
        $this->assertSame([], $result['errors']);
        $fact = fn (string $source, string $id) => DB::table('share_bet_facts')->where('source', $source)->where('source_id', $id)->first();
        $won = $fact('lhc_order_item', '101'); $lost = $fact('lhc_order_item', '102');
        $this->assertEquals(70, $won->bet_amount); $this->assertEquals(80, $won->net_profit); $this->assertEquals(70, $won->effective_amount);
        $this->assertEquals(-70, $lost->net_profit); $this->assertEquals(70, $lost->effective_amount);
        $this->assertEquals(150, $fact('sport_game_order', '1')->net_profit); $this->assertEquals(50, $fact('sport_game_order', '1')->effective_amount);
        $this->assertEquals(-50, $fact('sport_game_order', '2')->net_profit); $this->assertEquals(50, $fact('sport_game_order', '2')->effective_amount);
        // A refund of the paid total (not the gross 200) is a consistent full refund.
        DB::table('lhc_order')->where('id', 10)->update(['lottery_status' => 1, 'updated_at' => Carbon::now()->timestamp]);
        DB::table('balance_logs')->insert(['member_id' => '10001', 'related_id' => 10, 'change_type' => '投注退分', 'amount' => 140]);
        $this->assertSame([], (new BetFactSynchronizer())->sync(null, null, true)['errors']);
        $this->assertSame(2, DB::table('share_bet_facts')->where('source', 'lhc_order_item')->where('voided', 1)->count());
    }

    public function test_refunded_orders_mark_previous_facts_void_and_preserve_unfinished_facts(): void
    {
        $this->lottery();
        $sync = new BetFactSynchronizer(); $sync->sync(null, null, true);
        // Failed draw legacy refund is stored with loss status; its positive refund log is authoritative.
        DB::table('lhc_order')->where('id', 10)->update(['lottery_status' => 1, 'updated_at' => Carbon::now()->timestamp]);
        DB::table('balance_logs')->insert(['member_id' => '10001', 'related_id' => 10, 'change_type' => '投注退分', 'amount' => 200]);
        $this->assertSame(2, $sync->sync(null, null, true)['updated']);
        $this->assertEquals(0, DB::table('share_bet_facts')->sum('effective_amount'));
        $this->assertSame(2, DB::table('share_bet_facts')->where('voided', 1)->count());
        DB::table('sport_game_order')->insert(['member_id' => '10001', 'status' => 0, 'amount' => 100, 'created_at' => '2026-10-24 10:00:00']);
        $sync->sync(null, null, true);
        $pending = DB::table('share_bet_facts')->where('source', 'sport_game_order')->first();
        $this->assertEquals(0, $pending->effective_amount); $this->assertEquals(0, $pending->settled);
    }

    public function test_orders_settled_without_touching_their_timestamp_still_settle_their_facts(): void
    {
        $placed = Carbon::parse('2026-10-24 11:00:00', 'Asia/Shanghai')->timestamp;
        DB::table('lhc_order')->insert(['id' => 10, 'member_id' => '10001', 'ordernum' => 'slow-draw', 'type' => 1,
            'lottery_status' => 0, 'amount' => 100, 'total_amount' => 200, 'created_at' => $placed, 'updated_at' => $placed]);
        DB::table('lhc_order_item')->insert([
            ['id' => 101, 'member_id' => '10001', 'ordernum' => 'slow-draw', 'lottery_status' => 0, 'updated_at' => $placed],
            ['id' => 102, 'member_id' => '10001', 'ordernum' => 'slow-draw', 'lottery_status' => 0, 'updated_at' => $placed],
        ]);
        DB::table('sport_order')->insert(['id' => 30, 'user_id' => '10001', 'status' => 1, 'pay_status' => 1, 'settlement_status' => 0,
            'amount' => 100, 'create_time' => $placed, 'update_time' => $placed, 'settlement_time' => 0]);
        $sync = new BetFactSynchronizer();
        $this->assertSame(3, $sync->sync(null, null, true)['created']);
        $this->assertSame(3, DB::table('share_bet_facts')->where('settled', 0)->count());

        Carbon::setTestNow(Carbon::parse('2026-10-24 13:00:00', 'Asia/Shanghai'));
        $idle = $sync->sync(null, null, true);
        $this->assertSame(0, $idle['scanned'], 'open bets whose source is still open are not re-read');

        // melbet LhcSettlementService / FootballSettlement: Model::where()->update() leaves updated_at / update_time unchanged.
        DB::table('lhc_order_item')->where('id', 101)->update(['lottery_status' => 2, 'win_amount' => 150]);
        DB::table('lhc_order_item')->where('id', 102)->update(['lottery_status' => 1]);
        DB::table('lhc_order')->where('id', 10)->update(['lottery_status' => 2]);
        DB::table('sport_order')->where('id', 30)->update(['settlement_status' => 1, 'return_amount' => 50, 'settlement_time' => $placed + 7200]);
        Carbon::setTestNow(Carbon::parse('2026-10-24 13:01:00', 'Asia/Shanghai'));
        $result = $sync->sync(null, null, true);

        $this->assertSame([], $result['errors']);
        $this->assertSame(3, $result['updated']);
        $this->assertSame(0, DB::table('share_bet_facts')->where('settled', 0)->count());
        $this->assertEquals(150, DB::table('share_bet_facts')->where('source', 'lhc_order_item')->sum('effective_amount'));
        $this->assertEquals(50, DB::table('share_bet_facts')->where('source', 'sport_order')->value('effective_amount'));
        $this->assertSame(0, $sync->sync(null, null, true)['scanned'], 'settled facts are not re-read again');
    }

    public function test_finished_orders_whose_facts_stay_open_are_retried_hourly_not_every_run(): void
    {
        $placed = Carbon::parse('2026-10-24 11:00:00', 'Asia/Shanghai')->timestamp;
        DB::table('lhc_order')->insert(['id' => 10, 'member_id' => '10001', 'ordernum' => 'stuck', 'type' => 1,
            'lottery_status' => 0, 'amount' => 100, 'total_amount' => 100, 'created_at' => $placed, 'updated_at' => $placed]);
        DB::table('lhc_order_item')->insert(['id' => 101, 'member_id' => '10001', 'ordernum' => 'stuck', 'lottery_status' => 0, 'updated_at' => $placed]);
        $sync = new BetFactSynchronizer(); $sync->sync(null, null, true);
        // Parent is final but its only child bet never settled: the fact cannot leave the open state.
        DB::table('lhc_order')->where('id', 10)->update(['lottery_status' => 2]);

        Carbon::setTestNow(Carbon::parse('2026-10-24 13:00:00', 'Asia/Shanghai'));
        $this->assertSame(1, $sync->sync(null, null, true)['unchanged']);
        Carbon::setTestNow(Carbon::parse('2026-10-24 13:30:00', 'Asia/Shanghai'));
        $this->assertSame(0, $sync->sync(null, null, true)['scanned'], 'waits before retrying');
        Carbon::setTestNow(Carbon::parse('2026-10-24 14:01:00', 'Asia/Shanghai'));
        DB::table('lhc_order_item')->where('id', 101)->update(['lottery_status' => 1]);
        $this->assertSame(1, $sync->sync(null, null, true)['updated'], 'retried after the backoff');
        $this->assertSame([], json_decode(DB::table('share_system_state')->where('key', 'facts_repair_backoff:lhc_order')->value('value'), true));
    }

    public function test_football_partial_returns_third_net_profit_and_demo_exclusion(): void
    {
        $time = Carbon::parse('2026-10-24 01:00:00', 'Asia/Shanghai')->timestamp;
        DB::table('sport_order')->insert(['user_id' => '10001', 'status' => 1, 'pay_status' => 1, 'settlement_status' => 1,
            'amount' => 100, 'win_amount' => 0, 'return_amount' => 50, 'create_time' => $time, 'update_time' => $time + 3600, 'settlement_time' => $time + 3600]);
        foreach ([1 => '10001', 2 => '20002'] as $id => $member) {
            DB::table('third_game_orders')->insert(['user_id' => $id, 'member_id' => $member, 'order_key' => hash('sha256', (string) $id),
                'game_type' => 4, 'status' => 1, 'bet_amount' => 100, 'settled_amount' => 80, 'currency' => 'CNY',
                'bet_time' => '2026-10-24 01:00:00', 'last_update_time' => '2026-10-24 02:00:00']);
        }
        $result = (new BetFactSynchronizer())->sync(null, null, true);
        $this->assertSame([], $result['errors']); $this->assertSame(2, $result['created']);
        $this->assertEquals(50, DB::table('share_bet_facts')->where('source', 'sport_order')->value('effective_amount'));
        $this->assertEquals(80, DB::table('share_bet_facts')->where('source', 'third_game_orders')->value('effective_amount'));
        $this->assertSame(0, DB::table('share_bet_facts')->where('user_id', 2)->count());
        DB::table('third_game_orders')->where('user_id', 1)->update(['status' => 3, 'game_type' => 0, 'bet_amount' => null,
            'settled_amount' => null, 'last_update_time' => '2026-10-24 12:00:00']);
        $sync = (new BetFactSynchronizer())->sync(null, null, true);
        $this->assertSame([], $sync['errors']); $this->assertSame(1, $sync['updated']);
        $cancelled = DB::table('share_bet_facts')->where('source', 'third_game_orders')->first();
        $this->assertEquals(0, $cancelled->effective_amount); $this->assertEquals(1, $cancelled->voided);
        $this->assertSame('third:4', $cancelled->category);
    }

    public function test_history_recalculation_is_preview_by_default_and_never_changes_paid_or_ambiguous_dates(): void
    {
        $this->lottery();
        DB::table('rebates')->insert([
            ['id' => 1, 'member_id' => '10001', 'date' => '2026-10-23', 'betting_amount' => 200, 'effective_betting_amount' => 200, 'status' => 0],
            ['id' => 2, 'member_id' => '10001', 'date' => '2026-10-24', 'betting_amount' => 200, 'effective_betting_amount' => 200, 'status' => 0],
            ['id' => 3, 'member_id' => '10001', 'date' => '2026-10-22', 'betting_amount' => 200, 'effective_betting_amount' => 200, 'status' => 1],
        ]);
        $command = new RecalculateShareRebates(); $sync = new BetFactSynchronizer();
        $preview = $command->recalculate($sync);
        $this->assertSame(1, $preview['changed']); $this->assertSame(1, $preview['skipped']); $this->assertSame(1, $preview['paid_untouched']);
        $this->assertEquals(200, DB::table('rebates')->where('id', 1)->value('effective_betting_amount'));
        $written = $command->recalculate($sync, true); $this->assertSame(1, $written['changed']);
        $this->assertEquals(150, DB::table('rebates')->where('id', 1)->value('effective_betting_amount'));
        $this->assertEquals(200, DB::table('rebates')->where('id', 2)->value('effective_betting_amount'));
        $this->assertEquals(200, DB::table('rebates')->where('id', 3)->value('effective_betting_amount'));
    }

    public function test_legacy_injected_bets_are_never_a_source_and_partial_refund_is_flagged_for_review(): void
    {
        Schema::create('bets', function (Blueprint $t) { $t->id(); $t->integer('status'); $t->decimal('amount', 24, 10); });
        DB::table('bets')->insert(['status' => 2, 'amount' => 100000]);
        $this->lottery();
        DB::table('balance_logs')->insert(['member_id' => '10001', 'related_id' => 10, 'change_type' => '投注退分', 'amount' => 100]);
        $result = (new BetFactSynchronizer())->sync(null, null, true);
        $this->assertSame(1, $result['scanned']); $this->assertSame(1, count($result['errors']));
        $this->assertStringContainsString('refund requires review', $result['errors'][0]['reason']);
        $this->assertSame(0, DB::table('share_bet_facts')->count());
        $this->assertNull(DB::table('share_system_state')->where('key', 'facts_cursor:lhc_order')->value('value'));
    }

    public function test_incremental_cursor_includes_new_orders_with_old_dates_and_retries_updated_sources(): void
    {
        $sync = new BetFactSynchronizer(); $sync->sync(null, null, true);
        DB::table('sport_game_order')->insert(['id' => 20, 'member_id' => '10001', 'status' => 2, 'amount' => 100,
            'win_amount' => 150, 'created_at' => '2026-10-01 10:00:00', 'updated_at' => '2026-10-01 11:00:00']);
        $this->assertSame(1, $sync->sync(null, null, true)['created']);
        DB::table('sport_game_order')->where('id', 20)->update(['status' => 3, 'updated_at' => '2026-10-24 12:00:00']);
        $this->assertSame(1, $sync->sync(null, null, true)['updated']);
        $this->assertEquals(0, DB::table('share_bet_facts')->value('effective_amount'));
        $this->assertSame(['2026-10-01'], json_decode(DB::table('share_system_state')->where('key', 'facts_dirty_dates')->value('value'), true));
    }

    public function test_legacy_lottery_orders_without_child_bets_are_skipped_and_cursor_advances(): void
    {
        $time = Carbon::parse('2026-05-01 10:00:00', 'Asia/Shanghai')->timestamp;
        DB::table('lhc_order')->insert(['id' => 5, 'member_id' => '10001', 'ordernum' => 'legacy-lottery', 'type' => 5,
            'lottery_status' => 2, 'amount' => 100, 'created_at' => $time, 'updated_at' => $time]);
        $this->lottery();
        $sync = new BetFactSynchronizer();
        $this->assertSame('Lottery order has no identifiable child bets', $sync->sync()['errors'][0]['reason']);
        app('config')->set('sharing.lottery_legacy_max_id', 5);
        $result = $sync->sync(null, null, true);
        $this->assertSame([], $result['errors']); $this->assertSame(1, $result['scanned']); $this->assertSame(2, $result['created']);
        $this->assertNotNull(DB::table('share_system_state')->where('key', 'facts_cursor:lhc_order')->value('value'));
    }

    public function test_second_child_failure_rolls_back_all_facts_dirty_dates_and_source_cursor(): void
    {
        $this->lottery();
        DB::statement("CREATE TRIGGER reject_second_fact BEFORE INSERT ON bot_share_bet_facts WHEN NEW.source_id='102' BEGIN SELECT RAISE(ABORT,'second child failed'); END");
        $result = (new BetFactSynchronizer())->sync(null, null, true);
        $this->assertSame(1, count($result['errors'])); $this->assertSame(0, $result['created']);
        $this->assertSame(0, DB::table('share_bet_facts')->count());
        $this->assertNull(DB::table('share_system_state')->where('key', 'facts_dirty_dates')->value('value'));
        $this->assertNull(DB::table('share_system_state')->where('key', 'facts_cursor:lhc_order')->value('value'));
        $this->assertSame(0, DB::transactionLevel());
    }

    public function test_write_reloads_source_after_chunk_read_and_preview_never_creates_the_guard(): void
    {
        $this->lottery();
        DB::table('share_system_state')->where('key', 'relations_lock')->delete();
        $preview = (new BetFactSynchronizer())->sync();
        $this->assertSame(2, $preview['created']); $this->assertSame(0, DB::table('share_system_state')->count());
        DB::table('share_system_state')->insert(['key' => 'relations_lock', 'value' => '1']);
        $changed = false;
        DB::listen(function ($event) use (&$changed) {
            if (!$changed && preg_match('/from "bot_lhc_order" (where "id" is not null )?order by "id"/', $event->sql)) {
                $changed = true;
                DB::table('lhc_order')->where('id', 10)->update(['lottery_status' => 4, 'updated_at' => Carbon::now()->timestamp]);
            }
        });
        $result = (new BetFactSynchronizer())->sync(null, null, true);
        $this->assertTrue($changed); $this->assertSame([], $result['errors']); $this->assertSame(2, $result['created']);
        $this->assertEquals(0, DB::table('share_bet_facts')->sum('effective_amount'));
        $this->assertSame(2, DB::table('share_bet_facts')->where('voided', 1)->count());
    }

    public function test_untrusted_source_quarantines_only_identifiable_old_facts_and_repair_restores_them(): void
    {
        $this->lottery();
        DB::table('sport_game_order')->insert(['member_id' => '10001', 'status' => 2, 'amount' => 100, 'win_amount' => 180,
            'created_at' => '2026-10-24 10:00:00', 'updated_at' => '2026-10-24 11:00:00']);
        $sync = new BetFactSynchronizer(); $sync->sync(null, null, true);
        $original = DB::table('share_bet_facts')->where('source', 'lhc_order_item')->orderBy('source_id')->get();
        $cursor = DB::table('share_system_state')->where('key', 'facts_cursor:lhc_order')->value('value');
        DB::table('share_system_state')->where('key', 'facts_dirty_dates')->update(['value' => '[]']);
        DB::table('lhc_order')->where('id', 10)->update(['updated_at' => Carbon::now()->timestamp]);
        DB::table('balance_logs')->insert(['member_id' => '10001', 'related_id' => 10, 'change_type' => '投注退分', 'amount' => 100]);
        $bad = $sync->sync(null, null, true);
        $this->assertSame(1, count($bad['errors'])); $this->assertSame(2, $bad['errors'][0]['isolated_facts']);
        $this->assertSame(2, $bad['updated']);
        $this->assertEquals(0, DB::table('share_bet_facts')->where('source', 'lhc_order_item')->sum('effective_amount'));
        $this->assertSame(2, DB::table('share_bet_facts')->where('source', 'lhc_order_item')->where('settled', 0)->where('voided', 0)->count());
        $this->assertEquals(80, DB::table('share_bet_facts')->where('source', 'sport_game_order')->value('effective_amount'));
        $quarantined = DB::table('share_bet_facts')->where('source', 'lhc_order_item')->orderBy('source_id')->get();
        foreach ($original as $i => $old) {
            $this->assertEquals($old->bet_amount, $quarantined[$i]->bet_amount);
            $this->assertEquals($old->net_profit, $quarantined[$i]->net_profit);
            $this->assertNotSame($old->source_version, $quarantined[$i]->source_version);
        }
        $this->assertSame($cursor, DB::table('share_system_state')->where('key', 'facts_cursor:lhc_order')->value('value'));
        $this->assertSame(['2026-10-24'], json_decode(DB::table('share_system_state')->where('key', 'facts_dirty_dates')->value('value'), true));
        DB::table('balance_logs')->where('change_type', '投注退分')->delete();
        $fixed = $sync->sync(null, null, true);
        $this->assertSame([], $fixed['errors']); $this->assertSame(2, $fixed['updated']);
        $this->assertEquals(150, DB::table('share_bet_facts')->where('source', 'lhc_order_item')->sum('effective_amount'));
        $this->assertSame(2, DB::table('share_bet_facts')->where('source', 'lhc_order_item')->where('settled', 1)->count());
    }
}