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

import { Test } from "forge-std/Test.sol";
import { HamsterRunNFT } from "src/HamsterRunNFT.sol";
import { MatchQueue } from "src/MatchQueue.sol";
import { ISqueekCore } from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal certified ledger with the real roundPage semantics (afterRound exclusive, throughRound inclusive).
contract ScaleCore is ISqueekCore {
    CoreConfiguration private _cfg;
    CoreState private _st;
    RoundCheckpoint[] private _recs;

    constructor(uint64 genesis) {
        _cfg.genesisTimestamp = genesis;
        _cfg.roundDuration = 600;
        _cfg.maxRoundsPerBatch = 16;
    }

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

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

    /// @notice Certify through `through`, attaching `work` to that final round (zero rounds have no record).
    function certify(uint64 through, uint64 work) external {
        require(through > _st.settledThroughRound, "frontier");
        if (work != 0) {
            _st.cumulativeWork += work;
            _recs.push(RoundCheckpoint(through, _st.cumulativeWork, 0, 0, bytes32(0)));
        }
        _st.settledThroughRound = through;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= _st.settledThroughRound && maxRecords <= 16);
        uint256 first = _ub(afterRound);
        uint256 last = _ub(throughRound);
        uint256 n = last - first;
        require(n <= maxRecords, "unexpected truncation in this test");
        page.certifiedThroughRound = throughRound;
        if (first != 0) page.start.cumulativeWork = _recs[first - 1].cumulativeWork;
        if (last != 0) page.end.cumulativeWork = _recs[last - 1].cumulativeWork;
        page.rounds = new RoundCheckpoint[](n);
        for (uint256 i; i < n; ++i) page.rounds[i] = _recs[first + i];
    }

    function _ub(uint64 r) private view returns (uint256 lo) {
        uint256 hi = _recs.length;
        while (lo < hi) {
            uint256 mid = (lo + hi) / 2;
            if (_recs[mid].roundId <= r) lo = mid + 1;
            else hi = mid;
        }
    }
}

/// @notice One training session at live-Sepolia work levels moves a pet hundreds of 25-wide bands away from
///         any pet whose window differed by a few percent, so the preserved MatchQueue cannot pair them.
contract BandScaleTest is Test {
    uint64 constant GENESIS = 1_791_847_800; // live SqueekCore genesis
    HamsterRunNFT nft;
    MatchQueue queue;
    ScaleCore core;
    address owner = makeAddr("owner");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    function setUp() public {
        vm.warp(GENESIS + 2000 * 600); // round 2001
        vm.roll(1000);
        core = new ScaleCore(GENESIS);
        nft = new HamsterRunNFT(owner, address(core));
        queue = new MatchQueue(address(nft));
        vm.startPrank(owner);
        nft.setMatchQueue(address(queue));
        nft.setMintOpen(true);
        vm.stopPrank();
        vm.deal(alice, 1 ether);
        vm.deal(bob, 1 ether);
    }

    function _trainOnce(address player, uint64 work) internal returns (uint256 id) {
        vm.startPrank(player);
        id = nft.mint();
        nft.feed{ value: 0.0003 ether }(id, 2);
        nft.startTraining(id);
        vm.stopPrank();
        (, uint64 end,,) = nft.training(id);
        vm.warp(GENESIS + uint256(end) * 600);
        core.certify(end, work);
        nft.settleTraining(id);
    }

    function test_twoPetsTrainedOnComparableLiveWorkStillShareAQueueBand() public {
        // Live ledger (331 records, frontier 1973): p90 six-round window = 2213 work, max = 3344.
        uint256 a = _trainOnce(alice, 2213);
        uint256 b = _trainOnce(bob, 2000);
        assertEq(nft.hamster(a).stamina, 10 + 2213 * 2 * 20_000 / 10_000); // 8862
        assertEq(nft.hamster(b).stamina, 10 + 2000 * 2 * 20_000 / 10_000); // 8010

        // Re-feed so both may enqueue; feed does not change stamina.
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(a, 2);
        vm.prank(bob);
        nft.feed{ value: 0.0003 ether }(b, 2);
        vm.prank(alice);
        queue.enqueue(a);
        vm.prank(bob);
        queue.enqueue(b);
        vm.roll(block.number + queue.QUEUE_WAIT_BLOCKS());

        // Pets whose certified work differed by about 10% should still be matchable in one band.
        // Today they sit 34 bands apart (354 vs 320) and requestRound finds a single player in each.
        assertEq(queue.bandOf(a), queue.bandOf(b), "one training session should not split comparable pets");
        queue.requestRound(queue.bandOf(a));
    }

    function test_oneTrainingGainIsOrdersOfMagnitudeAboveEveryOtherStaminaSource() public view {
        // Band width 25, start stamina 10, match reward 3: a median active live window (about 2000 work)
        // yields 4000 to 8000 stamina in one hour. The band grid built for 10..24 cannot absorb it.
        uint256 gainLow = uint256(2000) * nft.STAMINA_PER_WORK() * 10_000 / 10_000;
        assertLe(gainLow, 10 * queue.BAND_WIDTH(), "single-session gain should stay within a few bands");
    }
}

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

