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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

/// @dev A PLANT token with a public burn, as ERC20Burnable launch tokens commonly have.
contract BurnableToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ScratchHook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// @dev One wei of PLANT burned by anyone makes redeem and settle revert forever,
/// locking every holder's backing IMD in the contract.
contract SupplyLockTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    uint32 internal constant LISBON = 10223579;
    bytes32 internal constant QUESTION = keccak256("frozen test weather question");

    BurnableToken internal imd;
    BurnableToken internal token;
    PlantOrganism internal body;
    address internal alice = makeAddr("alice");
    address internal mallory = makeAddr("mallory");

    function setUp() public {
        vm.chainId(4663);
        vm.warp(20000 days + 12 hours);
        imd = new BurnableToken();
        token = new BurnableToken();
        token.mint(alice, 999 ether);
        token.mint(mallory, 1 ether);
        body = new PlantOrganism(address(imd), vm.addr(KEY), LISBON, address(this));
        ScratchHook hook = new ScratchHook(address(body), address(token));
        body.bind(address(hook), QUESTION);
        vm.prank(alice);
        token.approve(address(body), type(uint256).max);
    }

    function attestation(uint256 day, uint24 sun) internal view returns (OracleAttestation.Attestation memory a) {
        bytes32[] memory words = new bytes32[](3);
        words[0] = bytes32(uint256(sun) | (uint256(1) << 48) | (uint256(LISBON) << 64) | (day << 96));
        a = OracleAttestation.Attestation({
            requestId: bytes32(day),
            chainId: 4663,
            questionHash: QUESTION,
            answerType: 5,
            answer: abi.encode(words),
            figure: 0,
            fromBlock: 100,
            toBlock: 200,
            blockHash: bytes32(uint256(7)),
            panelJobId: bytes32(uint256(8)),
            panelSize: 5,
            quorum: 4,
            agreed: 5,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
    }

    function settle(uint24 sun) internal {
        uint256 day = body.lastSettledDay() + 1;
        if (block.timestamp / 1 days < day) vm.warp(day * 1 days + 12 hours);
        OracleAttestation.Attestation memory a = attestation(day, sun);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, body.attestationDigest(a));
        body.settle(a, abi.encodePacked(r, s, v));
    }

    function test_oneWeiBurnLocksAllBackingForever() public {
        // Birth at Lisbon, then one sunny hour turns pot into backing.
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        settle(0);
        imd.mint(address(body), 10_000 ether);
        settle(1);
        assertGt(body.backing(), 0);
        uint256 backingBefore = body.backing();

        // An unrelated holder burns one wei of PLANT.
        vm.prank(mallory);
        token.burn(1);

        // Alice unparks (still allowed) and tries to redeem: the backing is hers pro rata.
        vm.prank(alice);
        body.unpark(LISBON, 100 ether);
        vm.prank(alice);
        uint256 paid = body.redeem(100 ether);
        assertGt(paid, 0, "holder cannot redeem any backing after a one-wei burn");

        // And the organism must keep living: the next day's settle must still be accepted.
        settle(1);
        assertGt(body.backing(), backingBefore);
    }

    function test_lockPersistsThroughDeathSoBackingIsNeverRecoverable() public {
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        settle(0);
        imd.mint(address(body), 10_000 ether);
        settle(1);
        vm.prank(mallory);
        token.burn(1);
        // Settle is blocked, so 30 days later the plant is dead and redeem should pay the full floor.
        vm.warp(block.timestamp + 30 days);
        assertTrue(body.isDead());
        vm.prank(alice);
        body.unpark(LISBON, 100 ether);
        vm.prank(alice);
        uint256 paid = body.redeem(100 ether);
        assertGt(paid, 0, "dead-plant redemption is blocked: all IMD is locked forever");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract ScratchToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ScratchHook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// @dev The death clock starts at deployment, before bind. A bind 30 days after deployment
/// produces an organism that is dead before its first settle and can never be settled.
contract BornDeadTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    uint32 internal constant LISBON = 10223579;
    bytes32 internal constant QUESTION = keccak256("frozen test weather question");

    ScratchToken internal imd;
    ScratchToken internal token;
    PlantOrganism internal body;
    address internal alice = makeAddr("alice");

    function setUp() public {
        vm.chainId(4663);
        vm.warp(20000 days + 12 hours);
        imd = new ScratchToken();
        token = new ScratchToken();
        token.mint(alice, 1000 ether);
        body = new PlantOrganism(address(imd), vm.addr(KEY), LISBON, address(this));
    }

    function attestation(uint256 day) internal view returns (OracleAttestation.Attestation memory a) {
        bytes32[] memory words = new bytes32[](3);
        words[0] = bytes32((uint256(1) << 48) | (uint256(LISBON) << 64) | (day << 96));
        a = OracleAttestation.Attestation({
            requestId: bytes32(day),
            chainId: 4663,
            questionHash: QUESTION,
            answerType: 5,
            answer: abi.encode(words),
            figure: 0,
            fromBlock: 100,
            toBlock: 200,
            blockHash: bytes32(uint256(7)),
            panelJobId: bytes32(uint256(8)),
            panelSize: 5,
            quorum: 4,
            agreed: 5,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
    }

    function test_bindThirtyDaysAfterDeploymentIsDeadBeforeFirstSettle() public {
        // The second launch (PLANT + hook) lands 30 days after the organism was deployed.
        vm.warp(block.timestamp + 30 days);
        // Keep the day cursor current so the first bound settle is simply "tomorrow".
        OracleAttestation.Attestation memory blank;
        body.settle(blank, "");
        ScratchHook hook = new ScratchHook(address(body), address(token));
        body.bind(address(hook), QUESTION);
        assertTrue(body.bound());

        // Nothing ever succeeded or failed: no settle was possible before bind. The plant must be alive.
        assertFalse(body.isDead(), "organism is dead at the moment it is bound");

        // And the first settle, on the very next day, must be accepted.
        vm.prank(alice);
        token.approve(address(body), type(uint256).max);
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        vm.warp(block.timestamp + 1 days);
        OracleAttestation.Attestation memory a = attestation(body.lastSettledDay() + 1);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, body.attestationDigest(a));
        body.settle(a, abi.encodePacked(r, s, v));
        assertEq(body.location(), LISBON);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

/// @dev Minimal exact-transfer ERC-20 whose holders can burn their own tokens (ERC20Burnable-style).
contract BurnableToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract StubHook {
    address public organism;
    address public plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// @notice A single 1-wei burn by any PLANT holder makes redeem() revert forever, locking all backing IMD.
contract SupplyFreezeTest is Test {
    uint256 constant KEY = 0xA11CE;
    uint32 constant LISBON = 10223579;
    bytes32 constant QUESTION = keccak256("frozen question");
    BurnableToken imd;
    BurnableToken plant;
    PlantOrganism body;
    address alice = makeAddr("alice");
    address bob = makeAddr("bob");

    function setUp() public {
        vm.chainId(4663);
        vm.warp(20000 days + 12 hours);
        imd = new BurnableToken();
        plant = new BurnableToken();
        plant.mint(alice, 600 ether);
        plant.mint(bob, 400 ether);
        body = new PlantOrganism(address(imd), vm.addr(KEY), LISBON, address(this));
        body.bind(address(new StubHook(address(body), address(plant))), QUESTION);
        vm.prank(alice);
        plant.approve(address(body), type(uint256).max);
        vm.prank(bob);
        plant.approve(address(body), type(uint256).max);
    }

    function settleNext(uint24 sun, bool valid, uint32 cell) internal {
        uint256 day = body.lastSettledDay() + 1;
        vm.warp(day * 1 days + 12 hours);
        bytes32[] memory words = new bytes32[](3);
        words[0] = bytes32(uint256(sun) | (uint256(valid ? 1 : 0) << 48) | (uint256(cell) << 64) | (day << 96));
        OracleAttestation.Attestation memory a;
        a.requestId = bytes32(day);
        a.chainId = 4663;
        a.questionHash = QUESTION;
        a.answerType = 5;
        a.answer = abi.encode(words);
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, body.attestationDigest(a));
        body.settle(a, abi.encodePacked(r, s, v));
    }

    function test_oneWeiBurnByAnyHolderPermanentlyBlocksRedemptionOfBacking() public {
        // Birth at Lisbon, then one sunny hour so backing becomes nonzero.
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        settleNext(0, true, LISBON);
        imd.mint(address(body), 1000 ether);
        settleNext(1, false, 0);
        uint256 backingBefore = body.backing();
        assertGt(backingBefore, 0);

        // Bob, an ordinary holder, burns 1 wei of his own PLANT.
        vm.prank(bob);
        plant.burn(1);

        // Expected: holders can still redeem against the recorded backing.
        // Actual on current code: redeem reverts SupplyChanged, forever (settle reverts the same way,
        // so the plant dies in 30 days and redeem still reverts after death).
        vm.prank(bob);
        uint256 paid = body.redeem(100 ether);
        assertGt(paid, 0, "redeem paid nothing");
        assertEq(imd.balanceOf(bob), paid);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

/// @dev Minimal exact-transfer ERC-20 with a public burn, as OpenZeppelin ERC20Burnable gives any holder.
contract BurnableToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract Hook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// Finding: a one-wei change in PLANT.totalSupply() by any holder makes settle() AND redeem() revert
/// SupplyChanged forever. The plant then dies after 30 days, and the IMD backing can never be redeemed.
contract SupplyDriftLocksBackingTest is Test {
    uint256 constant KEY = 0xA11CE;
    uint32 constant LISBON = 10223579;
    bytes32 constant QUESTION = keccak256("q");
    BurnableToken imd;
    BurnableToken plant;
    PlantOrganism body;
    address alice = makeAddr("alice");
    address mallory = makeAddr("mallory");

    function setUp() public {
        vm.chainId(4663);
        vm.warp(20000 days + 12 hours);
        imd = new BurnableToken();
        plant = new BurnableToken();
        plant.mint(alice, 999 ether);
        plant.mint(mallory, 1 ether);
        body = new PlantOrganism(address(imd), vm.addr(KEY), LISBON, address(this));
        body.bind(address(new Hook(address(body), address(plant))), QUESTION);
        vm.prank(alice);
        plant.approve(address(body), type(uint256).max);
        // Give the plant some backing: birth, then one sunny day on 1000 IMD.
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        settleNext(0, true, LISBON);
        imd.mint(address(body), 1000 ether);
        settleNext(1, false, 0);
        assertGt(body.backing(), 0, "backing exists");
    }

    function settleNext(uint24 sun, bool valid, uint32 cell) internal {
        uint256 day = body.lastSettledDay() + 1;
        vm.warp(day * 1 days + 12 hours);
        bytes32[] memory words = new bytes32[](3);
        words[0] = bytes32(uint256(sun) | (uint256(valid ? 1 : 0) << 48) | (uint256(cell) << 64) | (day << 96));
        OracleAttestation.Attestation memory a;
        a.requestId = bytes32(day);
        a.chainId = 4663;
        a.questionHash = QUESTION;
        a.answerType = 5;
        a.answer = abi.encode(words);
        a.issuedAt = uint64(block.timestamp);
        a.expiresAt = uint64(block.timestamp + 1 days);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, body.attestationDigest(a));
        body.settle(a, abi.encodePacked(r, s, v));
    }

    /// Fails on the current code: after an unprivileged holder burns 1 wei of PLANT, alice can never
    /// redeem her 899 PLANT against the IMD backing. Passes once redeem no longer reverts on a supply
    /// decrease (the snapshot denominator already makes a decrease safe for backing).
    function test_oneWeiBurnByAnyHolderLocksAllBackingForever() public {
        vm.prank(mallory);
        plant.burn(1);

        // On the current code settle() now reverts SupplyChanged too, so no oracle can keep the plant
        // alive; it is dead 30 days later. (Not asserted, so a fix that also relaxes settle still passes.)
        vm.warp(block.timestamp + 31 days);
        assertTrue(body.isDead());
        assertGt(body.backing(), 0);

        // Even dead, redemption of the backing must remain possible; today it reverts SupplyChanged
        // and the IMD is stranded forever (only unpark/claim still work).
        vm.prank(alice);
        uint256 paid = body.redeem(100 ether); // Expected: alice's full-floor share. Actual: SupplyChanged.
        assertGt(paid, 0);
        assertEq(imd.balanceOf(alice), paid);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

/// @dev A PLANT token with a public burn, the ERC20Burnable shape launch tokens commonly expose.
contract BurnableToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function burn(uint256 amount) external {
        balanceOf[msg.sender] -= amount;
        totalSupply -= amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ScratchHook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// @dev One wei of PLANT burned by any holder makes redeem revert SupplyChanged forever, alive or dead,
/// so the IMD backing that the brief calls "redeemable" can never be redeemed by anyone.
contract SupplyDriftLocksBackingTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    uint32 internal constant LISBON = 10223579;
    bytes32 internal constant QUESTION = keccak256("frozen test weather question");

    BurnableToken internal imd;
    BurnableToken internal token;
    PlantOrganism internal body;
    address internal alice = makeAddr("alice");
    address internal mallory = makeAddr("mallory");

    function setUp() public {
        vm.chainId(4663);
        vm.warp(20000 days + 12 hours);
        imd = new BurnableToken();
        token = new BurnableToken();
        token.mint(alice, 999 ether);
        token.mint(mallory, 1 ether);
        body = new PlantOrganism(address(imd), vm.addr(KEY), LISBON, address(this));
        ScratchHook hook = new ScratchHook(address(body), address(token));
        body.bind(address(hook), QUESTION);
        vm.prank(alice);
        token.approve(address(body), type(uint256).max);

        // Birth at Lisbon, then 10 000 IMD arrives and one sunny hour turns a tenth of it into backing.
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        settle(0);
        imd.mint(address(body), 10_000 ether);
        settle(1);
        assertGt(body.backing(), 0);
        vm.prank(alice);
        body.unpark(LISBON, 100 ether);
    }

    function attestation(uint256 day, uint24 sun) internal view returns (OracleAttestation.Attestation memory a) {
        bytes32[] memory words = new bytes32[](3);
        words[0] = bytes32(uint256(sun) | (uint256(1) << 48) | (uint256(LISBON) << 64) | (day << 96));
        a = OracleAttestation.Attestation({
            requestId: bytes32(day),
            chainId: 4663,
            questionHash: QUESTION,
            answerType: 5,
            answer: abi.encode(words),
            figure: 0,
            fromBlock: 100,
            toBlock: 200,
            blockHash: bytes32(uint256(7)),
            panelJobId: bytes32(uint256(8)),
            panelSize: 5,
            quorum: 4,
            agreed: 5,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
    }

    function settle(uint24 sun) internal {
        uint256 day = body.lastSettledDay() + 1;
        if (block.timestamp / 1 days < day) vm.warp(day * 1 days + 12 hours);
        OracleAttestation.Attestation memory a = attestation(day, sun);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, body.attestationDigest(a));
        body.settle(a, abi.encodePacked(r, s, v));
    }

    function test_oneWeiBurnByAnyHolderBlocksLiveRedemptionOfBacking() public {
        uint256 backingBefore = body.backing();
        uint256 expected = 100 ether * backingBefore / 1000 ether * 9 / 10;

        // An unrelated holder burns one wei of PLANT. Nothing the organism owes has changed.
        vm.prank(mallory);
        token.burn(1);

        vm.prank(alice);
        uint256 paid = body.redeem(100 ether);
        assertEq(paid, expected, "live redemption must pay amount x backing / remaining x 90%");
    }

    function test_oneWeiBurnLocksBackingEvenAfterDeath() public {
        vm.prank(mallory);
        token.burn(1);

        // No settle can land, so the plant dies; death must still let holders exit at full floor.
        vm.warp(block.timestamp + 30 days);
        assertTrue(body.isDead());
        uint256 full = body.backing();
        assertGt(full, 0);

        vm.prank(alice);
        uint256 paid = body.redeem(100 ether);
        assertEq(paid, 100 ether * full / 1000 ether, "dead redemption must pay the full floor");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {PlantOrganism} from "src/PlantOrganism.sol";
import {OracleAttestation} from "src/OracleAttestation.sol";

contract ScratchToken {
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        totalSupply += amount;
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;
        return true;
    }
}

contract ScratchHook {
    address public immutable organism;
    address public immutable plant;

    constructor(address organism_, address plant_) {
        organism = organism_;
        plant = plant_;
    }
}

/// @dev The 30-day death clock runs from deployment although no settle can succeed before bind.
/// Binding 30 days after deployment yields an organism that is dead the moment bind returns.
/// The test accepts either repair: bind refuses to bind a body that would be dead, or a body that
/// bind accepts is alive and settles.
contract BornDeadTest is Test {
    uint256 internal constant KEY = 0xA11CE;
    uint32 internal constant LISBON = 10223579;
    bytes32 internal constant QUESTION = keccak256("frozen test weather question");

    ScratchToken internal imd;
    ScratchToken internal token;
    PlantOrganism internal body;
    address internal alice = makeAddr("alice");

    function setUp() public {
        vm.chainId(4663);
        vm.warp(20000 days + 12 hours);
        imd = new ScratchToken();
        token = new ScratchToken();
        token.mint(alice, 1000 ether);
        body = new PlantOrganism(address(imd), vm.addr(KEY), LISBON, address(this));
        imd.mint(address(body), 1000 ether);
    }

    function attestation(uint256 day) internal view returns (OracleAttestation.Attestation memory a) {
        bytes32[] memory words = new bytes32[](3);
        words[0] = bytes32((uint256(1) << 48) | (uint256(LISBON) << 64) | (day << 96));
        a = OracleAttestation.Attestation({
            requestId: bytes32(day),
            chainId: 4663,
            questionHash: QUESTION,
            answerType: 5,
            answer: abi.encode(words),
            figure: 0,
            fromBlock: 100,
            toBlock: 200,
            blockHash: bytes32(uint256(7)),
            panelJobId: bytes32(uint256(8)),
            panelSize: 5,
            quorum: 4,
            agreed: 5,
            issuedAt: uint64(block.timestamp),
            expiresAt: uint64(block.timestamp + 1 days)
        });
    }

    function test_bindThirtyDaysAfterDeploymentMustNotYieldADeadBody() public {
        // The second launch (PLANT + hook) lands 30 days after the organism was deployed.
        vm.warp(block.timestamp + 30 days);
        OracleAttestation.Attestation memory blank;
        body.settle(blank, ""); // keep the day cursor current, as the README advises
        assertFalse(body.isDead(), "unbound body is never dead");

        ScratchHook hook = new ScratchHook(address(body), address(token));
        (bool ok,) = address(body).call(abi.encodeCall(body.bind, (address(hook), QUESTION)));
        if (!ok) return; // a bind that refuses a body past its deadline is an acceptable repair

        // bind accepted: a body that has never had a chance to settle must be alive ...
        assertFalse(body.isDead(), "organism is dead at the moment it is bound");
        assertEq(body.pot(), 1000 ether, "pot already merged into dead backing");

        // ... and must accept its first in-order settle on the next day.
        vm.prank(alice);
        token.approve(address(body), type(uint256).max);
        vm.prank(alice);
        body.park(LISBON, 100 ether);
        vm.warp(block.timestamp + 1 days);
        OracleAttestation.Attestation memory a = attestation(body.lastSettledDay() + 1);
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(KEY, body.attestationDigest(a));
        body.settle(a, abi.encodePacked(r, s, v));
        assertEq(body.location(), LISBON);
    }
}