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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {IMD6900Hook} from "src/IMD6900Hook.sol";
import {IMD6900LockedPool} from "src/IMD6900LockedPool.sol";
import {IMD6900RobinhoodLaunch} from "src/IMD6900RobinhoodLaunch.sol";
import {PerpEngine} from "src/perps/PerpEngine.sol";
import {PerpVault} from "src/perps/PerpVault.sol";

/// ENGINE_CODE_HASH in IMD6900LockedPool is not the keccak256 of the PerpEngine this repository builds (solc 0.8.26,
/// via-IR, 200 runs, cancun, bytecode_hash none), so createPerps refuses the only code that exists and the perps can
/// never be created the way the launch documents. Fails now with NotThePerpsCode(); passes once the constant matches
/// the source (or the source matches the constant).
contract PerpsCodeHashProof is Test {
    address constant OWNER = address(0xA11CE);
    address constant TL = address(0x71E10C);
    uint256 constant SUPPLY = 1_000_000_000 ether;

    IPoolManager PM;
    IMD6900RobinhoodLaunch L;
    IMD6900LockedPool pool;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        L = new IMD6900RobinhoodLaunch(OWNER, PM, address(0xBEEF), TL);
        L.createHook(_mineHook(L));
        pool = L.pool();
        bytes32 salt = _mineCoin(L);
        address expected = L.tokenAddress(salt);
        uint160 price = uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether)));
        vm.deal(OWNER, 2.81 ether);
        vm.prank(OWNER);
        L.launch{value: 2.81 ether}(salt, expected, price, 0, address(L));
    }

    function test_CreatePerpsAcceptsTheEngineThisRepositoryBuilds() public {
        assertEq(keccak256(type(PerpVault).creationCode), pool.VAULT_CODE_HASH(), "the vault hash matches the build");
        assertEq(keccak256(type(PerpEngine).creationCode), pool.ENGINE_CODE_HASH(), "the engine hash matches the build");
        vm.deal(address(this), 1 ether);
        (address e, address v) =
            pool.createPerps{value: 0.05 ether}(type(PerpEngine).creationCode, type(PerpVault).creationCode);
        assertTrue(e != address(0) && v != address(0));
        assertEq(IMD6900Hook(L.hook()).perpEngine(), e, "wired at once");
    }

    function _mineHook(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {
        bytes32 initHash = l.hookInitCodeHash();
        uint160 flags = l.FLAGS();
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);
        }
    }

    function _mineCoin(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {
        bytes32 initHash = l.tokenInitCodeHash();
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));
            if (uint160(a) >> 144 == 0x6900) return bytes32(i);
        }
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        y = x;
        uint256 z = (x + 1) / 2;
        while (z < y) (y, z) = (z, (x / z + z) / 2);
    }
}

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

import {Test} from "forge-std/Test.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {PoolManager} from "@uniswap/v4-core/src/PoolManager.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {IMD6900Hook} from "src/IMD6900Hook.sol";
import {IMD6900LockedPool} from "src/IMD6900LockedPool.sol";
import {IMD6900RobinhoodLaunch} from "src/IMD6900RobinhoodLaunch.sol";
import {PerpEngine} from "src/perps/PerpEngine.sol";
import {PerpVault} from "src/perps/PerpVault.sol";

interface IERC20Min {
    function balanceOf(address) external view returns (uint256);
    function approve(address, uint256) external returns (bool);
    function transfer(address, uint256) external returns (bool);
}

/// A plain trader: swaps through the PoolManager as any router would
contract Trader {
    IPoolManager immutable pm;
    PoolKey key;
    constructor(IPoolManager pm_) { pm = pm_; }
    function swap(PoolKey calldata k, bool buy, int256 amountSpecified) external payable returns (BalanceDelta d) {
        key = k;
        d = abi.decode(pm.unlock(abi.encode(buy, amountSpecified)), (BalanceDelta));
    }
    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        (bool buy, int256 amt) = abi.decode(data, (bool, int256));
        BalanceDelta d = pm.swap(key, SwapParams(buy, amt, buy ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1), "");
        _settle(key.currency0, d.amount0());
        _settle(key.currency1, d.amount1());
        return abi.encode(d);
    }
    function _settle(Currency c, int128 v) internal {
        if (v < 0) {
            if (c.isAddressZero()) pm.settle{value: uint128(-v)}();
            else { pm.sync(c); IERC20Min(Currency.unwrap(c)).transfer(address(pm), uint128(-v)); pm.settle(); }
        } else if (v > 0) pm.take(c, address(this), uint128(v));
    }
    receive() external payable {}
}

