// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.19;

import { LiquidityAmounts } from "@aperture/uni-v3-lib/LiquidityAmounts.sol";
import { TickMath } from "@aperture/uni-v3-lib/TickMath.sol";

import { Math } from "@openzeppelin/utils/math/Math.sol";
import { IUniswapV3Pool } from "@uniswap-v3-core/interfaces/IUniswapV3Pool.sol";
import { console2 } from "forge-std/console2.sol";

/**
 * @title PositionTracker
 * @notice Tracks KrAIken's three-position lifecycle and computes P&L metrics
 *         for backtesting analysis.
 *
 * For each position lifecycle (open → close on next recenter), records:
 *   - Tick range (tickLower, tickUpper) and liquidity
 *   - Entry/exit block and timestamp
 *   - Token amounts at entry vs exit (via Uniswap V3 LiquidityAmounts math)
 *   - Fees earned (proportional to each position's share of total liquidity)
 *   - Impermanent loss vs holding the initial token amounts
 *   - Net P&L = fees value + IL  (IL is negative when LP underperforms HODL)
 *
 * Aggregate metrics:
 *   - Total fees (token0 + token1 raw, and token0-equivalent)
 *   - Cumulative IL and net P&L (token0 units)
 *   - Rebalance count
 *   - Time in range: % of notified blocks where Anchor tick range contains current tick
 *   - Capital efficiency numerator/denominator for offline calculation
 *
 * All output lines carry a [TRACKER][TYPE] prefix for downstream parseability.
 * Cumulative P&L is logged every CUMULATIVE_LOG_INTERVAL blocks.
 *
 * Not a Script — no vm access. Uses console2 for output only.
 */
