// 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 {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {Currency} from "@uniswap/v4-core/src/types/Currency.sol";
import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {TickMath} from "@uniswap/v4-core/src/libraries/TickMath.sol";
import {ERC20} from "solmate/src/tokens/ERC20.sol";
import {PimdToken} from "src/pimd/PimdToken.sol";
import {PimdHook} from "src/pimd/PimdHook.sol";

contract QuoteStub is ERC20("Identity.md", "IMD", 18) {}

/// Points the quote at a local stand-in and changes nothing else; every line of beforeInitialize executed
/// is the production contract's.
contract HookUnderTest is PimdHook {
    address private immutable _quote;
    constructor(IPoolManager pm, address token_, address factory_, address quote_) PimdHook(pm, token_, factory_) {
        _quote = quote_;
    }
    function quoteToken() public view override returns (address) { return _quote; }
}

contract FactoryStub {
    IPoolManager immutable m;
    constructor(IPoolManager m_) { m = m_; }
    function open(PoolKey memory key, uint160 p) external { m.initialize(key, p); }
}

/// README ("refuses ... an opening tick more than 300 from LAUNCH_TICK"), the hook's own NatSpec at
/// PimdHook.sol:42-43 and the launch brief all say beforeInitialize refuses an opening price more than
/// LAUNCH_TICK_TOLERANCE from LAUNCH_TICK. The code reads the tick for the event and gates nothing, so the
/// factory can open this pool at any price at all. The price used here is launch.json's own
/// pool.initialPrice, 2^96, which is tick 0: one IMD per PIMD, a 1,000,000,000 IMD opening cap against the
/// policy's 2,500.
contract TickGateTest is Test {
    uint160 constant FLAGS = uint160(
        Hooks.BEFORE_INITIALIZE_FLAG | Hooks.AFTER_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
            | Hooks.BEFORE_SWAP_RETURNS_DELTA_FLAG | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG
            | Hooks.BEFORE_ADD_LIQUIDITY_FLAG | Hooks.BEFORE_REMOVE_LIQUIDITY_FLAG
    );

    IPoolManager manager;
    QuoteStub imd;
    PimdToken token;
    FactoryStub factory;
    PimdHook hook;

    function setUp() public {
        manager = IPoolManager(address(new PoolManager(address(this))));
        imd = new QuoteStub();
        // mine a token address above the quote so IMD is currency0, as the hook requires
        bytes32 initHash = keccak256(type(PimdToken).creationCode);
        for (uint256 i; i < 100_000; ++i) {
            address predicted = vm.computeCreate2Address(bytes32(i), initHash, address(this));
            if (uint160(predicted) > uint160(address(imd))) {
                token = new PimdToken{salt: bytes32(i)}();
                break;
            }
        }
        require(address(token) != address(0), "no salt");
        factory = new FactoryStub(manager);
        // mine a hook address whose low bits are exactly the permission flags
        bytes32 hookInit = keccak256(
            abi.encodePacked(type(HookUnderTest).creationCode, abi.encode(manager, address(token), address(factory), address(imd)))
        );
        for (uint256 i; i < 500_000; ++i) {
            address predicted = vm.computeCreate2Address(bytes32(i), hookInit, address(this));
            if (uint160(predicted) & Hooks.ALL_HOOK_MASK == FLAGS) {
                hook = PimdHook(payable(address(new HookUnderTest{salt: bytes32(i)}(manager, address(token), address(factory), address(imd)))));
                require(address(hook) == predicted, "hook addr");
                break;
            }
        }
        require(address(hook) != address(0), "no hook salt");
    }

    function _key() internal view returns (PoolKey memory) {
        return PoolKey({
            currency0: Currency.wrap(address(imd)),
            currency1: Currency.wrap(address(token)),
            fee: 12_500,
            tickSpacing: 60,
            hooks: IHooks(address(hook))
        });
    }

    /// launch.json's initialPrice, 79228162514264337593543950336, is tick 0: 129,000 ticks from LAUNCH_TICK.
    /// The advertised gate refuses it. The code opens the pool.
    function test_the_advertised_tick_gate_refuses_launch_json_initial_price() public {
        uint160 manifestPrice = 79228162514264337593543950336;
        assertEq(TickMath.getTickAtSqrtPrice(manifestPrice), 0);
        vm.expectRevert();
        factory.open(_key(), manifestPrice);
        assertFalse(hook.launched(), "pool opened 129000 ticks away from LAUNCH_TICK");
    }

    /// One tick past the tolerance on either side is refused by the advertised gate.
    function test_the_advertised_tick_gate_refuses_one_tick_past_tolerance() public {
        uint160 oneTickPast = TickMath.getSqrtPriceAtTick(hook.LAUNCH_TICK() + hook.LAUNCH_TICK_TOLERANCE() + 1);
        vm.expectRevert();
        factory.open(_key(), oneTickPast);
        assertFalse(hook.launched());
    }

    /// Control: the briefed tick is accepted, so a fix that gates the price does not refuse the real launch.
    function test_the_briefed_tick_is_accepted() public {
        factory.open(_key(), TickMath.getSqrtPriceAtTick(hook.LAUNCH_TICK()));
        assertTrue(hook.launched());
    }
}