import { Test } from "forge-std/Test.sol";
import { HamsterRunNFT } from "src/HamsterRunNFT.sol";
import { WeightClass } from "src/GameMath.sol";
import { ISqueekCore } from "src/interfaces/ISqueekCore.sol";

contract LagCore is ISqueekCore {
    CoreConfiguration private _cfg;
    CoreState private _st;
    RoundCheckpoint[] private _recs;

    constructor(uint64 genesis) {
        _cfg.genesisTimestamp = genesis;
        _cfg.roundDuration = 600;
        _cfg.maxRoundsPerBatch = 16;
    }

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

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

    function certify(uint64 through, uint64 work) external {
        require(through > _st.settledThroughRound, "frontier");
        if (work != 0) {
            _st.cumulativeWork += work;
            _recs.push(RoundCheckpoint(through, _st.cumulativeWork, 0, 0, bytes32(0)));
        }
        _st.settledThroughRound = through;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= _st.settledThroughRound && maxRecords <= 16);
        uint256 first = _ub(afterRound);
        uint256 last = _ub(throughRound);
        uint256 n = last - first;
        require(n <= maxRecords);
        page.certifiedThroughRound = throughRound;
        if (first != 0) page.start.cumulativeWork = _recs[first - 1].cumulativeWork;
        if (last != 0) page.end.cumulativeWork = _recs[last - 1].cumulativeWork;
        page.rounds = new RoundCheckpoint[](n);
        for (uint256 i; i < n; ++i) page.rounds[i] = _recs[first + i];
    }

    function _ub(uint64 r) private view returns (uint256 lo) {
        uint256 hi = _recs.length;
        while (lo < hi) {
            uint256 mid = (lo + hi) / 2;
            if (_recs[mid].roundId <= r) lo = mid + 1;
            else hi = mid;
        }
    }
}

