"""Live executor — deferred behind MODE=live.

Same `Executor` surface as PaperExecutor. Signs EIP-712 orders via
py-clob-client, submits FAK across all legs in parallel, aborts + unwinds on
partial fill, and calls NegRiskAdapter.redeemPositions once a complete set is
held.

Status: functional skeleton. The signing + order submission path is wired up,
but each side-effect is gated by a `dry_run` flag so nothing is broadcast until
the operator explicitly flips it. The risk gate is enforced here; it's the
last thing between an Opportunity and real capital.

See docs/api/order-signing.md and docs/api/negrisk.md for wire details.
"""
from __future__ import annotations

import asyncio
import json
from dataclasses import dataclass
from datetime import UTC, datetime
from decimal import Decimal
from pathlib import Path

from loguru import logger

from ..book.l2 import BookRegistry
from ..config import Mode, settings
from ..db import db_conn
from ..models import Basket, BasketStatus, Fill, Opportunity, OrderType, Side


@dataclass(slots=True)
class RiskLimits:
    max_basket_usd: Decimal
    max_open_baskets: int
    max_open_baskets_per_event: int
    daily_loss_stop_usd: Decimal
    kill_switch_file: Path

    @classmethod
    def from_settings(cls) -> RiskLimits:
        return cls(
            max_basket_usd=settings.max_basket_usd,
            max_open_baskets=settings.max_open_baskets,
            max_open_baskets_per_event=settings.max_open_baskets_per_event,
            daily_loss_stop_usd=settings.daily_loss_stop_usd,
            kill_switch_file=settings.kill_switch_file,
        )


class RiskDenied(Exception):
    """Raised when a risk gate refuses an opportunity."""


async def risk_gate(opp: Opportunity, limits: RiskLimits) -> None:
    """Apply hard caps. Raises RiskDenied with a reason if any cap is hit."""
    if limits.kill_switch_file.exists():
        raise RiskDenied(f"kill switch present: {limits.kill_switch_file}")

    cost = opp.sum_vwap_asks * opp.max_baskets
    if cost > limits.max_basket_usd:
        raise RiskDenied(f"basket cost ${cost} > max ${limits.max_basket_usd}")

    today = datetime.now(UTC).date().isoformat()
    async with db_conn() as conn:
        cursor = await conn.execute(
            """
            SELECT COUNT(*) FROM baskets
            WHERE is_paper=0 AND status IN (?, ?, ?)
            """,
            (
                BasketStatus.OPEN.value,
                BasketStatus.PARTIAL.value,
                BasketStatus.PENDING_RESOLUTION.value,
            ),
        )
        (open_global,) = await cursor.fetchone()
        if open_global >= limits.max_open_baskets:
            raise RiskDenied(f"{open_global} live baskets already open")

        cursor = await conn.execute(
            """
            SELECT COUNT(*) FROM baskets
            WHERE event_id=? AND is_paper=0 AND status IN (?, ?, ?)
            """,
            (
                opp.event_id,
                BasketStatus.OPEN.value,
                BasketStatus.PARTIAL.value,
                BasketStatus.PENDING_RESOLUTION.value,
            ),
        )
        (open_per_event,) = await cursor.fetchone()
        if open_per_event >= limits.max_open_baskets_per_event:
            raise RiskDenied(f"event {opp.event_id} already has {open_per_event} open")

        cursor = await conn.execute(
            "SELECT live_pnl_usd FROM daily_pnl WHERE date=?", (today,)
        )
        row = await cursor.fetchone()
        if row is not None:
            pnl = Decimal(row[0])
            if pnl <= -limits.daily_loss_stop_usd:
                raise RiskDenied(f"daily loss stop hit: pnl={pnl}")


