// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ISqueekCoreV3} from "src/interfaces/ISqueekCoreV3.sol";
import {CoreReader} from "src/CoreReader.sol";
import {HamsterRunNFT} from "src/HamsterRunNFT.sol";
import {PointsLedger} from "src/PointsLedger.sol";
import {SeasonBoard} from "src/SeasonBoard.sol";
import {TrainBook} from "src/TrainBook.sol";
import {MatchBook} from "src/MatchBook.sol";

/// @dev Minimal ABI-faithful Core stand-in. Endpoint pages return the stored position for the round.
contract StubCore is ISqueekCoreV3 {
    CoreConfiguration private _configuration;
    CoreState private _state;
    mapping(uint64 => LedgerPosition) private _positions;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxWorkPerRound = 10_000;
        _configuration.maxRoundsPerBatch = 16;
        _configuration.blockUnitsPerBlock = 1e9;
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return _configuration;
    }

    function state() external view returns (CoreState memory) {
        return _state;
    }

    function implementationCodeAddress() external view returns (address) {
        return address(this);
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function setPoint(uint64 round, uint64 work) external {
        _positions[round] = LedgerPosition(work, 0, 10875);
    }

    function setFrontier(uint64 frontier) external {
        _state.settledThroughRound = frontier;
        _state.cumulativeWork = _positions[frontier].cumulativeWork;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound == throughRound && throughRound <= _state.settledThroughRound, "bounds");
        page.certifiedThroughRound = throughRound;
        page.start = _positions[throughRound];
        page.end = _positions[throughRound];
        page.rounds = new RoundCheckpoint[](0);
    }
}

/// Economic finding: the weekly board adds certified physical work (hundreds per round on the live
/// Sepolia Core, at most 10,000 per round by configuration) to TWO TIMES a race distance whose floor
/// is 10,000 per race, for the loser as well as the winner. A hamster that loses two races without
/// ever training outranks a hamster that trained every day of the week with the largest six-round
/// work delta ever certified on the live Core (3,226, rounds 1001-1006).
contract BoardWeightTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    // Largest six-round certified delta observed on the live Sepolia Core (rounds 1001-1006).
    uint64 internal constant BEST_LIVE_WINDOW_WORK = 3226;
    address internal admin = makeAddr("owner");
    address internal trainer = makeAddr("trainer");
    address internal racerA = makeAddr("racerA");
    address internal racerB = makeAddr("racerB");
    address internal racerC = makeAddr("racerC");
    StubCore internal core;
    CoreReader internal reader;
    HamsterRunNFT internal nft;
    PointsLedger internal ledger;
    SeasonBoard internal board;
    TrainBook internal train;
    MatchBook internal matches;

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new StubCore(GENESIS);
        reader = new CoreReader(address(core), address(core), address(core).codehash);
        nft = new HamsterRunNFT(admin);
        ledger = new PointsLedger(admin);
        board = new SeasonBoard(admin, address(nft), address(ledger), address(reader));
        train = new TrainBook(address(nft), address(reader), address(board));
        matches = new MatchBook(address(nft), address(ledger), address(board), address(reader));
        vm.startPrank(admin);
        nft.configureBooks(address(train), address(matches));
        ledger.configureWriters(address(matches), address(board));
        board.configureBooks(address(train), address(matches));
        nft.ownerMint(trainer, 1); // token 1
        nft.ownerMint(racerA, 1); // token 2
        nft.ownerMint(racerB, 1); // token 3
        nft.ownerMint(racerC, 1); // token 4
        vm.stopPrank();
    }

    function _race(uint256 first, address firstOwner, uint256 second, address secondOwner, bytes32 hash)
        internal
    {
        vm.prank(firstOwner);
        uint256 id = matches.challenge(first, second);
        vm.prank(secondOwner);
        matches.accept(id);
        MatchBook.Race memory race = matches.races(id);
        vm.roll(race.randomBlock + 1);
        vm.setBlockhash(race.randomBlock, hash);
        vm.warp(race.readyAt);
        matches.settle(id);
    }

    function testWeekOfBestLiveTrainingLosesBoardToTwoLostRaces() public {
        // Token 2 races twice on day 0 against two different opponents and we only care that it took part.
        _race(2, racerA, 3, racerB, keccak256("race one"));
        _race(2, racerA, 4, racerC, keccak256("race two"));
        uint256 racerScore = board.score(0, 2);
        // Even if token 2 lost both races it still banks 2 * 10_000 per race on the board.
        assertGe(racerScore, 40_000);

        // Token 1 trains every day of week 0, each day booking a window that the Core then certifies
        // with the best six-round delta ever recorded on the live Sepolia Core.
        uint64 cumulative = 0;
        for (uint64 day = 0; day < 7; ++day) {
            vm.warp(uint256(GENESIS) + day * 1 days);
            uint64 start = day * 144 + 2;
            vm.prank(trainer);
            train.book(1, start);
            core.setPoint(start - 1, cumulative);
            cumulative += BEST_LIVE_WINDOW_WORK;
            core.setPoint(start + 5, cumulative);
            core.setFrontier(start + 5);
            vm.warp(uint256(GENESIS) + uint256(start + 5) * 600);
            (uint64 work,) = train.settle(1, day);
            assertEq(work, BEST_LIVE_WINDOW_WORK);
        }
        uint256 trainerScore = board.score(0, 1);
        assertEq(trainerScore, 7 * BEST_LIVE_WINDOW_WORK); // 22,582 certified physical work units

        // Expected: a full week of the best certified training is not outranked by two unrelated,
        // possibly lost, races. Actual: the racer leads the board and takes the 300-point prize tier.
        uint256[10] memory top = board.leaders(0);
        assertEq(top[0], 1, "week of best-ever certified training should lead the board");
        assertGt(trainerScore, racerScore, "certified work is dwarfed by the race distance floor");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ISqueekCoreV3} from "src/interfaces/ISqueekCoreV3.sol";