/// PerpSwapLib.swapLeg takes the engine's fee refund (IMD6900LockedPool.feeRefund -> PoolManager.take of the input
/// currency) BEFORE the engine settles its own input. PoolManager.take pays from its balance, so when the manager
/// holds less ETH than the refund (4.65% of the engine's buy), the take fails with OutOfFunds and the whole swap
/// reverts. That is the pool's state once the timelock sells the held coins back for the opening buy's ETH
/// (sellHeld, as designed): from then on every engine buy reverts: openLong, a short's close, a short's
/// liquidation (inside the hook's pre-trade sweep: SweepUnavailable for everyone's trade while a short is open).
/// Fails now (openLong reverts); passes once the input is settled before the refund is taken.
contract RefundTakenBeforeSettleProof is Test {
    address constant OWNER = address(0xA11CE);
    address constant TL = address(0x71E10C);
    address constant STAKER = address(0x57A4E);
    uint256 constant SUPPLY = 1_000_000_000 ether;

    IPoolManager PM;
    IMD6900RobinhoodLaunch L;
    IMD6900Hook hook;
    IMD6900LockedPool pool;
    PerpEngine engine;
    PerpVault vault;
    address t;
    PoolKey k;

    function setUp() public {
        PM = IPoolManager(address(new PoolManager(address(this))));
        L = new IMD6900RobinhoodLaunch(OWNER, PM, address(0xBEEF), TL);
        hook = L.createHook(_mineHook(L));
        pool = L.pool();
        bytes32 salt = _mineCoin(L);
        address expected = L.tokenAddress(salt);
        uint160 price = uint160(_sqrt(FullMath.mulDiv(SUPPLY, 1 << 192, 19.18 ether)));
        vm.deal(OWNER, 2.81 ether);
        vm.prank(OWNER);
        (t,) = L.launch{value: 2.81 ether}(salt, expected, price, 0, address(L));
        k = pool.poolKey();
        // the perps as the timelock could wire them (createPerps is closed by the hash mismatch, a separate finding)
        engine = new PerpEngine(PM, address(hook), t, pool.fee(), 60, address(L), address(this));
        vault = new PerpVault(address(engine));
        engine.setVault(address(vault));
        engine.fundInsurance{value: 0.05 ether}();
        engine.transferOwnership(TL);
        vm.startPrank(TL);
        hook.setPerpEngine(address(engine));
        hook.setPerpRefunded(true);
        vm.stopPrank();
        vm.deal(STAKER, 20 ether);
        vm.prank(STAKER);
        vault.depositEth{value: 10 ether}();
    }

    function test_ALongOpensAfterTheHeldCoinsAreSoldBack() public {
        vm.prank(TL);
        L.sellHeld(0, 0, TL);
        assertLt(address(PM).balance, 0.02 ether, "the manager holds almost no ETH now");
        (uint160 sp,,) = pool.state();
        assertLt(sp, TickMath.getSqrtPriceAtTick(pool.upperTick()), "the price is still inside the range");
        assertGt(engine.activeEthDepth(), 15 ether, "and the engine's depth model still reports ~19 ETH");

        address alice = address(0xA1);
        vm.deal(alice, 1 ether);
        vm.prank(alice);
        uint256 id = engine.openLong{value: 0.1 ether}(5, 0);
        assertEq(engine.openCount(), 1);
        assertGt(id, 0);
    }

    function _mineHook(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {
        bytes32 initHash = l.hookInitCodeHash();
        uint160 flags = l.FLAGS();
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));
            if (uint160(a) & Hooks.ALL_HOOK_MASK == flags && uint160(a) >> 152 != 0x91) return bytes32(i);
        }
    }

    function _mineCoin(IMD6900RobinhoodLaunch l) internal view returns (bytes32) {
        bytes32 initHash = l.tokenInitCodeHash();
        for (uint256 i;; ++i) {
            address a = address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(l), i, initHash)))));
            if (uint160(a) >> 144 == 0x6900) return bytes32(i);
        }
    }

    function _sqrt(uint256 x) internal pure returns (uint256 y) {
        if (x == 0) return 0;
        y = x;
        uint256 z = (x + 1) / 2;
        while (z < y) (y, z) = (z, (x / z + z) / 2);
    }

    receive() external payable {}
}