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

import {Test} from "forge-std/Test.sol";
import {MockERC20} from "solmate/src/test/utils/mocks/MockERC20.sol";
import {Deployers} from "v4-core-test/utils/Deployers.sol";
import {IHooks} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {TickMath} from "v4-core/libraries/TickMath.sol";
import {PoolKey} from "v4-core/types/PoolKey.sol";
import {Currency} from "v4-core/types/Currency.sol";

import {InkHook, IAgentPortraits, IInkVault} from "src/InkHook.sol";

/// Stand-ins for the vault and portraits: the hook only reads them.
contract StubVault {
    bool public released;
    address public liquidity;
}

contract StubPortraits {
    function isAgentHolder(address) external pure returns (bool) {
        return false;
    }
}

/// InkHook.beforeInitialize accepts any initializer and any paired token / fee / tick spacing, and is one-shot
/// (poolCreated). Once the hook exists at its mined address and before the launch factory initializes the
/// INK/IMD pool, anyone can initialize a pool of IMD against any token with this hook. That flips
/// poolCreated, so the factory's own initialize reverts with PoolAlreadyCreated and the launch cannot use the
/// hook. The test plays the factory: it deploys the hook, an attacker initializes a junk pool, then the
/// factory initializes the real pool, which must succeed.
contract InkHookInitFrontrunTest is Test, Deployers {
    address attacker = makeAddr("attacker");
    address treasury = makeAddr("treasury");

    MockERC20 imd;
    MockERC20 ink;
    MockERC20 junk;
    InkHook hook;

    function setUp() public {
        deployFreshManagerAndRouters();
        imd = new MockERC20("Identity.md", "IMD", 18);
        ink = new MockERC20("INK", "INK", 18);
        junk = new MockERC20("JUNK", "JUNK", 18);

        address hookAddr = address(
            uint160(
                Hooks.BEFORE_INITIALIZE_FLAG | Hooks.BEFORE_SWAP_FLAG | Hooks.AFTER_SWAP_FLAG
                    | Hooks.AFTER_SWAP_RETURNS_DELTA_FLAG
            ) ^ (0x4444 << 144)
        );
        // The test contract is the launch factory: it deploys the hook and later initializes its pool.
        deployCodeTo(
            "InkHook.sol:InkHook",
            abi.encode(
                manager,
                IAgentPortraits(address(new StubPortraits())),
                IInkVault(address(new StubVault())),
                Currency.wrap(address(imd)),
                treasury,
                uint16(25)
            ),
            hookAddr
        );
        hook = InkHook(hookAddr);
    }

    function _key(address a, address b, uint24 fee, int24 spacing) internal view returns (PoolKey memory) {
        (address c0, address c1) = a < b ? (a, b) : (b, a);
        return PoolKey({
            currency0: Currency.wrap(c0),
            currency1: Currency.wrap(c1),
            fee: fee,
            tickSpacing: spacing,
            hooks: IHooks(address(hook))
        });
    }

    function test_strangerCannotPreemptTheLaunchPool() public {
        // 1. A stranger initializes IMD/JUNK with the launch hook, between hook deployment and the factory's
        //    initialize. Its outcome is not asserted: on fixed code this call reverts, on current code it passes.
        PoolKey memory junkKey = _key(address(imd), address(junk), 3000, 60);
        vm.prank(attacker, attacker);
        (bool ok,) = address(manager).call(
            abi.encodeWithSelector(manager.initialize.selector, junkKey, TickMath.getSqrtPriceAtTick(0))
        );
        ok; // ignored on purpose

        // 2. The launch factory initializes the real INK/IMD pool. This must succeed and bind the hook to INK.
        PoolKey memory realKey = _key(address(imd), address(ink), 12_500, 200);
        manager.initialize(realKey, TickMath.getSqrtPriceAtTick(0));

        assertTrue(hook.poolCreated(), "the launch pool exists");
        assertEq(Currency.unwrap(hook.ink()), address(ink), "the hook is bound to INK, not to the stranger's token");
    }
}