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

import {Test} from "forge-std/Test.sol";
import {SIMDTEST} from "src/SIMDTEST.sol";
import {SIMDTESTHook} from "src/SIMDTESTHook.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

contract PairStandIn is ERC20 {
    constructor() ERC20("Offline IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice The anti-snipe fee has a different base in the two swap modes. Exact input charges
/// rate/10000 of the IMD the buyer hands over (gross); exact output charges rate/10000 of the pool
/// input only, i.e. rate/(10000+rate) of gross (23.08% instead of 30% at opening). A buyer who
/// spends the same IMD in exact-output mode therefore receives ~10% more tokens than in
/// exact-input mode. This test fails on the current code and passes once both modes charge the
/// same fraction of the IMD actually paid (either base, applied consistently).
contract FeeBaseAsymmetryTest is Test {
    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 internal constant PRICE = 79228162514264337593543950336;

    IPoolManager internal manager;
    SIMDTEST internal token;
    SIMDTESTHook internal hook;
    PoolKey internal key;
    PoolSwapTest internal router;
    PoolModifyLiquidityTest internal liquidity;
    bool internal pairIs0;

    function setUp() public {
        vm.roll(100);
        vm.warp(1000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new PairStandIn()).code);
        PairStandIn(IMD).mint(address(this), 2_000_000_000 ether);
        token = new SIMDTEST();
        hook = _deployHook();
        pairIs0 = IMD < address(token);
        key = PoolKey(
            Currency.wrap(pairIs0 ? IMD : address(token)),
            Currency.wrap(pairIs0 ? address(token) : IMD),
            12500,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, PRICE);
        router = new PoolSwapTest(manager);
        liquidity = new PoolModifyLiquidityTest(manager);
        IERC20(IMD).approve(address(router), type(uint256).max);
        IERC20(IMD).approve(address(liquidity), type(uint256).max);
        token.approve(address(router), type(uint256).max);
        token.approve(address(liquidity), type(uint256).max);
        liquidity.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, 900_000_000 ether, 0), "");
    }

    function _deployHook() internal returns (SIMDTESTHook deployed) {
        bytes memory code =
            abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token)));
        bytes32 hash = keccak256(code);
        for (uint256 i;; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), salt, hash)))));
            if ((uint160(predicted) & 0x3fff) == 0x20c8 && predicted.code.length == 0) {
                deployed = new SIMDTESTHook{salt: salt}(manager, address(token));
                assertEq(address(deployed), predicted);
                return deployed;
            }
        }
    }

    function _buy(int256 amount) internal returns (BalanceDelta) {
        bool zeroForOne = pairIs0;
        return router.swap(
            key,
            SwapParams(zeroForOne, amount, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function _pair(BalanceDelta d) internal view returns (int128) {
        return pairIs0 ? d.amount0() : d.amount1();
    }

    function _tok(BalanceDelta d) internal view returns (int128) {
        return pairIs0 ? d.amount1() : d.amount0();
    }

    /// @dev Same opening block (30% fee), same pool state, same IMD spent: both swap modes must
    /// deliver the same number of tokens (up to 1 part in 1e6 of rounding).
    function test_sameIMDSpentBuysSameTokensInBothModes() public {
        assertEq(hook.antiSnipeFeeBps(), 3000);

        uint256 snap = vm.snapshotState();
        BalanceDelta out = _buy(int256(1000 ether)); // exact output: 1000 tokens
        uint256 grossOut = uint256(-int256(_pair(out)));
        uint256 feeOut = hook.accruedFees();
        assertEq(_tok(out), 1000 ether);
        vm.revertToState(snap);

        BalanceDelta inn = _buy(-int256(grossOut)); // exact input: the same gross IMD
        uint256 feeIn = hook.accruedFees();
        assertEq(uint256(-int256(_pair(inn))), grossOut, "same IMD spent");

        emit log_named_uint("gross IMD paid", grossOut);
        emit log_named_uint("exact-output fee", feeOut);
        emit log_named_uint("exact-input  fee", feeIn);
        emit log_named_uint("exact-output tokens", 1000 ether);
        emit log_named_uint("exact-input  tokens", uint256(uint128(_tok(inn))));

        // The hook fee charged for the same gross IMD must be the same in both modes.
        assertApproxEqRel(feeIn, feeOut, 1e12, "hook fee differs by swap mode for identical IMD spend");
        // And so must the tokens the buyer receives.
        assertApproxEqRel(uint256(uint128(_tok(inn))), 1000 ether, 1e12, "tokens differ by swap mode");
    }
}

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

import {Test} from "forge-std/Test.sol";
import {SIMDTEST} from "src/SIMDTEST.sol";
import {SIMDTESTHook} from "src/SIMDTESTHook.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {SwapParams, ModifyLiquidityParams} from "v4-core/src/types/PoolOperation.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";

contract PairStandIn is ERC20 {
    constructor() ERC20("Offline IMD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @notice The anti-snipe fee is specified as 30% of the paired currency (decaying 300 bps per block).
/// Exact-input buys pay exactly that share of the IMD they spend. Exact-output buys pay
/// rate / (10000 + rate) of the IMD they spend (23.08% at the opening block), so the same tokens
/// cost ~9% less through exact-output and the treasury receives ~30% less fee on those swaps.
/// Fails on the current code; passes once the exact-output fee is `used * rate / (10000 - rate)`.
contract ExactOutputFeeRateTest is Test {
    address internal constant IMD = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;
    uint160 internal constant PRICE = 79228162514264337593543950336;
    uint256 internal constant LIMIT = 10_000_000 ether;

    IPoolManager internal manager;
    SIMDTEST internal token;
    SIMDTESTHook internal hook;
    PoolKey internal key;
    PoolSwapTest internal router;
    PoolModifyLiquidityTest internal liquidity;
    bool internal pairIs0;

    function setUp() public {
        vm.roll(100);
        vm.warp(1000);
        manager = IPoolManager(address(new PoolManager(address(this))));
        vm.etch(IMD, address(new PairStandIn()).code);
        PairStandIn(IMD).mint(address(this), 2_000_000_000 ether);
        token = new SIMDTEST();
        hook = _deployHook();
        pairIs0 = IMD < address(token);
        key = PoolKey(
            Currency.wrap(pairIs0 ? IMD : address(token)),
            Currency.wrap(pairIs0 ? address(token) : IMD),
            12500,
            60,
            IHooks(address(hook))
        );
        manager.initialize(key, PRICE);
        router = new PoolSwapTest(manager);
        liquidity = new PoolModifyLiquidityTest(manager);
        IERC20(IMD).approve(address(router), type(uint256).max);
        IERC20(IMD).approve(address(liquidity), type(uint256).max);
        token.approve(address(router), type(uint256).max);
        token.approve(address(liquidity), type(uint256).max);
        liquidity.modifyLiquidity(key, ModifyLiquidityParams(-887220, 887220, 900_000_000 ether, 0), "");
    }

    function _deployHook() internal returns (SIMDTESTHook deployed) {
        bytes memory code =
            abi.encodePacked(type(SIMDTESTHook).creationCode, abi.encode(manager, address(token)));
        bytes32 hash = keccak256(code);
        for (uint256 i;; ++i) {
            bytes32 salt = bytes32(i);
            address predicted =
                address(uint160(uint256(keccak256(abi.encodePacked(hex"ff", address(this), salt, hash)))));
            if ((uint160(predicted) & 0x3fff) == 0x20c8 && predicted.code.length == 0) {
                deployed = new SIMDTESTHook{salt: salt}(manager, address(token));
                assertEq(address(deployed), predicted);
                return deployed;
            }
        }
    }

    function _buy(int256 amount) internal returns (BalanceDelta) {
        bool zeroForOne = pairIs0;
        return router.swap(
            key,
            SwapParams(zeroForOne, amount, zeroForOne ? TickMath.MIN_SQRT_PRICE + 1 : TickMath.MAX_SQRT_PRICE - 1),
            PoolSwapTest.TestSettings(false, false),
            ""
        );
    }

    function _pairDelta(BalanceDelta d) internal view returns (int128) {
        return pairIs0 ? d.amount0() : d.amount1();
    }

    function _tokenDelta(BalanceDelta d) internal view returns (int128) {
        return pairIs0 ? d.amount1() : d.amount0();
    }

    /// @dev Opening block: antiSnipeFeeBps() == 3000. The fee on an exact-output buy must be 30% of the
    /// IMD the buyer actually spends, the same share an exact-input buy pays.
    function test_exactOutputBuyPaysTheAdvertisedShareOfIMDSpent() public {
        uint256 rate = hook.antiSnipeFeeBps();
        assertEq(rate, 3000, "opening block rate");

        // Reference: exact input pays exactly rate/10000 of the IMD spent.
        uint256 snap = vm.snapshotState();
        BalanceDelta dIn = _buy(-int256(10_000_000 ether));
        uint256 spentIn = uint256(-int256(_pairDelta(dIn)));
        uint256 feeIn = hook.accruedFees();
        assertEq(feeIn, spentIn * rate / 10_000, "exact-input fee share");
        vm.revertToState(snap);

        // Exact output of exactly maxBuy() tokens at the same opening state.
        BalanceDelta dOut = _buy(int256(LIMIT));
        assertEq(_tokenDelta(dOut), int256(LIMIT));
        uint256 spentOut = uint256(-int256(_pairDelta(dOut)));
        uint256 feeOut = hook.accruedFees();

        // The advertised rate is a share of the paired currency paid; allow 1 wei of floor rounding.
        assertApproxEqAbs(
            feeOut, spentOut * rate / 10_000, 1, "exact-output buy pays less than antiSnipeFeeBps() of IMD spent"
        );
    }

    /// @dev Same tokens, same block, same pool: the exact-output route must not be cheaper for a sniper
    /// than the exact-input route by more than rounding dust.
    function test_sameTokensCostTheSameThroughEitherExactMode() public {
        uint256 target = LIMIT / 2; // 5,000,000 tokens: well inside the max-buy limit either way.
        uint256 snap = vm.snapshotState();
        BalanceDelta dOut = _buy(int256(target));
        uint256 spentOut = uint256(-int256(_pairDelta(dOut)));
        uint256 poolInput = spentOut - hook.accruedFees();
        vm.revertToState(snap);

        // Exact-input budget whose 70% net reaches the same pool input (same tokens out).
        uint256 budget = (poolInput * 10_000 + 6_999) / 7_000;
        BalanceDelta dIn = _buy(-int256(budget));
        assertGe(uint256(uint128(_tokenDelta(dIn))), target - 1e18, "same tokens reached");

        // A sniper must not save more than dust by choosing exact output.
        assertLe(budget - spentOut, 1e18, "exact-output route is materially cheaper than exact-input");
    }
}