contract PositionTracker {
    using Math for uint256;

    // -------------------------------------------------------------------------
    // Types
    // -------------------------------------------------------------------------

    /**
     * @notice Snapshot of all three KrAIken positions at a point in time.
     * @dev Stage ordinals: 0 = FLOOR, 1 = ANCHOR, 2 = DISCOVERY.
     */
    struct PositionSnapshot {
        uint128 floorLiq;
        int24 floorLo;
        int24 floorHi;
        uint128 anchorLiq;
        int24 anchorLo;
        int24 anchorHi;
        uint128 discLiq;
        int24 discLo;
        int24 discHi;
    }

    struct OpenPosition {
        int24 tickLower;
        int24 tickUpper;
        uint128 liquidity;
        uint256 entryBlock;
        uint256 entryTimestamp;
        uint256 entryAmount0;
        uint256 entryAmount1;
        bool active;
    }

    // -------------------------------------------------------------------------
    // Constants
    // -------------------------------------------------------------------------

    uint256 internal constant Q96 = 2 ** 96;

    /// @notice Blocks between cumulative P&L log lines.
    uint256 public constant CUMULATIVE_LOG_INTERVAL = 500;

    // -------------------------------------------------------------------------
    // Immutables
    // -------------------------------------------------------------------------

    IUniswapV3Pool public immutable pool;

    /// @notice True when pool token0 is WETH; affects fees0/fees1 mapping.
    bool public immutable token0isWeth;

    // -------------------------------------------------------------------------
    // Open position state (indexed 0=FLOOR, 1=ANCHOR, 2=DISCOVERY)
    // -------------------------------------------------------------------------

    OpenPosition[3] public openPositions;

    // -------------------------------------------------------------------------
    // Cumulative aggregate metrics
    // -------------------------------------------------------------------------

    uint256 public totalFees0;
    uint256 public totalFees1;
    uint256 public rebalanceCount;

    /// @notice Cumulative IL across all closed positions in token0 units.
    ///         Negative means LP underperformed HODL.
    int256 public totalILToken0;

    /// @notice Cumulative net P&L = IL + fees value (token0 units).
    int256 public totalNetPnLToken0;

    // Time-in-range (Anchor position).
    uint256 public blocksChecked;
    uint256 public blocksAnchorInRange;
    uint256 public lastNotifiedBlock;

    // Capital efficiency accumulators.
    /// @notice Cumulative fees expressed in token0 units.
    uint256 public totalFeesToken0;
    /// @notice Sum of (liquidity × blocksOpen) for all closed positions.
    uint256 public totalLiquidityBlocks;

    // -------------------------------------------------------------------------
    // Internal
    // -------------------------------------------------------------------------

    uint256 internal _lastCumulativeLogBlock;

    // -------------------------------------------------------------------------
    // Constructor
    // -------------------------------------------------------------------------

    constructor(IUniswapV3Pool _pool, bool _token0isWeth) {
        pool = _pool;
        token0isWeth = _token0isWeth;
    }

    // -------------------------------------------------------------------------
    // Integration API (called by StrategyExecutor)
    // -------------------------------------------------------------------------

    /**
     * @notice Notify the tracker that a new block has been observed.
     *         Updates Anchor time-in-range and emits cumulative P&L lines at
     *         every CUMULATIVE_LOG_INTERVAL blocks.
     * @param blockNum Block number as advanced by EventReplayer.
     */
    function notifyBlock(uint256 blockNum) external {
        if (blockNum == lastNotifiedBlock) return;
        lastNotifiedBlock = blockNum;

        // Track Anchor time-in-range.
        OpenPosition storage anchor = openPositions[1]; // ANCHOR = 1
        if (anchor.active) {
            (, int24 tick,,,,,) = pool.slot0();
            blocksChecked++;
            if (tick >= anchor.tickLower && tick < anchor.tickUpper) {
                blocksAnchorInRange++;
            }
        }

        // Log cumulative P&L at regular intervals.
        if (_lastCumulativeLogBlock == 0) {
            _lastCumulativeLogBlock = blockNum;
        } else if (blockNum - _lastCumulativeLogBlock >= CUMULATIVE_LOG_INTERVAL) {
            _logCumulative(blockNum);
            _lastCumulativeLogBlock = blockNum;
        }
    }

    /**
     * @notice Record a successful recenter: close old positions, open new ones.
     * @param oldPos     Pre-recenter snapshot (positions being burned).
     * @param newPos     Post-recenter snapshot (positions being minted).
     * @param feesWeth   Total WETH fees collected across all positions this recenter.
     * @param feesKrk    Total KRK fees collected across all positions this recenter.
     * @param blockNum   Block number of the recenter.
     * @param timestamp  Block timestamp of the recenter.
     */
    function recordRecenter(
        PositionSnapshot calldata oldPos,
        PositionSnapshot calldata newPos,
        uint256 feesWeth,
        uint256 feesKrk,
        uint256 blockNum,
        uint256 timestamp
    )
        external
    {
        (uint160 sqrtPriceX96,,,,,,) = pool.slot0();

        // Map WETH/KRK fees to pool token0/token1 based on pool ordering.
        uint256 fees0 = token0isWeth ? feesWeth : feesKrk;
        uint256 fees1 = token0isWeth ? feesKrk : feesWeth;

        totalFees0 += fees0;
        totalFees1 += fees1;
        totalFeesToken0 += _valueInToken0(fees0, fees1, sqrtPriceX96);
        rebalanceCount++;

        uint256 totalOldLiq = uint256(oldPos.floorLiq) + uint256(oldPos.anchorLiq) + uint256(oldPos.discLiq);

        // Close old positions (skip stages where old liquidity is zero or no open record exists).
        _closePosition(0, oldPos.floorLiq, oldPos.floorLo, oldPos.floorHi, fees0, fees1, totalOldLiq, sqrtPriceX96, blockNum);
        _closePosition(1, oldPos.anchorLiq, oldPos.anchorLo, oldPos.anchorHi, fees0, fees1, totalOldLiq, sqrtPriceX96, blockNum);
        _closePosition(2, oldPos.discLiq, oldPos.discLo, oldPos.discHi, fees0, fees1, totalOldLiq, sqrtPriceX96, blockNum);

        // Open new positions.
        _openPosition(0, newPos.floorLiq, newPos.floorLo, newPos.floorHi, sqrtPriceX96, blockNum, timestamp);
        _openPosition(1, newPos.anchorLiq, newPos.anchorLo, newPos.anchorHi, sqrtPriceX96, blockNum, timestamp);
        _openPosition(2, newPos.discLiq, newPos.discLo, newPos.discHi, sqrtPriceX96, blockNum, timestamp);
    }

    /**
     * @notice Log the final aggregate summary. Call once at the end of replay.
     * @param blockNum Final block number (for context in the summary line).
     */
    function logFinalSummary(uint256 blockNum) external view {
        // Compute incremental IL from still-open positions without mutating state.
        (uint160 sqrtPriceX96,,,,,,) = pool.slot0();
        int256 finalIL = totalILToken0;
        int256 finalNetPnL = totalNetPnLToken0;
        for (uint8 i = 0; i < 3; i++) {
            OpenPosition storage pos = openPositions[i];
            if (!pos.active) continue;
            (uint256 exitAmt0, uint256 exitAmt1) = _positionAmounts(pos.liquidity, pos.tickLower, pos.tickUpper, sqrtPriceX96);
            int256 il = _computeIL(pos.entryAmount0, pos.entryAmount1, exitAmt0, exitAmt1, sqrtPriceX96);
            finalIL += il;
            finalNetPnL += il; // no fees for unclosed positions
        }

        uint256 timeInRangeBps = blocksChecked > 0 ? (blocksAnchorInRange * 10_000) / blocksChecked : 0;

        console2.log("[TRACKER][SUMMARY] === Final P&L Summary ===");
        console2.log(string.concat("[TRACKER][SUMMARY] finalBlock=", _str(blockNum)));
        console2.log(string.concat("[TRACKER][SUMMARY] rebalances=", _str(rebalanceCount)));
        console2.log(
            string.concat("[TRACKER][SUMMARY] totalFees0=", _str(totalFees0), " totalFees1=", _str(totalFees1), " totalFeesToken0=", _str(totalFeesToken0))
        );
        console2.log(string.concat("[TRACKER][SUMMARY] totalIL=", _istr(finalIL), " netPnL=", _istr(finalNetPnL), " (token0 units)"));
        console2.log(
            string.concat(
                "[TRACKER][SUMMARY] timeInRange=", _str(timeInRangeBps), " bps blocksAnchorInRange=", _str(blocksAnchorInRange), "/", _str(blocksChecked)
            )
        );
        console2.log(string.concat("[TRACKER][SUMMARY] capitalEff: feesToken0=", _str(totalFeesToken0), " liqBlocks=", _str(totalLiquidityBlocks)));
    }

    // -------------------------------------------------------------------------
    // Internal: position lifecycle
    // -------------------------------------------------------------------------

    function _openPosition(
        uint8 stageIdx,
        uint128 liquidity,
        int24 tickLower,
        int24 tickUpper,
        uint160 sqrtPriceX96,
        uint256 blockNum,
        uint256 timestamp
    )
        internal
    {
        if (liquidity == 0) return;
        (uint256 amt0, uint256 amt1) = _positionAmounts(liquidity, tickLower, tickUpper, sqrtPriceX96);
        openPositions[stageIdx] = OpenPosition({
            tickLower: tickLower,
            tickUpper: tickUpper,
            liquidity: liquidity,
            entryBlock: blockNum,
            entryTimestamp: timestamp,
            entryAmount0: amt0,
            entryAmount1: amt1,
            active: true
        });
        console2.log(
            string.concat(
                "[TRACKER][OPEN] stage=",
                _stageName(stageIdx),
                " block=",
                _str(blockNum),
                " ts=",
                _str(timestamp),
                " tick=[",
                _istr(tickLower),
                ",",
                _istr(tickUpper),
                "] liq=",
                _str(uint256(liquidity)),
                " amt0=",
                _str(amt0),
                " amt1=",
                _str(amt1)
            )
        );
    }

    function _closePosition(
        uint8 stageIdx,
        uint128 liquidity,
        int24 tickLower,
        int24 tickUpper,
        uint256 fees0Total,
        uint256 fees1Total,
        uint256 totalOldLiq,
        uint160 sqrtPriceX96,
        uint256 blockNum
    )
        internal
    {
        if (liquidity == 0) return;
        OpenPosition storage pos = openPositions[stageIdx];
        if (!pos.active) return; // first ever close: no open record to match

        (uint256 exitAmt0, uint256 exitAmt1) = _positionAmounts(liquidity, tickLower, tickUpper, sqrtPriceX96);

        // Attribute fees proportional to this position's share of total liquidity.
        uint256 posLiq = uint256(liquidity);
        uint256 myFees0 = totalOldLiq > 0 ? fees0Total.mulDiv(posLiq, totalOldLiq) : 0;
        uint256 myFees1 = totalOldLiq > 0 ? fees1Total.mulDiv(posLiq, totalOldLiq) : 0;

        // IL = LP exit value (ex-fees) − HODL value at exit price (both in token0 units).
        int256 il = _computeIL(pos.entryAmount0, pos.entryAmount1, exitAmt0, exitAmt1, sqrtPriceX96);
        int256 feesToken0 = int256(_valueInToken0(myFees0, myFees1, sqrtPriceX96));
        int256 netPnL = il + feesToken0;

        totalILToken0 += il;
        totalNetPnLToken0 += netPnL;

        uint256 blocksOpen = blockNum > pos.entryBlock ? blockNum - pos.entryBlock : 0;
        totalLiquidityBlocks += posLiq * blocksOpen;

        console2.log(
            string.concat(
                "[TRACKER][CLOSE] stage=",
                _stageName(stageIdx),
                " block=",
                _str(blockNum),
                " entryBlock=",
                _str(pos.entryBlock),
                " tick=[",
                _istr(tickLower),
                ",",
                _istr(tickUpper),
                "] liq=",
                _str(posLiq)
            )
        );
        console2.log(
            string.concat(
                "[TRACKER][CLOSE] entryAmt0=",
                _str(pos.entryAmount0),
                " entryAmt1=",
                _str(pos.entryAmount1),
                " exitAmt0=",
                _str(exitAmt0),
                " exitAmt1=",
                _str(exitAmt1),
                " fees0=",
                _str(myFees0),
                " fees1=",
                _str(myFees1)
            )
        );
        console2.log(string.concat("[TRACKER][CLOSE] IL=", _istr(il), " netPnL=", _istr(netPnL), " (token0 units)"));

        delete openPositions[stageIdx];
    }

    function _logCumulative(uint256 blockNum) internal view {
        uint256 timeInRangeBps = blocksChecked > 0 ? (blocksAnchorInRange * 10_000) / blocksChecked : 0;
        console2.log(
            string.concat(
                "[TRACKER][CUMULATIVE] block=",
                _str(blockNum),
                " rebalances=",
                _str(rebalanceCount),
                " totalFees0=",
                _str(totalFees0),
                " totalFees1=",
                _str(totalFees1),
                " IL=",
                _istr(totalILToken0),
                " netPnL=",
                _istr(totalNetPnLToken0),
                " timeInRange=",
                _str(timeInRangeBps),
                " bps"
            )
        );
    }

    // -------------------------------------------------------------------------
    // Internal: Uniswap V3 math
    // -------------------------------------------------------------------------

    /**
     * @notice Compute (amount0, amount1) for a liquidity position at the given sqrt price.
     */
    function _positionAmounts(
        uint128 liquidity,
        int24 tickLower,
        int24 tickUpper,
        uint160 sqrtPriceX96
    )
        internal
        pure
        returns (uint256 amount0, uint256 amount1)
    {
        uint160 sqrtRatioLow = TickMath.getSqrtRatioAtTick(tickLower);
        uint160 sqrtRatioHigh = TickMath.getSqrtRatioAtTick(tickUpper);
        (amount0, amount1) = LiquidityAmounts.getAmountsForLiquidity(sqrtPriceX96, sqrtRatioLow, sqrtRatioHigh, liquidity);
    }

    /**
     * @notice Impermanent loss for a position close (token0 units).
     *         IL = lpExitValue − hodlValue at the exit price.
     *         Negative when LP underperforms HODL (the typical case).
     */
    function _computeIL(uint256 entryAmt0, uint256 entryAmt1, uint256 exitAmt0, uint256 exitAmt1, uint160 sqrtPriceX96) internal pure returns (int256) {
        uint256 lpVal = _valueInToken0(exitAmt0, exitAmt1, sqrtPriceX96);
        uint256 hodlVal = _valueInToken0(entryAmt0, entryAmt1, sqrtPriceX96);
        return int256(lpVal) - int256(hodlVal);
    }

    /**
     * @notice Convert (amount0, amount1) to token0-equivalent units at the given sqrt price.
     * @dev    value = amount0 + amount1 / price
     *              = amount0 + amount1 × Q96² / sqrtPriceX96²
     *              = amount0 + mulDiv(mulDiv(amount1, Q96, sqrtPrice), Q96, sqrtPrice)
     */
    function _valueInToken0(uint256 amount0, uint256 amount1, uint160 sqrtPriceX96) internal pure returns (uint256) {
        if (sqrtPriceX96 == 0 || amount1 == 0) return amount0;
        uint256 amt1InT0 = Math.mulDiv(Math.mulDiv(amount1, Q96, uint256(sqrtPriceX96)), Q96, uint256(sqrtPriceX96));
        return amount0 + amt1InT0;
    }

    // -------------------------------------------------------------------------
    // Formatting helpers (no vm dependency)
    // -------------------------------------------------------------------------

    function _stageName(uint8 idx) internal pure returns (string memory) {
        if (idx == 0) return "FLOOR";
        if (idx == 1) return "ANCHOR";
        return "DISC";
    }

    function _str(uint256 v) internal pure returns (string memory) {
        if (v == 0) return "0";
        uint256 tmp = v;
        uint256 len;
        while (tmp != 0) {
            len++;
            tmp /= 10;
        }
        bytes memory buf = new bytes(len);
        while (v != 0) {
            buf[--len] = bytes1(uint8(48 + v % 10));
            v /= 10;
        }
        return string(buf);
    }

    function _istr(int256 v) internal pure returns (string memory) {
        if (v >= 0) return _str(uint256(v));
        return string.concat("-", _str(uint256(-v)));
    }
}