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

import {Test} from "forge-std/Test.sol";
import {
    MoneyBackHook,
    IHooks,
    IPoolManager,
    PoolKey,
    SwapParams,
    Currency,
    BalanceDelta,
    BeforeSwapDelta
} from "src/MoneyBackHook.sol";
import {MoneyBackToken} from "src/MoneyBackToken.sol";

/// @notice Proof: the hook charges the IMD fee on the amount the swapper SPECIFIED, in beforeSwap,
///         before the pool has moved anything. When the pool fills only part of the order (price
///         limit reached, or not enough IMD in the pool, which is the state right after the
///         single-sided seeding), v4 still applies the full beforeSwap delta to the swapper
///         (v4-core Hooks.sol: `amountToSwap += hookDeltaSpecified` in beforeSwap, then
///         `swapDelta = swapDelta - hookDelta` in afterSwap). An exact-output SELL whose fill is
///         smaller than the fee makes the seller PAY IMD on top of the MONEYBACK they sold; an
///         exact-input BUY that fills partially pays 4.25% of the offered amount, not of the amount
///         actually swapped.
///
///         This contract plays the PoolManager (the hook is built with it as `manager`) and
///         replays exactly the two v4 callbacks with the deltas v4 would pass. Each test passes if
///         the hook either refuses the under-filled swap (reverts in beforeSwap or afterSwap) or
///         charges no more than the IMD the pool actually moved.
contract PartialFillFeeTest is Test, IPoolManager {
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    uint160 constant FLAGS = 0x20CC;
    uint160 constant SQRT_1_1 = 79228162514264337593543950336;

    MoneyBackHook hook;
    MoneyBackToken token;
    PoolKey key;
    bool imdIs0;
    mapping(address => mapping(uint256 => uint256)) claims;

    // ---- minimal PoolManager surface the hook touches in these paths ----
    function unlock(bytes calldata) external pure returns (bytes memory) {
        return "";
    }

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

    function burn(address from, uint256 id, uint256 amount) external {
        claims[from][id] -= amount;
    }

    function take(Currency, address, uint256) external {}

    function balanceOf(address owner, uint256 id) external view returns (uint256) {
        return claims[owner][id];
    }

    function setUp() public {
        token = new MoneyBackToken();
        bytes memory creation =
            abi.encodePacked(type(MoneyBackHook).creationCode, abi.encode(address(this), address(token), address(0xFA)));
        bytes32 h = keccak256(creation);
        address at;
        for (uint256 i = 0; i < 1_000_000; i++) {
            address p =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(i), h)))));
            if ((uint160(p) & ((1 << 14) - 1)) != FLAGS) continue;
            bytes32 salt = bytes32(i);
            assembly ("memory-safe") {
                at := create2(0, add(creation, 0x20), mload(creation), salt)
            }
            break;
        }
        require(at != address(0), "hook not deployed");
        hook = MoneyBackHook(at);

        imdIs0 = IMD < address(token);
        (address c0, address c1) = imdIs0 ? (IMD, address(token)) : (address(token), IMD);
        key = PoolKey({
            currency0: Currency.wrap(c0),
            currency1: Currency.wrap(c1),
            fee: 12_500,
            tickSpacing: 60,
            hooks: IHooks(at)
        });
        bytes4 sel = hook.beforeInitialize(address(this), key, SQRT_1_1);
        assertEq(sel, IHooks.beforeInitialize.selector);
    }

    function _specified(BeforeSwapDelta d) internal pure returns (int256 a) {
        assembly ("memory-safe") {
            a := sar(128, d)
        }
    }

    function _delta(int128 a0, int128 a1) internal pure returns (BalanceDelta d) {
        assembly ("memory-safe") {
            d := or(shl(128, a0), and(sub(shl(128, 1), 1), a1))
        }
    }

    /// Exact-output SELL of 100 IMD during the surcharge window, pool can deliver only 5 IMD
    /// (price limit reached, or the pool holds only 5 IMD). v4 asks the pool for
    /// 100 + fee, the pool pays 5, the swapper is charged the full beforeSwap fee of 24.25.
    function test_exactOutputSell_partialFill_sellerMustNotPayImd() public {
        bool sellZeroForOne = !imdIs0; // MONEYBACK in, IMD out
        SwapParams memory params = SwapParams({zeroForOne: sellZeroForOne, amountSpecified: 100e18, sqrtPriceLimitX96: SQRT_1_1});

        int256 feeSpecified;
        try hook.beforeSwap(address(this), key, params, "") returns (bytes4, BeforeSwapDelta bsd, uint24) {
            feeSpecified = _specified(bsd);
        } catch {
            return; // the hook refused the swap: acceptable
        }

        // the pool delivered only 5 IMD (and took 5.07 MONEYBACK) before hitting the limit / running dry
        int128 delivered = 5e18;
        BalanceDelta swapDelta = imdIs0 ? _delta(delivered, -5.07e18) : _delta(-5.07e18, delivered);
        try hook.afterSwap(address(this), key, params, swapDelta, "") returns (bytes4, int128) {}
        catch {
            return; // the hook refused the under-filled swap in afterSwap: acceptable
        }

        // v4 (Hooks.afterSwap): swapDelta = swapDelta - hookDelta, hookDelta.specified = feeSpecified
        int256 sellerImd = int256(delivered) - feeSpecified;
        assertGe(sellerImd, 0, "a SELL made the seller pay IMD: fee charged on 100 IMD the pool never delivered");
        assertLe(hook.pending(), uint256(int256(delivered)), "hook kept more IMD than the pool moved");
    }

    /// Exact-input BUY offering 100 IMD, pool consumes only 50 before the price limit: the hook
    /// has already taken 4.25 (4.25% of 100) so the buyer pays 54.25 for a 50 IMD swap (8.5%).
    function test_exactInputBuy_partialFill_feeOnlyOnConsumed() public {
        bool buyZeroForOne = imdIs0; // IMD in
        SwapParams memory params = SwapParams({zeroForOne: buyZeroForOne, amountSpecified: -100e18, sqrtPriceLimitX96: SQRT_1_1});

        int256 feeSpecified;
        try hook.beforeSwap(address(this), key, params, "") returns (bytes4, BeforeSwapDelta bsd, uint24) {
            feeSpecified = _specified(bsd);
        } catch {
            return;
        }

        int128 consumed = 50e18; // pool consumed 50 of the 95.75 it was offered
        BalanceDelta swapDelta = imdIs0 ? _delta(-consumed, 47e18) : _delta(47e18, -consumed);
        try hook.afterSwap(address(this), key, params, swapDelta, "") returns (bytes4, int128) {}
        catch {
            return;
        }

        uint256 charged = hook.pending();
        assertLe(charged, uint256(int256(consumed)) * 425 / 10_000 + 1, "fee exceeds 4.25% of the IMD actually swapped");
        feeSpecified; // silence
    }
}

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