class LiveExecutor:
    """Signs and submits orders. Requires MODE=live and wallet credentials."""

    def __init__(
        self,
        *,
        books: BookRegistry,
        limits: RiskLimits | None = None,
        dry_run: bool = True,
    ) -> None:
        if settings.mode != Mode.LIVE:
            raise RuntimeError(
                "LiveExecutor instantiated but ARB_MODE is not live — refusing."
            )
        settings.require_live_credentials()
        self._books = books
        self._limits = limits or RiskLimits.from_settings()
        self._dry_run = dry_run
        self._clob = None  # py_clob_client.ClobClient, lazy-init

    def _ensure_clob(self):
        if self._clob is not None:
            return self._clob
        # Imported lazily so paper-mode users don't need py-clob-client installed.
        from py_clob_client.client import ClobClient
        from py_clob_client.clob_types import ApiCreds

        pk = settings.private_key.get_secret_value() if settings.private_key else None
        if pk is None:
            raise RuntimeError("ARB_PRIVATE_KEY is required for live mode")
        creds = None
        if settings.api_key and settings.api_secret and settings.api_passphrase:
            creds = ApiCreds(
                api_key=settings.api_key.get_secret_value(),
                api_secret=settings.api_secret.get_secret_value(),
                api_passphrase=settings.api_passphrase.get_secret_value(),
            )
        self._clob = ClobClient(
            host=settings.clob_host,
            key=pk,
            chain_id=137,
            signature_type=settings.signature_type,
            funder=settings.funder_address,
            creds=creds,
        )
        if creds is None:
            self._clob.set_api_creds(self._clob.create_or_derive_api_creds())
        return self._clob

    async def execute(self, opp: Opportunity) -> Basket | None:
        try:
            await risk_gate(opp, self._limits)
        except RiskDenied as exc:
            logger.warning("risk denied opp {}: {}", opp.id, exc)
            return None

        now = datetime.now(UTC)
        basket = Basket(
            opportunity_id=opp.id,
            event_id=opp.event_id,
            is_paper=False,
            created_at=now,
            basket_count=opp.max_baskets,
            total_cost_usd=Decimal(0),
            status=BasketStatus.OPEN,
            fills=[],
        )
        await self._persist_basket_open(opp, basket)

        fills, total_cost, shortfall = await self._submit_parallel(opp, basket)
        basket.fills = fills
        basket.total_cost_usd = total_cost

        if shortfall:
            logger.error("partial fill detected on basket {}; unwinding", basket.id)
            await self._unwind(basket, shortfall)
            basket.status = BasketStatus.FAILED
        else:
            basket.status = BasketStatus.PENDING_RESOLUTION
            await self._redeem_or_defer(basket, opp)

        await self._persist_basket_final(basket)
        return basket

    async def _submit_parallel(
        self, opp: Opportunity, basket: Basket
    ) -> tuple[list[Fill], Decimal, dict[str, Decimal]]:
        tasks = [self._submit_leg(opp, leg, basket.id) for leg in opp.legs]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        fills: list[Fill] = []
        total_cost = Decimal(0)
        shortfall: dict[str, Decimal] = {}
        for leg, res in zip(opp.legs, results, strict=True):
            if isinstance(res, Exception):
                logger.error("leg {} raised: {}", leg.token_id, res)
                shortfall[leg.token_id] = leg.size
                continue
            fill, short = res
            fills.append(fill)
            total_cost += fill.price * fill.size
            if short > 0:
                shortfall[leg.token_id] = short
        return fills, total_cost, shortfall

    async def _submit_leg(self, opp: Opportunity, leg, basket_id: str):
        if self._dry_run:
            logger.info("[dry_run] would FAK buy token={} price={} size={}",
                        leg.token_id, leg.vwap_price, leg.size)
            fill = Fill(
                token_id=leg.token_id, side=Side.BUY,
                price=leg.vwap_price, size=leg.size,
                fee_usd=Decimal(0), filled_at=datetime.now(UTC),
            )
            return fill, Decimal(0)

        client = self._ensure_clob()
        from py_clob_client.clob_types import OrderArgs
        from py_clob_client.clob_types import OrderType as ClobOrderType

        args = OrderArgs(
            token_id=leg.token_id,
            price=float(leg.vwap_price),
            size=float(leg.size),
            side="BUY",
        )
        # neg_risk=True is critical — routes to NegRiskCtfExchange.
        signed = await asyncio.to_thread(
            client.create_order, args, options={"neg_risk": True}
        )
        resp = await asyncio.to_thread(
            client.post_order, signed, ClobOrderType.FAK
        )
        await self._persist_live_order(basket_id, leg, resp)
        filled_size = Decimal(str(resp.get("making_amount") or resp.get("size_matched") or 0))
        price = Decimal(str(resp.get("price") or leg.vwap_price))
        short = leg.size - filled_size
        fill = Fill(
            token_id=leg.token_id, side=Side.BUY,
            price=price, size=filled_size,
            fee_usd=Decimal(str(resp.get("fee") or 0)),
            filled_at=datetime.now(UTC),
        )
        return fill, max(short, Decimal(0))

    async def _unwind(self, basket: Basket, shortfall: dict[str, Decimal]) -> None:
        """Sell any legs we over-filled relative to the shortfalled ones."""
        short_legs = set(shortfall.keys())
        for fill in basket.fills:
            if fill.token_id in short_legs or fill.size <= 0:
                continue
            if self._dry_run:
                logger.info("[dry_run] would market-sell token={} size={}",
                            fill.token_id, fill.size)
                continue
            client = self._ensure_clob()
            from py_clob_client.clob_types import OrderArgs
            from py_clob_client.clob_types import OrderType as ClobOrderType
            args = OrderArgs(
                token_id=fill.token_id,
                price=0.0,  # market
                size=float(fill.size),
                side="SELL",
            )
            signed = await asyncio.to_thread(
                client.create_order, args, options={"neg_risk": True}
            )
            await asyncio.to_thread(client.post_order, signed, ClobOrderType.FAK)

    async def _redeem_or_defer(self, basket: Basket, opp: Opportunity) -> None:
        """Once the full YES set is held, call NegRiskAdapter.redeemPositions.
        Deferred (no-op) in MVP — the patient path is to wait for UMA and
        call redeem from a separate resolution worker. This keeps the hot
        path small and avoids gas on every successful basket.
        """
        logger.info("basket {} pending resolution; redeem deferred to watcher", basket.id)

    async def _persist_basket_open(self, opp: Opportunity, basket: Basket) -> None:
        legs_json = json.dumps([leg.model_dump(mode="json") for leg in opp.legs])
        async with db_conn() as conn:
            await conn.execute(
                """
                INSERT OR IGNORE INTO opportunities
                  (id, detected_at, event_id, event_title, sum_vwap_asks,
                   net_edge_bps, max_baskets, expected_profit_usd, legs_json, acted_on)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 1)
                """,
                (
                    opp.id, opp.detected_at.isoformat(), opp.event_id, opp.event_title,
                    str(opp.sum_vwap_asks), opp.net_edge_bps, str(opp.max_baskets),
                    str(opp.expected_profit_usd), legs_json,
                ),
            )
            await conn.execute(
                """
                INSERT INTO baskets
                  (id, opportunity_id, event_id, is_paper, created_at, basket_count,
                   total_cost_usd, status)
                VALUES (?, ?, ?, 0, ?, ?, ?, ?)
                """,
                (basket.id, basket.opportunity_id, basket.event_id,
                 basket.created_at.isoformat(), str(basket.basket_count),
                 str(basket.total_cost_usd), basket.status.value),
            )
            await conn.commit()

    async def _persist_basket_final(self, basket: Basket) -> None:
        async with db_conn() as conn:
            await conn.execute(
                """
                UPDATE baskets SET total_cost_usd=?, status=? WHERE id=?
                """,
                (str(basket.total_cost_usd), basket.status.value, basket.id),
            )
            for fill in basket.fills:
                await conn.execute(
                    """
                    INSERT INTO fills
                      (basket_id, token_id, side, price, size, fee_usd, filled_at)
                    VALUES (?, ?, ?, ?, ?, ?, ?)
                    """,
                    (basket.id, fill.token_id, fill.side.value, str(fill.price),
                     str(fill.size), str(fill.fee_usd), fill.filled_at.isoformat()),
                )
            await conn.commit()

    async def _persist_live_order(self, basket_id: str, leg, resp: dict) -> None:
        now = datetime.now(UTC).isoformat()
        async with db_conn() as conn:
            await conn.execute(
                """
                INSERT INTO live_orders
                  (id, basket_id, token_id, side, price, size, order_type, status,
                   clob_order_id, tx_hash, created_at, updated_at)
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    str(resp.get("orderId") or resp.get("id") or f"{basket_id}-{leg.token_id}"),
                    basket_id, leg.token_id, Side.BUY.value,
                    str(leg.vwap_price), str(leg.size),
                    OrderType.FAK.value,
                    str(resp.get("status") or "submitted"),
                    resp.get("orderId") or resp.get("id"),
                    resp.get("transactionHash"),
                    now, now,
                ),
            )
            await conn.commit()