/// @notice While a pet waits for Core certification it is locked (cannot be fed) yet keeps accruing idle
///         and hunger damage at 5/day each. At the live Sepolia lag (frontier 1973 vs current round ~2951,
///         about 6.8 days) a high-tier session with large certified work ends Obese.
contract LagDecayTest is Test {
    uint64 constant GENESIS = 1_791_847_800;
    HamsterRunNFT nft;
    LagCore core;
    address owner = makeAddr("owner");
    address alice = makeAddr("alice");

    function setUp() public {
        vm.warp(GENESIS + 2950 * 600); // round 2951, as on Sepolia on 2026-11-02
        core = new LagCore(GENESIS);
        core.certify(1973, 1); // live frontier
        nft = new HamsterRunNFT(owner, address(core));
        vm.prank(owner);
        nft.setMintOpen(true);
        vm.deal(alice, 1 ether);
    }

    function test_highTierTrainingWithLargeWorkMustNotLeaveThePetObeseBecauseCoreLagged() public {
        vm.startPrank(alice);
        uint256 id = nft.mint();
        nft.feed{ value: 0.0003 ether }(id, 2); // body 50 + 12 = 62, Normal
        assertEq(nft.hamster(id).bodyScore, 62);
        nft.startTraining(id); // books rounds 2951..2956
        vm.stopPrank();
        (, uint64 end,,) = nft.training(id);
        assertEq(end, 2956);

        // The pet cannot be fed while Training, so the 72h feed cadence the brief keeps is unreachable.
        vm.warp(block.timestamp + 3 days);
        vm.prank(alice);
        vm.expectRevert(HamsterRunNFT.Locked.selector);
        nft.feed{ value: 0.0003 ether }(id, 2);

        // Core catches up 6.8 days after booking (today's live lag) and certifies 2213 work in the window.
        vm.warp(GENESIS + uint256(end) * 600 + 6 days + 19 hours);
        core.certify(end, 2213);
        nft.settleTraining(id);

        HamsterRunNFT.Hamster memory ham = nft.hamster(id);
        assertEq(ham.stamina, 10 + 2213 * 4, "work was certified and paid");
        // idle 7 days (-35) + hungry days 4 (-20) = -55 -> 7, then +16 credit -> 23 Obese.
        // A successful high-tier training session should at least not demote the pet below where it started.
        assertGe(ham.bodyScore, 62, "paid, certified high-tier training should not reduce the body score");
        assertTrue(ham.weight != WeightClass.Obese, "training on real work must not produce an Obese pet");
    }

    function test_netBodyEffectTurnsNegativeOnceCertificationLagExceedsThreeDays() public {
        vm.startPrank(alice);
        uint256 id = nft.mint();
        nft.feed{ value: 0.0003 ether }(id, 2);
        nft.startTraining(id);
        vm.stopPrank();
        (, uint64 end,,) = nft.training(id);
        // Lag of exactly four days after the window ended: idle 4 days (-20), hunger day 1 (-5), credit +16.
        vm.warp(GENESIS + uint256(end) * 600 + 4 days);
        core.certify(end, 2213);
        nft.settleTraining(id);
        assertGe(nft.hamster(id).bodyScore, 62, "net effect of certified training is negative after 4 days of lag");
    }
}

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

import { Test } from "forge-std/Test.sol";
import { HamsterRunNFT } from "src/HamsterRunNFT.sol";
import { ISqueekCore } from "src/interfaces/ISqueekCore.sol";
import { WeightClass } from "src/GameMath.sol";

/// @dev Minimal certified-ledger stand-in for SqueekCore: one record carries the window's work.
contract LagCore is ISqueekCore {
    CoreConfiguration private _configuration;
    CoreState private _state;
    RoundCheckpoint[] private _records;

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

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

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

    function certify(uint64 throughRound, uint64 work) external {
        require(throughRound > _state.settledThroughRound, "frontier must advance");
        require(
            block.timestamp >= uint256(_configuration.genesisTimestamp) + uint256(throughRound) * 600,
            "round not ended"
        );
        if (work != 0) {
            _state.cumulativeWork += work;
            _records.push(RoundCheckpoint(throughRound, _state.cumulativeWork, 0, 0, bytes32(0)));
        }
        _state.settledThroughRound = throughRound;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= _state.settledThroughRound, "bounds");
        uint256 first = _upperBound(afterRound);
        uint256 last = _upperBound(throughRound);
        uint256 count = last - first;
        require(count <= maxRecords, "page too small for this test");
        page.certifiedThroughRound = throughRound;
        if (first != 0) page.start.cumulativeWork = _records[first - 1].cumulativeWork;
        if (last != 0) page.end.cumulativeWork = _records[last - 1].cumulativeWork;
        page.rounds = new RoundCheckpoint[](count);
        for (uint256 i; i < count; ++i) {
            page.rounds[i] = _records[first + i];
        }
    }

    function _upperBound(uint64 round) private view returns (uint256 low) {
        uint256 high = _records.length;
        while (low < high) {
            uint256 mid = (low + high) / 2;
            if (_records[mid].roundId <= round) low = mid + 1;
            else high = mid;
        }
    }
}