import {CoreReader} from "src/CoreReader.sol";
import {HamsterRunNFT} from "src/HamsterRunNFT.sol";
import {PointsLedger} from "src/PointsLedger.sol";
import {SeasonBoard} from "src/SeasonBoard.sol";
import {TrainBook} from "src/TrainBook.sol";
import {MatchBook} from "src/MatchBook.sol";

contract UpgradableStubCore is ISqueekCoreV3 {
    CoreConfiguration private _configuration;
    CoreState private _state;
    uint64 public version = 3;
    address public implementation;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxWorkPerRound = 10_000;
        implementation = address(this);
    }

    /// @dev Simulates upstream governance publishing V4 behind the same transparent proxy.
    function upgrade(address implementation_, uint64 version_) external {
        implementation = implementation_;
        version = version_;
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return _configuration;
    }

    function state() external view returns (CoreState memory) {
        return _state;
    }

    function implementationCodeAddress() external view returns (address) {
        return implementation;
    }

    function implementationCodeVersion() external view returns (uint64) {
        return version;
    }

    function roundPage(uint64, uint64, uint256) external pure returns (RoundPage memory page) {
        return page;
    }
}

/// Economic finding: once the upstream proxy reports a different implementation, every path in
/// SeasonBoard that could ever turn a completed week's activity into prizes reverts forever, even though
/// finalize needs nothing from the Core except a genesis timestamp the adapter already validated.
contract UpgradeStrandsPrizesTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    address internal admin = makeAddr("owner");
    address internal alice = makeAddr("alice");
    address internal bob = makeAddr("bob");
    UpgradableStubCore internal core;
    CoreReader internal reader;
    HamsterRunNFT internal nft;
    PointsLedger internal ledger;
    SeasonBoard internal board;
    TrainBook internal train;
    MatchBook internal matches;

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new UpgradableStubCore(GENESIS);
        reader = new CoreReader(address(core), address(core), address(core).codehash);
        nft = new HamsterRunNFT(admin);
        ledger = new PointsLedger(admin);
        board = new SeasonBoard(admin, address(nft), address(ledger), address(reader));
        train = new TrainBook(address(nft), address(reader), address(board));
        matches = new MatchBook(address(nft), address(ledger), address(board), address(reader));
        vm.startPrank(admin);
        nft.configureBooks(address(train), address(matches));
        ledger.configureWriters(address(matches), address(board));
        board.configureBooks(address(train), address(matches));
        nft.ownerMint(alice, 1); // token 1
        nft.ownerMint(bob, 1); // token 2
        vm.stopPrank();
    }

    function testCompletedWeekPrizesUnclaimableAfterUpstreamUpgrade() public {
        // Week 0: one race fully settled; the week has no pending activity.
        vm.prank(alice);
        uint256 id = matches.challenge(1, 2);
        vm.prank(bob);
        matches.accept(id);
        MatchBook.Race memory race = matches.races(id);
        vm.roll(race.randomBlock + 1);
        vm.setBlockhash(race.randomBlock, keccak256("week zero"));
        vm.warp(race.readyAt);
        matches.settle(id);
        assertEq(board.pendingMatches(0), 0);
        assertEq(board.pendingTrains(0), 0);
        assertGt(board.score(0, 1), 0);

        // The week ends; upstream governance then upgrades SqueekCore to V4 (a 60-second timelock upstream).
        vm.warp(GENESIS + 1 weeks);
        core.upgrade(address(0xBEEF), 4);

        // Expected: the completed week can be finalized from on-chain data and its prizes claimed.
        // Actual: finalize reverts CoreIdentityChanged forever and prize() stays 0, so the 300/150/50
        // tiers of every unfinalized week are lost; book/challenge/accept revert the same way.
        board.finalize(0);
        assertTrue(board.finalized(0));
        assertEq(board.prize(0, board.leaders(0)[0]), 300);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ISqueekCoreV3} from "src/interfaces/ISqueekCoreV3.sol";
