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

import {SIMDTEST} from "src/SIMDTEST.sol";
import {SIMDTESTHook} from "src/SIMDTESTHook.sol";
import {PoolManager} from "v4-core/src/PoolManager.sol";
import {IPoolManager} from "v4-core/src/interfaces/IPoolManager.sol";
import {IHooks} from "v4-core/src/interfaces/IHooks.sol";
import {IUnlockCallback} from "v4-core/src/interfaces/callback/IUnlockCallback.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {Hooks} from "v4-core/src/libraries/Hooks.sol";
import {TickMath} from "v4-core/src/libraries/TickMath.sol";
import {StateLibrary} from "v4-core/src/libraries/StateLibrary.sol";
import {TransientStateLibrary} from "v4-core/src/libraries/TransientStateLibrary.sol";
import {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {PoolIdLibrary} from "v4-core/src/types/PoolId.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {BalanceDelta} from "v4-core/src/types/BalanceDelta.sol";

interface ProofVm { function roll(uint256) external; }

// Self-contained: no imports from the submitted test suite or external test libraries.
contract EmptyRangeProofTest is IUnlockCallback {
    using StateLibrary for IPoolManager;
    using TransientStateLibrary for IPoolManager;
    using PoolIdLibrary for PoolKey;

    ProofVm constant vm = ProofVm(address(uint160(uint256(keccak256("hevm cheat code")))));
    IPoolManager manager;
    SIMDTESTHook hook;
    PoolKey hooked;
    PoolKey control;

    function setUp() public {
        vm.roll(100);
        manager = IPoolManager(address(new PoolManager(address(this))));
        SIMDTEST token = new SIMDTEST();
        SIMDTEST localPair = new SIMDTEST();
        bytes32 initHash = keccak256(abi.encodePacked(
            type(SIMDTESTHook).creationCode, abi.encode(manager, address(token), address(this))
        ));
        bool deployed;
        for (uint256 salt; salt < 1_000_000; ++salt) {
            address candidate = address(uint160(uint256(keccak256(abi.encodePacked(
                bytes1(0xff), address(this), bytes32(salt), initHash
            )))));
            if ((uint160(candidate) & Hooks.ALL_HOOK_MASK) == 0x2044) {
                hook = new SIMDTESTHook{salt: bytes32(salt)}(manager, address(token), address(this));
                deployed = true;
                break;
            }
        }
        require(deployed, "salt search failed");
        (address a, address b) = address(token) < address(localPair)
            ? (address(token), address(localPair)) : (address(localPair), address(token));
        hooked = PoolKey(Currency.wrap(a), Currency.wrap(b), 12500, 60, IHooks(address(hook)));
        control = PoolKey(Currency.wrap(a), Currency.wrap(b), 12500, 60, IHooks(address(0)));
        manager.initialize(hooked, uint160(1 << 96));
        manager.initialize(control, uint160(1 << 96));
        manager.unlock(abi.encode(true, control));
        manager.unlock(abi.encode(true, hooked));
    }

    function testPartialFillAtLastTickMustRemainExecutable() public {
        vm.roll(110); // The constant growth fee alone is sufficient to trigger the defect.
        BalanceDelta withoutHook = abi.decode(manager.unlock(abi.encode(false, control)), (BalanceDelta));
        require(withoutHook.amount0() < 0 && withoutHook.amount1() > 0, "control swap did not execute");
        require(uint256(-int256(withoutHook.amount0())) < 100_000 ether, "expected a partial fill");
        require(manager.getLiquidity(control.toId()) == 0, "control did not cross final tick");

        // Expected: the same valid partial fill executes with applicable hook fees.
        // Actual: donate() sees zero post-swap liquidity and raises NoLiquidityToReceiveFees.
        BalanceDelta withHook = abi.decode(manager.unlock(abi.encode(false, hooked)), (BalanceDelta));
        require(withHook.amount0() < 0 && withHook.amount1() > 0, "hooked partial fill did not execute");
        require(uint256(-int256(withHook.amount0())) <= 100_000 ether, "input budget exceeded");
    }

    function unlockCallback(bytes calldata data) external returns (bytes memory) {
        require(msg.sender == address(manager), "manager only");
        (bool addLiquidity, PoolKey memory key) = abi.decode(data, (bool, PoolKey));
        BalanceDelta delta;
        if (addLiquidity) {
            (delta,) = manager.modifyLiquidity(
                key, IPoolManager.ModifyLiquidityParams(-600, 600, int256(1_000_000 ether), bytes32(0)), ""
            );
        } else {
            delta = manager.swap(
                key,
                IPoolManager.SwapParams(true, -int256(100_000 ether), TickMath.getSqrtPriceAtTick(-600)),
                ""
            );
        }
        _settle(key.currency0);
        _settle(key.currency1);
        return abi.encode(delta);
    }

    function _settle(Currency currency) private {
        int256 delta = manager.currencyDelta(address(this), currency);
        if (delta < 0) {
            manager.sync(currency);
            require(IERC20(Currency.unwrap(currency)).transfer(address(manager), uint256(-delta)), "payment failed");
            manager.settle();
        } else if (delta > 0) {
            manager.take(currency, address(this), uint256(delta));
        }
    }
}