"""
Liquidation risk overlay.

Monitors current positions, mark prices, and computes liquidation
distance. Warns when positions approach liquidation threshold.

Integrates with live/treasury.py for position tracking.
"""

from __future__ import annotations

from typing import Optional

from live.treasury import Treasury


class LiquidationRiskOverlay:
    """Liquidation risk monitor for open positions.

    Usage:
        overlay = LiquidationRiskOverlay(treasury=treasury)
        status = overlay.check("BTC")
        if status["warning"]:
            # reduce position or add margin
    """

    def __init__(
        self,
        treasury: Treasury,
        warning_threshold_pct: float = 10.0,
        danger_threshold_pct: float = 5.0,
        critical_threshold_pct: float = 2.5,
    ):
        self._treasury = treasury
        self._warning = warning_threshold_pct
        self._danger = danger_threshold_pct
        self._critical = critical_threshold_pct

    def check(self, coin: str) -> dict:
        """Check liquidation safety for a specific coin."""
        distance = self._treasury.liquidation_distance(coin.upper())

        if distance >= self._warning or distance >= 1e9:
            level = "safe"
        elif distance >= self._danger:
            level = "warning"
        elif distance >= self._critical:
            level = "danger"
        else:
            level = "critical"

        return {
            "coin": coin.upper(),
            "level": level,
            "distance_pct": round(min(distance, 999999), 2),
            "position": self._treasury.position(coin.upper()),
            "warning": level in ("warning", "danger", "critical"),
            "needs_action": level == "critical",
        }

    def check_all(self) -> dict[str, dict]:
        positions = self._treasury.all_positions
        return {coin: self.check(coin) for coin, pos in positions.items() if abs(pos) > 0}

    def pnl_at_liquidation(self, coin: str) -> float:
        """Estimate realized PnL if position reaches liquidation price."""
        pos = self._treasury._positions.get(coin.upper())
        if not pos:
            return 0.0

        entry = pos["entry_px"]
        size = pos["size"]
        side = pos["side"]

        liq_price = self._treasury._liquidation.liquidation_price(
            entry, size, side, self._treasury.equity
        )

        if side == "buy":
            return size * (liq_price - entry)
        else:
            return size * (entry - liq_price)

    def recommended_action(self, coin: str) -> str:
        """Recommend action based on liquidation distance."""
        status = self.check(coin)
        level = status["level"]

        if level == "safe":
            return "none"
        elif level == "warning":
            return "reduce_position_25pct"
        elif level == "danger":
            return "reduce_position_50pct"
        else:
            return "close_all"

    def summary(self) -> dict:
        return {
            "positions": self.check_all(),
            "worst_case": min(
                (self.check(c)["distance_pct"] for c in self._treasury.all_positions),
                default=float("inf")
            ),
            "any_critical": any(
                self.check(c)["level"] == "critical"
                for c in self._treasury.all_positions
            ),
        }