/// @notice A pet locked in Training while SqueekCore certification lags is charged inactivity and
///         hunger decay for the whole wait, and cannot be fed meanwhile. The wait is not inactivity:
///         the wheel work was done in the booked hour. Expected: no idle-day damage for time spent
///         in Training; actual: 5 body points per waiting day, applied at settlement.
contract TrainingLagDecayTest is Test {
    HamsterRunNFT internal nft;
    LagCore internal core;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1000);
        core = new LagCore(1_799_994_000);
        nft = new HamsterRunNFT(owner, address(core));
        vm.prank(owner);
        nft.setMintOpen(true);
        vm.deal(alice, 1 ether);
    }

    function test_trainingWaitIsNotInactivity() public {
        vm.prank(alice);
        uint256 id = nft.mint();
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(id, 2);
        assertEq(nft.hamster(id).bodyScore, 62, "high food: 50 + 12");

        vm.prank(alice);
        nft.startTraining(id);
        (, uint64 end,,) = nft.training(id);

        // Core certifies the booked window with positive work, but only two days later (still fed).
        uint256 endedAt = uint256(core.configuration().genesisTimestamp) + uint256(end) * 600;
        vm.warp(endedAt + 2 days);
        core.certify(end, 5);

        // The owner cannot feed or otherwise care for the pet while it waits.
        vm.prank(alice);
        vm.expectRevert(HamsterRunNFT.Locked.selector);
        nft.feed{ value: 0.0003 ether }(id, 2);

        nft.settleTraining(id);
        assertEq(nft.hamster(id).stamina, 30, "10 + 5 work * 2 * 20000 / 10000");
        // Expected: 62 + training credit (2 + 4 + min(20,10) = 16) = 78, no inactivity charge for the
        // certification wait. Actual on current code: 62 - 2 idle days * 5 + 16 = 68.
        assertGe(nft.hamster(id).bodyScore, 78, "training wait charged as inactivity");
    }

    function test_liveLagMakesEveryTrainedPetObese() public {
        vm.prank(alice);
        uint256 id = nft.mint();
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(id, 2);
        vm.prank(alice);
        nft.startTraining(id);
        (, uint64 end,,) = nft.training(id);

        // Sepolia at review time: frontier 1973 vs current round 2951, about 6.8 days behind.
        uint256 endedAt = uint256(core.configuration().genesisTimestamp) + uint256(end) * 600;
        vm.warp(endedAt + 7 days);
        core.certify(end, 1012);
        nft.settleTraining(id);
        assertEq(nft.hamster(id).stamina, 4058);
        // 62 - 7 idle days * 5 - 4 begun hungry days * 5 = 7, then +16 credit = 23: Obese.
        assertTrue(nft.hamster(id).weight != WeightClass.Obese, "high-food pet that trained is Obese");
    }
}

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