import {CoreReader} from "src/CoreReader.sol";
import {HamsterRunNFT} from "src/HamsterRunNFT.sol";
import {PointsLedger} from "src/PointsLedger.sol";
import {SeasonBoard} from "src/SeasonBoard.sol";
import {TrainBook} from "src/TrainBook.sol";
import {MatchBook} from "src/MatchBook.sol";

/// @dev Minimal ABI-faithful Core stand-in. Identity getters can be changed to simulate an upgrade.
contract UpgradableCore is ISqueekCoreV3 {
    CoreConfiguration private _configuration;
    CoreState private _state;
    mapping(uint64 => LedgerPosition) private _positions;
    address public implementation;
    uint64 public version = 3;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxWorkPerRound = 10_000;
        implementation = address(this);
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return _configuration;
    }

    function state() external view returns (CoreState memory) {
        return _state;
    }

    function implementationCodeAddress() external view returns (address) {
        return implementation;
    }

    function implementationCodeVersion() external view returns (uint64) {
        return version;
    }

    function upgrade(uint64 version_) external {
        version = version_;
    }

    function setPoint(uint64 round, uint64 work) external {
        _positions[round] = LedgerPosition(work, 0, 0);
    }

    function setFrontier(uint64 frontier) external {
        _state.settledThroughRound = frontier;
        _state.cumulativeWork = _positions[frontier].cumulativeWork;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (RoundPage memory page) {
        page.certifiedThroughRound = throughRound;
        page.start = _positions[afterRound];
        page.end = _positions[throughRound];
        page.rounds = new RoundCheckpoint[](0);
    }
}

contract FinalizeCoupledToCoreIdentityTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    address internal admin = makeAddr("owner");
    address internal alice = makeAddr("Alice");
    address internal bob = makeAddr("Bob");
    UpgradableCore internal core;
    CoreReader internal reader;
    HamsterRunNFT internal nft;
    PointsLedger internal ledger;
    SeasonBoard internal board;
    TrainBook internal train;
    MatchBook internal matches;

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new UpgradableCore(GENESIS);
        reader = new CoreReader(address(core), address(core), address(core).codehash);
        nft = new HamsterRunNFT(admin);
        ledger = new PointsLedger(admin);
        board = new SeasonBoard(admin, address(nft), address(ledger), address(reader));
        train = new TrainBook(address(nft), address(reader), address(board));
        matches = new MatchBook(address(nft), address(ledger), address(board), address(reader));
        vm.startPrank(admin);
        nft.configureBooks(address(train), address(matches));
        ledger.configureWriters(address(matches), address(board));
        board.configureBooks(address(train), address(matches));
        nft.setMintOpen(true);
        vm.stopPrank();
        vm.prank(alice);
        nft.mint();
        vm.prank(bob);
        nft.mint();
    }

    /// Week 0 is fully resolved (one certified train, one settled race, nothing pending) before the
    /// upstream implementation changes. Finalization and the prize claim of that week do not depend on
    /// any Core value except the already-fixed genesis timestamp, yet they revert forever.
    function testFullyResolvedWeekCannotBeFinalizedAfterCoreUpgrade() public {
        // Train: book [2,7] on day 0, certify, settle.
        vm.prank(alice);
        train.book(1, 2);
        core.setPoint(1, 100);
        core.setPoint(7, 1100);
        core.setFrontier(7);
        vm.warp(uint256(GENESIS) + 7 * 600);
        train.settle(1, 0);
        // Race: challenge, accept, settle with a known block hash.
        vm.prank(alice);
        uint256 id = matches.challenge(1, 2);
        vm.prank(bob);
        matches.accept(id);
        MatchBook.Race memory race = matches.races(id);
        vm.roll(race.randomBlock + 1);
        vm.setBlockhash(race.randomBlock, keccak256("race"));
        vm.warp(race.readyAt);
        matches.settle(id);
        assertEq(board.pendingTrains(0), 0);
        assertEq(board.pendingMatches(0), 0);
        assertGt(board.score(0, 1), 0);

        // Week 0 ends. Upstream performs a routine upgrade (version 4) before anyone finalizes.
        vm.warp(GENESIS + 1 weeks);
        core.upgrade(4);

        // Expected: week 0 has nothing pending and its end time is already known, so finalize succeeds
        // and the rank-1 prize can be claimed. Actual: finalize reverts CoreIdentityChanged, and
        // because every contract is immutable and there is no owner path, the prize is lost forever.
        board.finalize(0);
        assertTrue(board.finalized(0));
        board.claimPrize(0, 1);
        assertEq(ledger.points(alice) >= 300, true);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ISqueekCoreV3} from "src/interfaces/ISqueekCoreV3.sol";
import {CoreReader} from "src/CoreReader.sol";
import {HamsterRunNFT} from "src/HamsterRunNFT.sol";
import {PointsLedger} from "src/PointsLedger.sol";
import {SeasonBoard} from "src/SeasonBoard.sol";
import {TrainBook} from "src/TrainBook.sol";
import {MatchBook} from "src/MatchBook.sol";

/// @dev Minimal ABI-faithful Core stand-in; identity can be flipped to simulate a proxy upgrade.
contract UpgradableCore is ISqueekCoreV3 {
    CoreConfiguration private _configuration;
    CoreState private _state;
    mapping(uint64 => LedgerPosition) private _positions;
    address public implementation;
    uint64 public version = 3;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxWorkPerRound = 10_000;
        implementation = address(this);
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return _configuration;
    }

    function state() external view returns (CoreState memory) {
        return _state;
    }

    function implementationCodeAddress() external view returns (address) {
        return implementation;
    }

    function implementationCodeVersion() external view returns (uint64) {
        return version;
    }

    function upgrade(address implementation_, uint64 version_) external {
        implementation = implementation_;
        version = version_;
    }

    function setPoint(uint64 round, uint64 work) external {
        _positions[round] = LedgerPosition(work, 0, 1);
    }

    function setFrontier(uint64 frontier) external {
        _state.settledThroughRound = frontier;
        _state.cumulativeWork = _positions[frontier].cumulativeWork;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (RoundPage memory page) {
        page.certifiedThroughRound = throughRound;
        page.start = _positions[afterRound];
        page.end = _positions[throughRound];
        page.rounds = new RoundCheckpoint[](0);
    }
}

contract FinalizeAfterUpgradeTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    address internal admin = makeAddr("owner");
    address internal alice = makeAddr("Alice");
    UpgradableCore internal core;
    CoreReader internal reader;
    HamsterRunNFT internal nft;
    PointsLedger internal ledger;
    SeasonBoard internal board;
    TrainBook internal train;
    MatchBook internal matches;

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new UpgradableCore(GENESIS);
        reader = new CoreReader(address(core), address(core), address(core).codehash);
        nft = new HamsterRunNFT(admin);
        ledger = new PointsLedger(admin);
        board = new SeasonBoard(admin, address(nft), address(ledger), address(reader));
        train = new TrainBook(address(nft), address(reader), address(board));
        matches = new MatchBook(address(nft), address(ledger), address(board), address(reader));
        vm.startPrank(admin);
        nft.configureBooks(address(train), address(matches));
        ledger.configureWriters(address(matches), address(board));
        board.configureBooks(address(train), address(matches));
        nft.ownerMint(alice, 1);
        vm.stopPrank();
    }

    /// Week 0 is fully settled (no pending trains or matches) and over. A later Core proxy upgrade
    /// must not stop the week from being finalized or its already-earned prize from being claimed.
    function testCompletedWeekCanBeFinalizedAfterCoreUpgrade() public {
        vm.prank(alice);
        train.book(1, 2);
        core.setPoint(1, 100);
        core.setPoint(7, 1100);
        core.setFrontier(7);
        vm.warp(uint256(GENESIS) + 7 * 600);
        train.settle(1, 0);
        assertEq(board.score(0, 1), 1000);
        assertEq(board.pendingTrains(0), 0);
        assertEq(board.pendingMatches(0), 0);

        vm.warp(GENESIS + 1 weeks);
        // Upstream governance ships V4: the identity pin now fails closed, as designed for work reads.
        core.upgrade(address(0xBEEF), 4);

        // Nothing about week 0 depends on Core data any more, yet finalize is dead forever.
        board.finalize(0);
        assertTrue(board.finalized(0));
        assertEq(board.prize(0, 1), 300);
        board.claimPrize(0, 1);
        assertEq(ledger.points(alice), 300);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ISqueekCoreV3} from "src/interfaces/ISqueekCoreV3.sol";
import {CoreReader} from "src/CoreReader.sol";
import {HamsterRunNFT} from "src/HamsterRunNFT.sol";
import {PointsLedger} from "src/PointsLedger.sol";
import {SeasonBoard} from "src/SeasonBoard.sol";
import {TrainBook} from "src/TrainBook.sol";
import {MatchBook} from "src/MatchBook.sol";

/// @dev Minimal ABI-faithful Core stand-in; identity can be flipped to simulate a proxy upgrade.
contract UpgradableCore is ISqueekCoreV3 {
    CoreConfiguration private _configuration;
    CoreState private _state;
    mapping(uint64 => LedgerPosition) private _positions;
    address public implementation;
    uint64 public version = 3;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxWorkPerRound = 10_000;
        implementation = address(this);
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return _configuration;
    }

    function state() external view returns (CoreState memory) {
        return _state;
    }

    function implementationCodeAddress() external view returns (address) {
        return implementation;
    }

    function implementationCodeVersion() external view returns (uint64) {
        return version;
    }

    function upgrade(address implementation_, uint64 version_) external {
        implementation = implementation_;
        version = version_;
    }

    function setPoint(uint64 round, uint64 work) external {
        _positions[round] = LedgerPosition(work, 0, 1);
    }

    function setFrontier(uint64 frontier) external {
        _state.settledThroughRound = frontier;
        _state.cumulativeWork = _positions[frontier].cumulativeWork;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256) external view returns (RoundPage memory page) {
        page.certifiedThroughRound = throughRound;
        page.start = _positions[afterRound];
        page.end = _positions[throughRound];
        page.rounds = new RoundCheckpoint[](0);
    }
}

contract FinalizeAfterUpgradeTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    address internal admin = makeAddr("owner");
    address internal alice = makeAddr("Alice");
    UpgradableCore internal core;
    CoreReader internal reader;
    HamsterRunNFT internal nft;
    PointsLedger internal ledger;
    SeasonBoard internal board;
    TrainBook internal train;
    MatchBook internal matches;

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new UpgradableCore(GENESIS);
        reader = new CoreReader(address(core), address(core), address(core).codehash);
        nft = new HamsterRunNFT(admin);
        ledger = new PointsLedger(admin);
        board = new SeasonBoard(admin, address(nft), address(ledger), address(reader));
        train = new TrainBook(address(nft), address(reader), address(board));
        matches = new MatchBook(address(nft), address(ledger), address(board), address(reader));
        vm.startPrank(admin);
        nft.configureBooks(address(train), address(matches));
        ledger.configureWriters(address(matches), address(board));
        board.configureBooks(address(train), address(matches));
        nft.ownerMint(alice, 1);
        vm.stopPrank();
    }

    /// Week 0 is fully settled (no pending trains or matches) and over. A later Core proxy upgrade
    /// must not stop the week from being finalized or its already-earned prize from being claimed.
    function testCompletedWeekCanBeFinalizedAfterCoreUpgrade() public {
        vm.prank(alice);
        train.book(1, 2);
        core.setPoint(1, 100);
        core.setPoint(7, 1100);
        core.setFrontier(7);
        vm.warp(uint256(GENESIS) + 7 * 600);
        train.settle(1, 0);
        assertEq(board.score(0, 1), 1000);
        assertEq(board.pendingTrains(0), 0);
        assertEq(board.pendingMatches(0), 0);

        vm.warp(GENESIS + 1 weeks);
        // Upstream governance ships V4: the identity pin now fails closed, as designed for work reads.
        core.upgrade(address(0xBEEF), 4);

        // Nothing about week 0 depends on Core data any more, yet finalize is dead forever.
        board.finalize(0);
        assertTrue(board.finalized(0));
        assertEq(board.prize(0, 1), 300);
        board.claimPrize(0, 1);
        assertEq(ledger.points(alice), 300);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.26;

import {Test} from "forge-std/Test.sol";
import {ISqueekCoreV3} from "src/interfaces/ISqueekCoreV3.sol";
import {CoreReader} from "src/CoreReader.sol";
import {HamsterRunNFT} from "src/HamsterRunNFT.sol";
import {PointsLedger} from "src/PointsLedger.sol";
import {SeasonBoard} from "src/SeasonBoard.sol";
import {TrainBook} from "src/TrainBook.sol";
import {MatchBook} from "src/MatchBook.sol";

/// @dev Minimal ABI-faithful Core stand-in. Endpoint pages return the stored position for the round.
contract StubCore is ISqueekCoreV3 {
    CoreConfiguration private _configuration;
    CoreState private _state;
    mapping(uint64 => LedgerPosition) private _positions;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxWorkPerRound = 10_000;
        _configuration.maxRoundsPerBatch = 16;
        _configuration.blockUnitsPerBlock = 1e9;
    }

    function configuration() external view returns (CoreConfiguration memory) {
        return _configuration;
    }

    function state() external view returns (CoreState memory) {
        return _state;
    }

    function implementationCodeAddress() external view returns (address) {
        return address(this);
    }

    function implementationCodeVersion() external pure returns (uint64) {
        return 3;
    }

    function setPoint(uint64 round, uint64 work) external {
        _positions[round] = LedgerPosition(work, 0, 10875);
    }

    function setFrontier(uint64 frontier) external {
        _state.settledThroughRound = frontier;
        _state.cumulativeWork = _positions[frontier].cumulativeWork;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound == throughRound && throughRound <= _state.settledThroughRound, "bounds");
        page.certifiedThroughRound = throughRound;
        page.start = _positions[throughRound];
        page.end = _positions[throughRound];
        page.rounds = new RoundCheckpoint[](0);
    }
}

