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

import {Test} from "forge-std/Test.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 {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 {PoolKey} from "v4-core/src/types/PoolKey.sol";
import {Currency} from "v4-core/src/types/Currency.sol";
import {ModifyLiquidityParams, SwapParams} from "v4-core/src/types/PoolOperation.sol";
import {PoolSwapTest} from "v4-core/src/test/PoolSwapTest.sol";
import {PoolModifyLiquidityTest} from "v4-core/src/test/PoolModifyLiquidityTest.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {CurbHook} from "src/CurbHook.sol";
import {ICurbHook} from "src/interfaces/ICurbHook.sol";

/// @dev Time the price spends where nothing trades is still sampled into the reference TWAP. A
/// dust holder pushes the price into the empty range for free, waits one window, steps back into
/// liquidity, and the next roll drags the reference 899 ticks toward the empty range. From then on
/// the band blocks the liquid side at 101 ticks from the current price.
contract VoidTwapDragTest is Test {
    using StateLibrary for IPoolManager;

    address constant FACTORY = address(0xFAC7);
    address constant OWNER = address(0xD35C);
    uint160 constant FLAGS = 0x20C0;
    uint160 constant SQRT_PRICE_1_1 = 79228162514264337593543950336;
    uint128 constant LIQUIDITY = 1e24;

    PoolManager manager;
    PoolSwapTest swapRouter;
    PoolModifyLiquidityTest lpRouter;
    MockERC20 curb;
    MockERC20 imd;
    CurbHook hook;
    PoolKey key;

    function setUp() public {
        vm.warp(1_000_000);
        vm.roll(100);
        manager = new PoolManager(address(this));
        swapRouter = new PoolSwapTest(manager);
        lpRouter = new PoolModifyLiquidityTest(manager);
        MockERC20 a = new MockERC20("A", "A", 18);
        MockERC20 b = new MockERC20("B", "B", 18);
        (curb, imd) = address(a) < address(b) ? (a, b) : (b, a);
        curb.mint(address(this), 1e30);
        imd.mint(address(this), 1e30);
        curb.approve(address(swapRouter), type(uint256).max);
        imd.approve(address(swapRouter), type(uint256).max);
        curb.approve(address(lpRouter), type(uint256).max);
        imd.approve(address(lpRouter), type(uint256).max);

        address at = address(
            (uint160(uint256(keccak256("curb-void-drag"))) & ~uint160(Hooks.ALL_HOOK_MASK)) | FLAGS
        );
        deployCodeTo(
            "CurbHook.sol:CurbHook",
            abi.encode(manager, address(curb), FACTORY, OWNER, int24(1000), int24(100), uint32(300), uint32(15), uint32(900), uint32(1800), uint32(1), true),
            at
        );
        hook = CurbHook(at);
        key = PoolKey(Currency.wrap(address(curb)), Currency.wrap(address(imd)), 12500, 60, IHooks(at));
        vm.prank(FACTORY);
        manager.initialize(key, SQRT_PRICE_1_1);
        // Launch-like: liquidity in range at the opening tick 0 and below it; nothing above tick 60.
        lpRouter.modifyLiquidity(key, ModifyLiquidityParams(-887220, 60, int256(uint256(LIQUIDITY)), 0), "");
    }

    function tick() internal view returns (int24 t) {
        (, t,,) = IPoolManager(address(manager)).getSlot0(key.toId());
    }

    function moveTo(int24 target) internal {
        bool zeroForOne = target < tick();
        swapRouter.swap(
            key, SwapParams(zeroForOne, -1e29, TickMath.getSqrtPriceAtTick(target)), PoolSwapTest.TestSettings(false, false), ""
        );
    }

    function test_voidTimeDragsReferenceAndBlocksLiquidSide() public {
        assertEq(hook.status().ref, 0);

        // 1. Free push into the empty range, inside the band (no liquidity above 60: costs ~nothing).
        moveTo(950);
        assertEq(tick(), 950);

        // 2. One reference window passes with the price parked there.
        vm.warp(block.timestamp + 300);

        // 3. Back into liquidity. Starts in the void, so no roll happens on this swap.
        moveTo(-100);
        assertEq(tick(), -100);

        // 4. The next swap rolls the reference from a TWAP made of 300 s at tick 950.
        moveTo(-101);
        int24 ref = hook.status().ref;
        emit log_named_int("reference after roll", ref);

        // The reference must not be built from prices where nothing trades: it should sit in the
        // liquid range (at or below tick 60), not 799.
        assertLe(ref, 60, "reference dragged into the empty range");

        // And a seller moving 200 more ticks into the liquid side must pass.
        moveTo(-300);
        assertEq(tick(), -300);
    }
}