import { Test } from "forge-std/Test.sol";
import { HamsterRunNFT } from "src/HamsterRunNFT.sol";
import { ISqueekCore } from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal certified-ledger stand-in with the real roundPage semantics (afterRound exclusive,
///      throughRound inclusive, start/end are ledger positions at those rounds).
contract LagCore is ISqueekCore {
    CoreConfiguration private _configuration;
    CoreState private _state;
    RoundCheckpoint[] private _records;

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

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

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

    function certify(uint64 throughRound, uint64 work) external {
        require(throughRound > _state.settledThroughRound, "frontier must advance");
        require(
            block.timestamp >= uint256(_configuration.genesisTimestamp) + uint256(throughRound) * 600,
            "round not ended"
        );
        if (work != 0) {
            _state.cumulativeWork += work;
            _records.push(RoundCheckpoint(throughRound, _state.cumulativeWork, 0, 0, bytes32(0)));
        }
        _state.settledThroughRound = throughRound;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= _state.settledThroughRound, "bounds");
        uint256 first = _upperBound(afterRound);
        uint256 last = _upperBound(throughRound);
        uint256 count = last - first;
        require(count <= maxRecords, "page too small for this test");
        page.certifiedThroughRound = throughRound;
        if (first != 0) page.start.cumulativeWork = _records[first - 1].cumulativeWork;
        if (last != 0) page.end.cumulativeWork = _records[last - 1].cumulativeWork;
        page.rounds = new RoundCheckpoint[](count);
        for (uint256 i; i < count; ++i) {
            page.rounds[i] = _records[first + i];
        }
    }

    function _upperBound(uint64 round) private view returns (uint256 low) {
        uint256 high = _records.length;
        while (low < high) {
            uint256 mid = (low + high) / 2;
            if (_records[mid].roundId <= round) low = mid + 1;
            else high = mid;
        }
    }
}

/// @notice The inactivity clock (lastTrainAt) is not moved or frozen by startTraining, so every day the
///         booked window spends waiting for SqueekCore certification is billed as an idle day at settle.
///         The pet stays fed the whole time here, so hunger plays no part: the only damage is idle decay.
///         Expected: a fed pet that booked and whose window certified with positive work keeps its score
///         plus the training credit (62 + 16 = 78). Actual: 62 - 2 idle days * 5 + 16 = 68.
contract IdleClockDuringTrainingTest is Test {
    HamsterRunNFT internal nft;
    LagCore internal core;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1000);
        core = new LagCore(1_799_994_000);
        nft = new HamsterRunNFT(owner, address(core));
        vm.prank(owner);
        nft.setMintOpen(true);
        vm.deal(alice, 1 ether);
    }

    function test_certificationWaitIsNotChargedAsInactivity() public {
        vm.prank(alice);
        uint256 id = nft.mint();
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(id, 2);
        assertEq(nft.hamster(id).bodyScore, 62, "high food: 50 + 12");

        vm.prank(alice);
        nft.startTraining(id);
        (, uint64 end,,) = nft.training(id);

        // Core certifies the booked window with positive work two days after it ended; the pet is still fed
        // (fedUntil = booking time + 72h > end + 2 days, since the window is one hour long).
        uint256 endedAt = uint256(core.configuration().genesisTimestamp) + uint256(end) * 600;
        vm.warp(endedAt + 2 days);
        assertFalse(nft.isHungry(id), "pet is still inside its 72h feed window");
        core.certify(end, 5);

        nft.settleTraining(id);
        assertEq(nft.hamster(id).stamina, 30, "10 + 5 work * 2 * 20000 / 10000");
        assertGe(nft.hamster(id).bodyScore, 78, "certification wait charged as inactivity");
    }
}

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

import { Test } from "forge-std/Test.sol";
import { HamsterRunNFT } from "src/HamsterRunNFT.sol";
import { ISqueekCore } from "src/interfaces/ISqueekCore.sol";
import { CoreReader } from "src/CoreReader.sol";

/// @dev Minimal SqueekCore stand-in whose frontier never advances: the booked window is never certified.
contract StalledCore is ISqueekCore {
    CoreConfiguration private _configuration;
    CoreState private _state;

    constructor(uint64 genesis) {
        _configuration.genesisTimestamp = genesis;
        _configuration.roundDuration = 600;
        _configuration.maxRoundsPerBatch = 16;
    }

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

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

    function roundPage(uint64, uint64, uint256) external pure returns (RoundPage memory page) {
        revert("nothing certified");
    }
}