import {MoneyBackHook, IPoolManager as HookManager} from "src/MoneyBackHook.sol";
import {MoneyBackToken} from "src/MoneyBackToken.sol";
import {PoolManager} from "test/vendor/v4-core/src/PoolManager.sol";
import {IPoolManager} from "test/vendor/v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "test/vendor/v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "test/vendor/v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {PoolKey} from "test/vendor/v4-core/src/types/PoolKey.sol";
import {Currency} from "test/vendor/v4-core/src/types/Currency.sol";
import {BalanceDelta} from "test/vendor/v4-core/src/types/BalanceDelta.sol";
import {SwapParams, ModifyLiquidityParams} from "test/vendor/v4-core/src/types/PoolOperation.sol";
import {TickMath} from "test/vendor/v4-core/src/libraries/TickMath.sol";

interface Vm {
    function etch(address, bytes calldata) external;
    function warp(uint256) external;
    function deal(address, uint256) external;
    function snapshotState() external returns (uint256);
    function revertToState(uint256) external returns (bool);
}

interface IERC20Like {
    function transfer(address to, uint256 value) external returns (bool);
}

contract ScratchIMD {
    mapping(address => uint256) public balanceOf;

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

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

/// @dev Same pool state, same MONEYBACK sold, same IMD leaving the pool: the exact-output route
///      pays a smaller hook fee than the exact-input route.
contract FeeBaseAsymmetryTest is IUnlockCallback {
    Vm constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    address constant PAYOUT = address(0xBACC);
    uint160 constant Q96 = 1 << 96;
    uint256 constant T0 = 1_750_000_000;

    PoolManager manager;
    MoneyBackToken token;
    MoneyBackHook hook;
    PoolKey key;
    bool tokenIs0;

    function setUp() public {
        vm.warp(T0);
        vm.etch(IMD, address(new ScratchIMD()).code);
        ScratchIMD(IMD).mint(address(this), 1e30);
        manager = new PoolManager(address(this));
        token = new MoneyBackToken();
        tokenIs0 = address(token) < IMD;
        bytes32 hookHash = keccak256(
            abi.encodePacked(type(MoneyBackHook).creationCode, abi.encode(address(manager), address(token), PAYOUT))
        );
        for (uint256 salt; salt < 1_000_000; ++salt) {
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), address(this), bytes32(salt), hookHash)))));
            if (uint160(predicted) & 0x3FFF == 0x20CC) {
                hook = new MoneyBackHook{salt: bytes32(salt)}(HookManager(address(manager)), address(token), PAYOUT);
                break;
            }
        }
        require(address(hook) != address(0), "hook salt");
        key = PoolKey({
            currency0: Currency.wrap(tokenIs0 ? address(token) : IMD),
            currency1: Currency.wrap(tokenIs0 ? IMD : address(token)),
            fee: 12_500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
        manager.initialize(key, Q96);
        manager.unlock(abi.encode(uint8(1), abi.encode(ModifyLiquidityParams(-600, 600, 1e24, 0))));
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (uint8 action, bytes memory params) = abi.decode(data, (uint8, bytes));
        BalanceDelta delta;
        if (action == 0) {
            delta = manager.swap(key, abi.decode(params, (SwapParams)), "");
        } else {
            (delta,) = manager.modifyLiquidity(key, abi.decode(params, (ModifyLiquidityParams)), "");
        }
        _settle(key.currency0, delta.amount0());
        _settle(key.currency1, delta.amount1());
        return abi.encode(delta);
    }

    function _settle(Currency currency, int128 delta) private {
        if (delta > 0) {
            manager.take(currency, address(this), uint128(delta));
        } else if (delta < 0) {
            manager.sync(currency);
            require(IERC20Like(Currency.unwrap(currency)).transfer(address(manager), uint256(-int256(delta))), "settle");
            manager.settle();
        }
    }

    function _sell(bool exactInput, uint256 amount) private returns (int256 imdDelta, int256 tokenDelta, uint256 fee) {
        uint256 before = hook.pending();
        SwapParams memory p = SwapParams({
            zeroForOne: tokenIs0,
            amountSpecified: exactInput ? -int256(amount) : int256(amount),
            sqrtPriceLimitX96: tokenIs0 ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1
        });
        BalanceDelta d = abi.decode(manager.unlock(abi.encode(uint8(0), abi.encode(p))), (BalanceDelta));
        imdDelta = tokenIs0 ? d.amount1() : d.amount0();
        tokenDelta = tokenIs0 ? d.amount0() : d.amount1();
        fee = hook.pending() - before;
    }

    /// @notice Inside the surcharge window (2425 bps). Seller A asks for exactly 100 IMD (exact
    ///         output). Seller B, from the identical pool state, sells exactly the MONEYBACK A sold
    ///         (exact input). The pool pays out the same IMD either way, but A is charged
    ///         ~19.5% of it and B 24.25% of it.
    function test_sameSaleSameOutputDifferentFee() public {
        uint256 snap = vm.snapshotState();

        // Route A: exact-output sell of 100 IMD.
        (int256 imdA, int256 tokA, uint256 feeA) = _sell(false, 100e18);
        require(imdA == 100e18, "A receives exactly 100 IMD");
        uint256 poolOutA = uint256(imdA) + feeA; // IMD that left the pool
        uint256 soldA = uint256(-tokA);

        vm.revertToState(snap);

        // Route B: exact-input sell of the same MONEYBACK amount from the same state.
        (int256 imdB,, uint256 feeB) = _sell(true, soldA);
        uint256 poolOutB = uint256(imdB) + feeB;

        // Same pool movement (pool math rounding only).
        require(poolOutB + 2 >= poolOutA && poolOutA + 2 >= poolOutB, "pool paid out the same IMD");

        // Both routes must charge the same fee for the same IMD leg leaving the pool.
        // Fails today: feeA = 24.25e18 (19.52% of 124.25e18), feeB = 30.13e18 (24.25% of 124.25e18).
        require(feeA + 2 >= feeB && feeB + 2 >= feeA, "exact-output route pays less hook fee than exact-input route");
    }

    /// @notice The same gap, stated as a rate on the pool's IMD output.
    function test_exactOutputSellSurchargeRateOnPoolOutput() public {
        (int256 imdA,, uint256 feeA) = _sell(false, 100e18);
        uint256 poolOut = uint256(imdA) + feeA;
        uint256 bpsOnPoolOutput = feeA * 10_000 / poolOut;
        // 2425 expected (425 base + 2000 surcharge). Actual: 1951.
        require(bpsOnPoolOutput == 2425, "exact-output sell is charged 1951 bps of the IMD the pool paid, not 2425");
    }
}