// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {OGClubBox} from "src/OGClubBox.sol";
import {OGClubFurniture} from "src/OGClubFurniture.sol";
import {MockOG} from "src/mocks/MockOG.sol";

/// @notice A paid, honest roll must survive the furniture owner revoking the box's minter role.
/// @dev Fails on the current code: `open` reverts with NotMinter while the box is revoked, and once the
///      256-block window passes the only possible outcome is the fallback piece. Passes once `open` records
///      the roll independently of delivery and `deliver(purchaseId)` mints the stored items later.
contract MinterRevokedRollLostTest is Test {
    MockOG internal token;
    OGClubFurniture internal furniture;
    OGClubBox internal box;
    address internal buyer = makeAddr("buyer");
    address internal vault = makeAddr("vault");
    uint256 internal seasonId;

    uint256 internal constant FALLBACK = 1;
    uint256 internal constant COMMON_PIECE = 2;

    function setUp() public {
        vm.roll(100);
        vm.warp(1000);
        token = new MockOG(address(this));
        furniture = new OGClubFurniture(address(this), vault);
        box = new OGClubBox(token, furniture, vault, address(this));
        _grant(address(box));
        token.mint(buyer, 1_000_000 ether);
        vm.prank(buyer);
        token.approve(address(box), type(uint256).max);

        OGClubBox.Entry[] memory entries = new OGClubBox.Entry[](2);
        entries[0] = OGClubBox.Entry(FALLBACK, 0, 1, 0);
        entries[1] = OGClubBox.Entry(COMMON_PIECE, 0, 1_000_000, 0);
        seasonId = box.createSeason(1, 1000, 100_000, 0, FALLBACK, entries);
    }

    function test_rollRecordedAtOpenSurvivesRevokedMinterAndExpiry() public {
        vm.prank(buyer);
        uint256 purchaseId = box.buy(seasonId, 3);
        (,,, uint256 targetBlock,) = box.purchases(purchaseId);

        // Furniture owner revokes the box while the purchase is pending.
        _revoke(address(box));

        // Target header is available; this is the honest roll the buyer paid for.
        bytes32 randao = keccak256("og-club-proof");
        bytes memory header = _header(targetBlock, randao);
        vm.roll(targetBlock + 1);
        vm.setBlockhash(targetBlock, keccak256(header));
        uint256[] memory expected = box.previewOpen(purchaseId, randao);
        uint256 expectedCommon;
        for (uint256 i; i < expected.length; ++i) {
            if (expected[i] == COMMON_PIECE) ++expectedCommon;
        }
        assertGt(expectedCommon, 0, "fixture: honest roll must contain a non-fallback piece");

        // Anyone tries to open inside the window. On the current code this reverts (NotMinter).
        (bool openedInWindow,) = address(box).call(abi.encodeCall(box.open, (purchaseId, header)));

        // The window passes, then the furniture owner restores the box.
        vm.roll(targetBlock + 257 + 10);
        _grant(address(box));

        (,,,, bool opened) = box.purchases(purchaseId);
        if (!opened) {
            // Current code: the only remaining path, which mints fallbacks.
            box.open(purchaseId, header);
        } else {
            assertTrue(openedInWindow, "open must not revert because of delivery");
            (bool ok, bytes memory reason) =
                address(box).call(abi.encodeWithSignature("deliver(uint256)", purchaseId));
            require(ok, string(reason));
        }

        // The buyer must receive exactly the roll recorded in the window, not fallbacks.
        assertEq(furniture.balanceOf(buyer, COMMON_PIECE), expectedCommon, "honest roll was lost");
        assertEq(furniture.balanceOf(buyer, FALLBACK), expected.length - expectedCommon, "fallbacks replaced the roll");
    }

    // ---- helpers that work before and after the minter API change ----

    function _grant(address minter) internal {
        (bool ok,) = address(furniture).call(abi.encodeWithSignature("setMinter(address,bool)", minter, true));
        if (!ok) {
            (ok,) = address(furniture).call(abi.encodeWithSignature("grantMinter(address)", minter));
            if (ok && !furniture.minters(minter)) {
                vm.warp(block.timestamp + 7 days + 1);
                (ok,) = address(furniture).call(abi.encodeWithSignature("activateMinter(address)", minter));
            }
        }
        require(ok && furniture.minters(minter), "grant failed");
    }

    function _revoke(address minter) internal {
        (bool ok,) = address(furniture).call(abi.encodeWithSignature("setMinter(address,bool)", minter, false));
        if (!ok) (ok,) = address(furniture).call(abi.encodeWithSignature("revokeMinter(address)", minter));
        require(ok && !furniture.minters(minter), "revoke failed");
    }

    // Minimal RLP header with 14 fields: field 8 = number, field 13 = prevRandao.
    function _header(uint256 number, bytes32 randao) internal pure returns (bytes memory) {
        bytes memory payload;
        for (uint256 i; i < 14; ++i) {
            if (i == 8) payload = bytes.concat(payload, _str(_uintBytes(number)));
            else if (i == 13) payload = bytes.concat(payload, _str(abi.encodePacked(randao)));
            else payload = bytes.concat(payload, hex"80");
        }
        return bytes.concat(_prefix(payload.length, 0xc0), payload);
    }

    function _uintBytes(uint256 value) internal pure returns (bytes memory result) {
        uint256 length;
        for (uint256 n = value; n != 0; n >>= 8) {
            ++length;
        }
        result = new bytes(length);
        for (uint256 i; i < length; ++i) {
            result[length - 1 - i] = bytes1(uint8(value >> (8 * i)));
        }
    }

    function _str(bytes memory value) internal pure returns (bytes memory) {
        if (value.length == 1 && uint8(value[0]) < 0x80) return value;
        return bytes.concat(_prefix(value.length, 0x80), value);
    }

    function _prefix(uint256 length, uint8 base) internal pure returns (bytes memory) {
        if (length < 56) return abi.encodePacked(bytes1(uint8(length) + base));
        bytes memory size = _uintBytes(length);
        return bytes.concat(abi.encodePacked(bytes1(base + 55 + uint8(size.length))), size);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {OGClubBox} from "src/OGClubBox.sol";
import {OGClubFurniture} from "src/OGClubFurniture.sol";
import {MockOG} from "src/mocks/MockOG.sol";

/// @dev A buyer contract with no ERC-1155 receiver hooks (a plain multisig-style wallet or a vault).
contract PlainWalletBuyer {
    OGClubBox public immutable box;

    constructor(OGClubBox box_, IERC20 token_) {
        box = box_;
        token_.approve(address(box_), type(uint256).max);
    }

    function buy(uint256 seasonId, uint256 count) external returns (uint256) {
        return box.buy(seasonId, count);
    }

    function deliverTo(uint256 purchaseId, address to) external {
        (bool ok, bytes memory reason) =
            address(box).call(abi.encodeWithSignature("deliverTo(uint256,address)", purchaseId, to));
        require(ok, string(reason));
    }
}

/// @notice The box accepts payment from a contract buyer that cannot receive ERC-1155 tokens, then can never
///         open its purchase: every `open` reverts in the receiver check, before and after expiry, so the
///         payment is lost and the roll is never recorded.
/// @dev Fails on the current code at the first assertion (open reverts because delivery fails). Passes once
///      `open` records the roll and reports DeliveryFailed, and the buyer can `deliverTo` another address.
contract NonReceiverBuyerLosesPurchaseTest is Test {
    MockOG internal token;
    OGClubFurniture internal furniture;
    OGClubBox internal box;
    PlainWalletBuyer internal wallet;
    address internal vault = makeAddr("vault");
    address internal eoa = makeAddr("eoa");
    uint256 internal seasonId;

    function setUp() public {
        vm.roll(100);
        vm.warp(1000);
        token = new MockOG(address(this));
        furniture = new OGClubFurniture(address(this), vault);
        box = new OGClubBox(token, furniture, vault, address(this));
        _grant(address(box));
        wallet = new PlainWalletBuyer(box, token);
        token.mint(address(wallet), 1_000_000 ether);

        OGClubBox.Entry[] memory entries = new OGClubBox.Entry[](2);
        entries[0] = OGClubBox.Entry(1, 0, 60, 0);
        entries[1] = OGClubBox.Entry(2, 1, 40, 0);
        seasonId = box.createSeason(100, 1000, 100_000, 5000, 1, entries);
    }

    function test_openDoesNotRevertForNonReceiverBuyerAndBuyerCanRedirectDelivery() public {
        uint256 balanceBefore = token.balanceOf(address(wallet));
        uint256 purchaseId = wallet.buy(seasonId, 2);
        assertEq(token.balanceOf(address(wallet)), balanceBefore - 200, "buyer paid in full");
        (,,, uint256 targetBlock,) = box.purchases(purchaseId);

        bytes32 randao = keccak256("og-club-proof-2");
        bytes memory header = _header(targetBlock, randao);
        vm.roll(targetBlock + 1);
        vm.setBlockhash(targetBlock, keccak256(header));
        uint256[] memory expected = box.previewOpen(purchaseId, randao);

        (bool ok,) = address(box).call(abi.encodeCall(box.open, (purchaseId, header)));
        assertTrue(ok, "open reverted because the buyer cannot receive ERC-1155: paid roll is unrecoverable");

        (,,,, bool opened) = box.purchases(purchaseId);
        assertTrue(opened, "purchase must be marked opened");

        // The buyer redirects delivery to an address that can hold the pieces.
        wallet.deliverTo(purchaseId, eoa);
        uint256 total;
        for (uint256 i; i < expected.length; ++i) {
            total += 1;
            assertGt(furniture.balanceOf(eoa, expected[i]), 0, "expected piece not delivered");
        }
        assertEq(furniture.balanceOf(eoa, 1) + furniture.balanceOf(eoa, 2), total, "delivered count");
    }

    function _grant(address minter) internal {
        (bool ok,) = address(furniture).call(abi.encodeWithSignature("setMinter(address,bool)", minter, true));
        if (!ok) (ok,) = address(furniture).call(abi.encodeWithSignature("grantMinter(address)", minter));
        require(ok && furniture.minters(minter), "grant failed");
    }

    function _header(uint256 number, bytes32 randao) internal pure returns (bytes memory) {
        bytes memory payload;
        for (uint256 i; i < 14; ++i) {
            if (i == 8) payload = bytes.concat(payload, _str(_uintBytes(number)));
            else if (i == 13) payload = bytes.concat(payload, _str(abi.encodePacked(randao)));
            else payload = bytes.concat(payload, hex"80");
        }
        return bytes.concat(_prefix(payload.length, 0xc0), payload);
    }

    function _uintBytes(uint256 value) internal pure returns (bytes memory result) {
        uint256 length;
        for (uint256 n = value; n != 0; n >>= 8) {
            ++length;
        }
        result = new bytes(length);
        for (uint256 i; i < length; ++i) {
            result[length - 1 - i] = bytes1(uint8(value >> (8 * i)));
        }
    }

    function _str(bytes memory value) internal pure returns (bytes memory) {
        if (value.length == 1 && uint8(value[0]) < 0x80) return value;
        return bytes.concat(_prefix(value.length, 0x80), value);
    }

    function _prefix(uint256 length, uint8 base) internal pure returns (bytes memory) {
        if (length < 56) return abi.encodePacked(bytes1(uint8(length) + base));
        bytes memory size = _uintBytes(length);
        return bytes.concat(abi.encodePacked(bytes1(base + 55 + uint8(size.length))), size);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

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

/// @notice Once the collection exists, the furniture owner can authorize itself and mint any piece, in any
///         quantity, in the same block, bypassing every season cap and the box's odds.
/// @dev Fails on the current code: `setMinter(owner, true)` then `mintBatch` succeeds immediately. Passes once a
///      new minter proposed after the first mint must wait MINTER_DELAY before it can mint.
contract OwnerMintsImmediatelyTest is Test {
    OGClubFurniture internal furniture;
    address internal firstMinter = makeAddr("box");
    address internal holder = makeAddr("holder");
    address internal royalty = makeAddr("royalty");
    uint256 internal constant CAPPED_PIECE = 3;

    function setUp() public {
        vm.warp(1000);
        furniture = new OGClubFurniture(address(this), royalty);
        // Fresh deployment: authorizing the box is immediate in both designs.
        _grant(firstMinter);
        // The collection now exists: one copy of a piece the box sells with a cap of 1.
        uint256[] memory ids = new uint256[](1);
        uint256[] memory amounts = new uint256[](1);
        ids[0] = CAPPED_PIECE;
        amounts[0] = 1;
        vm.prank(firstMinter);
        furniture.mintBatch(holder, ids, amounts);
        assertEq(furniture.totalSupply(CAPPED_PIECE), 1);
    }

    function test_ownerCannotMintPastCapImmediatelyAfterAuthorizingItself() public {
        // Owner authorizes itself (setMinter today, grantMinter after the change).
        (bool ok,) = address(furniture).call(abi.encodeWithSignature("setMinter(address,bool)", address(this), true));
        if (!ok) (ok,) = address(furniture).call(abi.encodeWithSignature("grantMinter(address)", address(this)));
        require(ok, "owner could not request minter role");

        // Same block: owner mints 100 more copies of the capped piece.
        uint256[] memory ids = new uint256[](1);
        uint256[] memory amounts = new uint256[](1);
        ids[0] = CAPPED_PIECE;
        amounts[0] = 100;
        (bool minted,) = address(furniture).call(abi.encodeCall(furniture.mintBatch, (holder, ids, amounts)));

        assertFalse(minted, "owner minted a capped piece past its cap with no delay");
        assertEq(furniture.totalSupply(CAPPED_PIECE), 1, "supply inflated by the owner");
    }

    function _grant(address minter) internal {
        (bool ok,) = address(furniture).call(abi.encodeWithSignature("setMinter(address,bool)", minter, true));
        if (!ok) (ok,) = address(furniture).call(abi.encodeWithSignature("grantMinter(address)", minter));
        require(ok && furniture.minters(minter), "grant failed");
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {OGClubBox} from "src/OGClubBox.sol";
import {OGClubFurniture} from "src/OGClubFurniture.sol";
import {MockOG} from "src/mocks/MockOG.sol";

/// @dev Minimal RLP header builder: 16 fields, field 8 = number, field 13 = mixHash.
library MiniHeader {
    function rlpBytes(bytes memory s) internal pure returns (bytes memory) {
        if (s.length == 1 && uint8(s[0]) < 0x80) return s;
        return bytes.concat(prefix(s.length, 0x80), s);
    }

    function prefix(uint256 len, uint8 base) internal pure returns (bytes memory) {
        if (len < 56) return abi.encodePacked(uint8(base + len));
        bytes memory lenBytes = uintBytes(len);
        return bytes.concat(abi.encodePacked(uint8(base + 55 + lenBytes.length)), lenBytes);
    }

    function uintBytes(uint256 v) internal pure returns (bytes memory out) {
        if (v == 0) return out;
        uint256 n;
        for (uint256 t = v; t != 0; t >>= 8) ++n;
        out = new bytes(n);
        for (uint256 i; i < n; ++i) {
            out[n - 1 - i] = bytes1(uint8(v >> (8 * i)));
        }
    }

    function header(uint256 number, bytes32 mixHash) internal pure returns (bytes memory) {
        bytes memory payload;
        for (uint256 i; i < 16; ++i) {
            bytes memory field;
            if (i == 8) field = uintBytes(number);
            else if (i == 13) field = abi.encodePacked(mixHash);
            else if (i == 2) field = abi.encodePacked(address(0xBEEF));
            else if (i == 0 || i == 1 || i == 3 || i == 4 || i == 5) field = abi.encodePacked(bytes32(uint256(i + 1)));
            else if (i == 6) field = new bytes(256);
            else field = uintBytes(i + 1);
            payload = bytes.concat(payload, rlpBytes(field));
        }
        return bytes.concat(prefix(payload.length, 0xc0), payload);
    }
}

/// @notice An EOA buyer whose box is an authorized minter must either be delivered at open or see open revert.
///         Today a caller that supplies 1.5x the gas a successful open consumes gets DeliveryFailed instead,
///         because the mint is starved of gas inside try/catch while the catch path still fits.
contract OpenGasDeliveryTest is Test {
    MockOG internal token;
    OGClubFurniture internal furniture;
    OGClubBox internal box;
    address internal buyer = makeAddr("buyer");
    uint256 internal seasonId;

    function setUp() public {
        vm.roll(100);
        vm.warp(1000);
        token = new MockOG(address(this));
        furniture = new OGClubFurniture(address(this), address(this));
        box = new OGClubBox(token, furniture, makeAddr("vault"), address(this));
        furniture.grantMinter(address(box));
        token.mint(buyer, 1_000_000 ether);
        vm.prank(buyer);
        token.approve(address(box), type(uint256).max);
        OGClubBox.Entry[] memory entries = new OGClubBox.Entry[](3);
        entries[0] = OGClubBox.Entry(1, 0, 60, 0);
        entries[1] = OGClubBox.Entry(2, 1, 30, 4);
        entries[2] = OGClubBox.Entry(3, 2, 10, 3);
        seasonId = box.createSeason(101, 1000, 100_000, 3333, 1, entries);
    }

    function _ready(uint256 purchaseId, bytes32 randao) internal returns (bytes memory header) {
        (,,, uint256 targetBlock,) = box.purchases(purchaseId);
        vm.roll(targetBlock + 1);
        header = MiniHeader.header(targetBlock, randao);
        vm.setBlockhash(targetBlock, keccak256(header));
    }

    function test_OpenWithEstimatedGasPlusHalfMustDeliverOrRevert() public {
        vm.prank(buyer);
        uint256 purchase = box.buy(seasonId, 10);
        bytes memory header = _ready(purchase, keccak256("gas estimate"));

        // Measure what a fully funded, successful open consumes: this is what eth_estimateGas reports.
        uint256 snapshot = vm.snapshotState();
        uint256 before = gasleft();
        box.open(purchase, header);
        uint256 used = before - gasleft();
        assertTrue(box.delivered(purchase), "fully funded open delivers");
        assertTrue(vm.revertToState(snapshot));

        // Same call with 1.5x that measurement, as a wallet with a generous buffer would send it.
        uint256 limit = used * 3 / 2;
        (bool ok,) = address(box).call{gas: limit}(abi.encodeCall(box.open, (purchase, header)));
        (,,,, bool opened) = box.purchases(purchase);
        if (ok) {
            assertTrue(opened);
            assertTrue(
                box.delivered(purchase),
                "open succeeded with 1.5x the measured gas but silently took the DeliveryFailed path"
            );
            assertEq(box.getStoredItems(purchase).length, 0, "normal path must add no storage");
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {Test} from "forge-std/Test.sol";
import {OGClubBox} from "src/OGClubBox.sol";
import {OGClubFurniture} from "src/OGClubFurniture.sol";
import {MockOG} from "src/mocks/MockOG.sol";

/// @dev Minimal RLP header builder: 16 fields, field 8 = number, field 13 = mixHash.
library MiniHeader {
    function rlpBytes(bytes memory s) internal pure returns (bytes memory) {
        if (s.length == 1 && uint8(s[0]) < 0x80) return s;
        return bytes.concat(prefix(s.length, 0x80), s);
    }

    function prefix(uint256 len, uint8 base) internal pure returns (bytes memory) {
        if (len < 56) return abi.encodePacked(uint8(base + len));
        bytes memory lenBytes = uintBytes(len);
        return bytes.concat(abi.encodePacked(uint8(base + 55 + lenBytes.length)), lenBytes);
    }

    function uintBytes(uint256 v) internal pure returns (bytes memory out) {
        if (v == 0) return out;
        uint256 n;
        for (uint256 t = v; t != 0; t >>= 8) ++n;
        out = new bytes(n);
        for (uint256 i; i < n; ++i) {
            out[n - 1 - i] = bytes1(uint8(v >> (8 * i)));
        }
    }

    function header(uint256 number, bytes32 mixHash) internal pure returns (bytes memory) {
        bytes memory payload;
        for (uint256 i; i < 16; ++i) {
            bytes memory field;
            if (i == 8) field = uintBytes(number);
            else if (i == 13) field = abi.encodePacked(mixHash);
            else if (i == 2) field = abi.encodePacked(address(0xBEEF));
            else if (i == 0 || i == 1 || i == 3 || i == 4 || i == 5) field = abi.encodePacked(bytes32(uint256(i + 1)));
            else if (i == 6) field = new bytes(256);
            else field = uintBytes(i + 1);
            payload = bytes.concat(payload, rlpBytes(field));
        }
        return bytes.concat(prefix(payload.length, 0xc0), payload);
    }
}

/// @notice An EOA buyer whose box is an authorized minter must either be delivered at open or see open revert.
///         Today a caller that supplies 1.5x the gas a successful open consumes gets DeliveryFailed instead,
///         because the mint is starved of gas inside try/catch while the catch path still fits.
contract OpenGasDeliveryTest is Test {
    MockOG internal token;
    OGClubFurniture internal furniture;
    OGClubBox internal box;
    address internal buyer = makeAddr("buyer");
    uint256 internal seasonId;

    function setUp() public {
        vm.roll(100);
        vm.warp(1000);
        token = new MockOG(address(this));
        furniture = new OGClubFurniture(address(this), address(this));
        box = new OGClubBox(token, furniture, makeAddr("vault"), address(this));
        furniture.grantMinter(address(box));
        token.mint(buyer, 1_000_000 ether);
        vm.prank(buyer);
        token.approve(address(box), type(uint256).max);
        OGClubBox.Entry[] memory entries = new OGClubBox.Entry[](3);
        entries[0] = OGClubBox.Entry(1, 0, 60, 0);
        entries[1] = OGClubBox.Entry(2, 1, 30, 4);
        entries[2] = OGClubBox.Entry(3, 2, 10, 3);
        seasonId = box.createSeason(101, 1000, 100_000, 3333, 1, entries);
    }

    function _ready(uint256 purchaseId, bytes32 randao) internal returns (bytes memory header) {
        (,,, uint256 targetBlock,) = box.purchases(purchaseId);
        vm.roll(targetBlock + 1);
        header = MiniHeader.header(targetBlock, randao);
        vm.setBlockhash(targetBlock, keccak256(header));
    }

    function test_OpenWithEstimatedGasPlusHalfMustDeliverOrRevert() public {
        vm.prank(buyer);
        uint256 purchase = box.buy(seasonId, 10);
        bytes memory header = _ready(purchase, keccak256("gas estimate"));

        // Measure what a fully funded, successful open consumes: this is what eth_estimateGas reports.
        uint256 snapshot = vm.snapshotState();
        uint256 before = gasleft();
        box.open(purchase, header);
        uint256 used = before - gasleft();
        assertTrue(box.delivered(purchase), "fully funded open delivers");
        assertTrue(vm.revertToState(snapshot));

        // Same call with 1.5x that measurement, as a wallet with a generous buffer would send it.
        uint256 limit = used * 3 / 2;
        (bool ok,) = address(box).call{gas: limit}(abi.encodeCall(box.open, (purchase, header)));
        (,,,, bool opened) = box.purchases(purchase);
        if (ok) {
            assertTrue(opened);
            assertTrue(
                box.delivered(purchase),
                "open succeeded with 1.5x the measured gas but silently took the DeliveryFailed path"
            );
            assertEq(box.getStoredItems(purchase).length, 0, "normal path must add no storage");
        }
    }
}