/// @notice feed() reuses the Idle-only guard, so a pet whose booking waits on Core certification cannot be
///         fed. The booking already snapshots lastFeedBps and tier at startTraining, so a later feed cannot
///         change the reward; the guard only forces the pet Hungry. On Sepolia the frontier is ~6.8 days
///         behind the clock, so every booked pet outlives its 72h food window while waiting.
///         Expected: the owner can renew food during the wait and the booking is untouched, so the pet is
///         not Hungry and takes no hunger damage. Actual: feed reverts Locked() and the pet takes 5 body
///         points per begun hungry day it cannot prevent.
contract FeedWhileTrainingTest is Test {
    HamsterRunNFT internal nft;
    StalledCore internal core;
    address internal owner = makeAddr("owner");
    address internal alice = makeAddr("alice");

    function setUp() public {
        vm.warp(1_800_000_000);
        vm.roll(1000);
        core = new StalledCore(1_799_994_000);
        nft = new HamsterRunNFT(owner, address(core));
        vm.prank(owner);
        nft.setMintOpen(true);
        vm.deal(alice, 1 ether);
    }

    function test_ownerCanKeepABookedPetFedWhileCoreCertificationLags() public {
        vm.prank(alice);
        uint256 id = nft.mint();
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(id, 2);
        vm.prank(alice);
        nft.startTraining(id);
        (uint64 start, uint64 end, uint256 bookedBps, uint8 bookedTier) = nft.training(id);
        assertEq(bookedBps, 20_000);
        assertEq(bookedTier, 2);

        // Core certifies nothing for three days; settlement is impossible and cancel forfeits the window.
        vm.warp(block.timestamp + 3 days + 1);
        vm.expectRevert(abi.encodeWithSelector(CoreReader.CoreCertificationLag.selector, 0, end));
        nft.settleTraining(id);

        // The owner renews food exactly as the kept 72h cadence asks. Expected: succeeds, booking unchanged.
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(id, 2);
        assertFalse(nft.isHungry(id), "a fed pet is not Hungry");

        (uint64 start2, uint64 end2, uint256 bps2, uint8 tier2) = nft.training(id);
        assertEq(start2, start, "booking start unchanged by feeding");
        assertEq(end2, end, "booking end unchanged by feeding");
        assertEq(bps2, bookedBps, "booked bps unchanged by feeding");
        assertEq(tier2, bookedTier, "booked tier unchanged by feeding");
    }
}

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

import { Test } from "forge-std/Test.sol";
import { HamsterRunNFT } from "src/HamsterRunNFT.sol";
import { MatchQueue } from "src/MatchQueue.sol";
import { ISqueekCore } from "src/interfaces/ISqueekCore.sol";

/// @dev Minimal certified ledger with the real roundPage semantics (afterRound exclusive, throughRound inclusive).
contract ScaleCore is ISqueekCore {
    CoreConfiguration private _cfg;
    CoreState private _st;
    RoundCheckpoint[] private _recs;

    constructor(uint64 genesis) {
        _cfg.genesisTimestamp = genesis;
        _cfg.roundDuration = 600;
        _cfg.maxRoundsPerBatch = 16;
    }

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

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

    /// @notice Certify through `through`, attaching `work` to that final round (zero rounds have no record).
    function certify(uint64 through, uint64 work) external {
        require(through > _st.settledThroughRound, "frontier");
        if (work != 0) {
            _st.cumulativeWork += work;
            _recs.push(RoundCheckpoint(through, _st.cumulativeWork, 0, 0, bytes32(0)));
        }
        _st.settledThroughRound = through;
    }

    function roundPage(uint64 afterRound, uint64 throughRound, uint256 maxRecords)
        external
        view
        returns (RoundPage memory page)
    {
        require(afterRound <= throughRound && throughRound <= _st.settledThroughRound && maxRecords <= 16);
        uint256 first = _ub(afterRound);
        uint256 last = _ub(throughRound);
        uint256 n = last - first;
        require(n <= maxRecords, "unexpected truncation in this test");
        page.certifiedThroughRound = throughRound;
        if (first != 0) page.start.cumulativeWork = _recs[first - 1].cumulativeWork;
        if (last != 0) page.end.cumulativeWork = _recs[last - 1].cumulativeWork;
        page.rounds = new RoundCheckpoint[](n);
        for (uint256 i; i < n; ++i) page.rounds[i] = _recs[first + i];
    }

    function _ub(uint64 r) private view returns (uint256 lo) {
        uint256 hi = _recs.length;
        while (lo < hi) {
            uint256 mid = (lo + hi) / 2;
            if (_recs[mid].roundId <= r) lo = mid + 1;
            else hi = mid;
        }
    }
}