/// Economic finding: the weekly board adds certified physical work (hundreds per round on the live
/// Sepolia Core, at most 10,000 per round by configuration) to TWO TIMES a race distance whose floor
/// is 10,000 per race, for the loser as well as the winner. A hamster that loses two races without
/// ever training outranks a hamster that trained every day of the week with the largest six-round
/// work delta ever certified on the live Core (3,226, rounds 1001-1006).
contract BoardWeightTest is Test {
    uint64 internal constant GENESIS = 1_700_000_000;
    // Largest six-round certified delta observed on the live Sepolia Core (rounds 1001-1006).
    uint64 internal constant BEST_LIVE_WINDOW_WORK = 3226;
    address internal admin = makeAddr("owner");
    address internal trainer = makeAddr("trainer");
    address internal racerA = makeAddr("racerA");
    address internal racerB = makeAddr("racerB");
    address internal racerC = makeAddr("racerC");
    StubCore internal core;
    CoreReader internal reader;
    HamsterRunNFT internal nft;
    PointsLedger internal ledger;
    SeasonBoard internal board;
    TrainBook internal train;
    MatchBook internal matches;

    function setUp() public {
        vm.warp(GENESIS);
        vm.roll(100);
        core = new StubCore(GENESIS);
        reader = new CoreReader(address(core), address(core), address(core).codehash);
        nft = new HamsterRunNFT(admin);
        ledger = new PointsLedger(admin);
        board = new SeasonBoard(admin, address(nft), address(ledger), address(reader));
        train = new TrainBook(address(nft), address(reader), address(board));
        matches = new MatchBook(address(nft), address(ledger), address(board), address(reader));
        vm.startPrank(admin);
        nft.configureBooks(address(train), address(matches));
        ledger.configureWriters(address(matches), address(board));
        board.configureBooks(address(train), address(matches));
        nft.ownerMint(trainer, 1); // token 1
        nft.ownerMint(racerA, 1); // token 2
        nft.ownerMint(racerB, 1); // token 3
        nft.ownerMint(racerC, 1); // token 4
        vm.stopPrank();
    }

    function _race(uint256 first, address firstOwner, uint256 second, address secondOwner, bytes32 hash)
        internal
    {
        vm.prank(firstOwner);
        uint256 id = matches.challenge(first, second);
        vm.prank(secondOwner);
        matches.accept(id);
        MatchBook.Race memory race = matches.races(id);
        vm.roll(race.randomBlock + 1);
        vm.setBlockhash(race.randomBlock, hash);
        vm.warp(race.readyAt);
        matches.settle(id);
    }

    function testWeekOfBestLiveTrainingLosesBoardToTwoLostRaces() public {
        // Token 2 races twice on day 0 against two different opponents and we only care that it took part.
        _race(2, racerA, 3, racerB, keccak256("race one"));
        _race(2, racerA, 4, racerC, keccak256("race two"));
        uint256 racerScore = board.score(0, 2);
        // Even if token 2 lost both races it still banks 2 * 10_000 per race on the board.
        assertGe(racerScore, 40_000);

        // Token 1 trains every day of week 0, each day booking a window that the Core then certifies
        // with the best six-round delta ever recorded on the live Sepolia Core.
        uint64 cumulative = 0;
        for (uint64 day = 0; day < 7; ++day) {
            vm.warp(uint256(GENESIS) + day * 1 days);
            uint64 start = day * 144 + 2;
            vm.prank(trainer);
            train.book(1, start);
            core.setPoint(start - 1, cumulative);
            cumulative += BEST_LIVE_WINDOW_WORK;
            core.setPoint(start + 5, cumulative);
            core.setFrontier(start + 5);
            vm.warp(uint256(GENESIS) + uint256(start + 5) * 600);
            (uint64 work,) = train.settle(1, day);
            assertEq(work, BEST_LIVE_WINDOW_WORK);
        }
        uint256 trainerScore = board.score(0, 1);
        assertEq(trainerScore, 7 * BEST_LIVE_WINDOW_WORK); // 22,582 certified physical work units

        // Expected: a full week of the best certified training is not outranked by two unrelated,
        // possibly lost, races. Actual: the racer leads the board and takes the 300-point prize tier.
        uint256[10] memory top = board.leaders(0);
        assertEq(top[0], 1, "week of best-ever certified training should lead the board");
        assertGt(trainerScore, racerScore, "certified work is dwarfed by the race distance floor");
    }
}