/// @notice One training session at live-Sepolia work levels moves a pet hundreds of 25-wide bands away from
///         any pet whose window differed by a few percent, so the preserved MatchQueue cannot pair them.
contract BandScaleTest is Test {
    uint64 constant GENESIS = 1_791_847_800; // live SqueekCore genesis
    HamsterRunNFT nft;
    MatchQueue queue;
    ScaleCore core;
    address owner = makeAddr("owner");
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    function setUp() public {
        vm.warp(GENESIS + 2000 * 600); // round 2001
        vm.roll(1000);
        core = new ScaleCore(GENESIS);
        nft = new HamsterRunNFT(owner, address(core));
        queue = new MatchQueue(address(nft));
        vm.startPrank(owner);
        nft.setMatchQueue(address(queue));
        nft.setMintOpen(true);
        vm.stopPrank();
        vm.deal(alice, 1 ether);
        vm.deal(bob, 1 ether);
    }

    function _trainOnce(address player, uint64 work) internal returns (uint256 id) {
        vm.startPrank(player);
        id = nft.mint();
        nft.feed{ value: 0.0003 ether }(id, 2);
        nft.startTraining(id);
        vm.stopPrank();
        (, uint64 end,,) = nft.training(id);
        vm.warp(GENESIS + uint256(end) * 600);
        core.certify(end, work);
        nft.settleTraining(id);
    }

    function test_twoPetsTrainedOnComparableLiveWorkStillShareAQueueBand() public {
        // Live ledger (331 records, frontier 1973): p90 six-round window = 2213 work, max = 3344.
        uint256 a = _trainOnce(alice, 2213);
        uint256 b = _trainOnce(bob, 2000);
        assertEq(nft.hamster(a).stamina, 10 + 2213 * 2 * 20_000 / 10_000); // 8862
        assertEq(nft.hamster(b).stamina, 10 + 2000 * 2 * 20_000 / 10_000); // 8010

        // Re-feed so both may enqueue; feed does not change stamina.
        vm.prank(alice);
        nft.feed{ value: 0.0003 ether }(a, 2);
        vm.prank(bob);
        nft.feed{ value: 0.0003 ether }(b, 2);
        vm.prank(alice);
        queue.enqueue(a);
        vm.prank(bob);
        queue.enqueue(b);
        vm.roll(block.number + queue.QUEUE_WAIT_BLOCKS());

        // Pets whose certified work differed by about 10% should still be matchable in one band.
        // Today they sit 34 bands apart (354 vs 320) and requestRound finds a single player in each.
        assertEq(queue.bandOf(a), queue.bandOf(b), "one training session should not split comparable pets");
        queue.requestRound(queue.bandOf(a));
    }

    function test_oneTrainingGainIsOrdersOfMagnitudeAboveEveryOtherStaminaSource() public view {
        // Band width 25, start stamina 10, match reward 3: a median active live window (about 2000 work)
        // yields 4000 to 8000 stamina in one hour. The band grid built for 10..24 cannot absorb it.
        uint256 gainLow = uint256(2000) * nft.STAMINA_PER_WORK() * 10_000 / 10_000;
        assertLe(gainLow, 10 * queue.BAND_WIDTH(), "single-session gain should stay within a few bands");
    }
}