"""模拟撮合: 用公开行情 bid/ask 成交, 结算到本地钱包."""

from __future__ import annotations

import uuid
from datetime import datetime
from typing import Any, Callable

from lib.sim.pricing_lib import option_fill, perp_fill, sim_fee_rate
from lib.sim.wallets_lib import InsufficientFunds, SimWallets


def _now() -> str:
    return datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")


def _ticker_bid_ask(exchange: Any, symbol: str) -> tuple[float, float]:
    t = exchange.fetch_ticker(symbol)
    last = t.get("last")
    bid = t.get("bid")
    ask = t.get("ask")
    if bid is None or float(bid) <= 0:
        bid = last
    if ask is None or float(ask) <= 0:
        ask = last
    if bid is None or ask is None:
        raise RuntimeError(f"无法获取 {symbol} 行情 bid/ask")
    return float(bid), float(ask)


def _option_bid_ask(exchange_options: Any, inst_id: str) -> tuple[float, float, float]:
    """返回 bid, ask, ct_mult."""
    ct_mult = 0.01
    bid = ask = None
    try:
        from lib.exchange.okx_options_lib import quote_option_contract

        q = quote_option_contract(exchange_options, inst_id)
        if q.get("ok"):
            bid = q.get("bid") or q.get("mark")
            ask = q.get("ask") or q.get("book_ask") or q.get("ref_ask") or q.get("mark")
            ct_mult = float(q.get("ct_mult") or 0.01)
    except Exception:
        pass
    if bid is None or ask is None:
        rows = exchange_options.public_get_market_ticker({"instId": inst_id}).get("data") or []
        if not rows:
            raise RuntimeError(f"无法获取期权行情 {inst_id}")
        t = rows[0]
        bid = bid or t.get("bidPx") or t.get("markPx") or t.get("last")
        ask = ask or t.get("askPx") or t.get("markPx") or t.get("last")
    if bid is None or ask is None:
        raise RuntimeError(f"期权 {inst_id} 缺少 bid/ask")
    return float(bid), float(ask), float(ct_mult)


def _contract_size(exchange: Any, symbol: str) -> float:
    try:
        if hasattr(exchange, "market"):
            m = exchange.market(symbol)
            return float(m.get("contractSize") or 1)
    except Exception:
        pass
    return 1.0


class SimBroker:
    def __init__(self, get_db: Callable) -> None:
        self.get_db = get_db
        self.wallets = SimWallets(get_db)

    def balances_header(self) -> dict[str, float]:
        return self.wallets.view()

    def list_perp_positions(self) -> list[dict[str, Any]]:
        conn = self.get_db()
        try:
            rows = conn.execute(
                "SELECT * FROM sim_perp_positions WHERE contracts > 1e-12 ORDER BY id"
            ).fetchall()
            out = []
            for r in rows:
                out.append(
                    {
                        "symbol": r["symbol"],
                        "direction": r["direction"],
                        "contracts": float(r["contracts"]),
                        "entry_px": float(r["entry_px"]),
                        "leverage": int(r["leverage"] or 1),
                        "margin_usdt": float(r["margin_usdt"] or 0),
                        "contract_size": float(r["contract_size"] or 1),
                    }
                )
            return out
        finally:
            conn.close()

    def list_option_positions(self) -> list[dict[str, Any]]:
        conn = self.get_db()
        try:
            rows = conn.execute(
                "SELECT * FROM sim_option_positions WHERE sheets > 1e-12 ORDER BY id"
            ).fetchall()
            out = []
            for r in rows:
                out.append(
                    {
                        "inst_id": r["inst_id"],
                        "side": r["side"],
                        "sheets": float(r["sheets"]),
                        "entry_px": float(r["entry_px"]),
                        "ct_mult": float(r["ct_mult"] or 0.01),
                        "premium_paid_usdc": float(r["premium_paid_usdc"] or 0),
                    }
                )
            return out
        finally:
            conn.close()

    def get_perp_contracts(self, symbol: str, direction: str) -> float:
        conn = self.get_db()
        try:
            row = conn.execute(
                """
                SELECT contracts FROM sim_perp_positions
                WHERE symbol=? AND direction=? AND contracts > 1e-12
                """,
                (symbol, direction),
            ).fetchone()
            if not row:
                return 0.0
            return float(row["contracts"] if hasattr(row, "keys") else row[0])
        finally:
            conn.close()

    def place_perp_market(
        self,
        exchange: Any,
        *,
        symbol: str,
        direction: str,
        contracts: float,
        leverage: int,
        fee_rate: float | None = None,
        stop_loss: Any = None,
        take_profit: Any = None,
    ) -> dict[str, Any]:
        _ = (stop_loss, take_profit)  # sim: ignore attachAlgoOrds / tpsl
        side = (direction or "").lower().strip()
        if side not in ("long", "short"):
            raise ValueError("direction 须为 long 或 short")
        qty_c = float(contracts)
        if qty_c <= 0:
            raise ValueError("张数须大于 0")
        lev = max(1, int(leverage or 1))
        fr = sim_fee_rate(fee_rate)
        bid, ask = _ticker_bid_ask(exchange, symbol)
        ct_sz = _contract_size(exchange, symbol)
        qty = qty_c * ct_sz
        pr = perp_fill(side=side, action="open", bid=bid, ask=ask, qty=qty, fee_rate=fr)
        margin = pr.notional / lev
        need = margin + pr.fee
        try:
            self.wallets.debit_trading(
                "USDT",
                need,
                kind="perp_open",
                note=f"open {side} {symbol} {qty_c}@{pr.fill_px:.4f}",
            )
        except InsufficientFunds as e:
            raise RuntimeError(str(e)) from e

        conn = self.get_db()
        try:
            existing = conn.execute(
                "SELECT * FROM sim_perp_positions WHERE symbol=? AND direction=?",
                (symbol, side),
            ).fetchone()
            if existing and float(existing["contracts"] or 0) > 1e-12:
                old_c = float(existing["contracts"])
                old_px = float(existing["entry_px"])
                old_m = float(existing["margin_usdt"] or 0)
                new_c = old_c + qty_c
                entry = (old_px * old_c + pr.fill_px * qty_c) / new_c
                conn.execute(
                    """
                    UPDATE sim_perp_positions
                    SET contracts=?, entry_px=?, leverage=?, margin_usdt=?, contract_size=?, updated_at=?
                    WHERE symbol=? AND direction=?
                    """,
                    (new_c, entry, lev, old_m + margin, ct_sz, _now(), symbol, side),
                )
            else:
                conn.execute(
                    """
                    INSERT INTO sim_perp_positions(
                        symbol, direction, contracts, entry_px, leverage, margin_usdt, contract_size, updated_at
                    ) VALUES (?,?,?,?,?,?,?,?)
                    ON CONFLICT(symbol, direction) DO UPDATE SET
                        contracts=excluded.contracts,
                        entry_px=excluded.entry_px,
                        leverage=excluded.leverage,
                        margin_usdt=excluded.margin_usdt,
                        contract_size=excluded.contract_size,
                        updated_at=excluded.updated_at
                    """,
                    (symbol, side, qty_c, pr.fill_px, lev, margin, ct_sz, _now()),
                )
            conn.commit()
        finally:
            conn.close()

        oid = f"sim-perp-{uuid.uuid4().hex[:16]}"
        return {
            "id": oid,
            "symbol": symbol,
            "side": "buy" if side == "long" else "sell",
            "amount": qty_c,
            "average": pr.fill_px,
            "status": "closed",
            "info": {"sim": True, "fee": pr.fee, "margin": margin, "fill": pr.to_dict()},
            "tpsl_attached": False,
        }

    def close_perp_market(
        self,
        exchange: Any,
        *,
        symbol: str,
        direction: str,
        contracts: float | None = None,
        fee_rate: float | None = None,
    ) -> dict[str, Any]:
        side = (direction or "").lower().strip()
        if side not in ("long", "short"):
            raise ValueError("direction 须为 long 或 short")
        conn = self.get_db()
        try:
            row = conn.execute(
                "SELECT * FROM sim_perp_positions WHERE symbol=? AND direction=?",
                (symbol, side),
            ).fetchone()
            if not row or float(row["contracts"] or 0) <= 1e-12:
                raise ValueError("模拟永续无对应持仓")
            pos_c = float(row["contracts"])
            entry = float(row["entry_px"])
            margin_all = float(row["margin_usdt"] or 0)
            ct_sz = float(row["contract_size"] or 1)
            close_c = pos_c if contracts is None else min(pos_c, float(contracts))
            if close_c <= 0:
                raise ValueError("平仓张数无效")
            fr = sim_fee_rate(fee_rate)
            bid, ask = _ticker_bid_ask(exchange, symbol)
            qty = close_c * ct_sz
            pr = perp_fill(side=side, action="close", bid=bid, ask=ask, qty=qty, fee_rate=fr)
            if side == "long":
                pnl = (pr.fill_px - entry) * qty
            else:
                pnl = (entry - pr.fill_px) * qty
            release = margin_all * (close_c / pos_c)
            credit = release + pnl - pr.fee
            remain = pos_c - close_c
            if remain <= 1e-12:
                conn.execute(
                    "DELETE FROM sim_perp_positions WHERE symbol=? AND direction=?",
                    (symbol, side),
                )
            else:
                conn.execute(
                    """
                    UPDATE sim_perp_positions
                    SET contracts=?, margin_usdt=?, updated_at=?
                    WHERE symbol=? AND direction=?
                    """,
                    (remain, margin_all - release, _now(), symbol, side),
                )
            conn.commit()
        finally:
            conn.close()

        if credit >= 0:
            self.wallets.credit_trading(
                "USDT",
                credit,
                kind="perp_close",
                note=f"close {side} {symbol} pnl={pnl:.4f}",
            )
        else:
            self.wallets.debit_trading(
                "USDT",
                abs(credit),
                kind="perp_close",
                note=f"close {side} {symbol} pnl={pnl:.4f}",
            )

        oid = f"sim-perp-close-{uuid.uuid4().hex[:16]}"
        return {
            "id": oid,
            "symbol": symbol,
            "side": "sell" if side == "long" else "buy",
            "amount": close_c,
            "average": pr.fill_px,
            "status": "closed",
            "info": {
                "sim": True,
                "fee": pr.fee,
                "pnl": pnl,
                "released_margin": release,
                "fill": pr.to_dict(),
            },
            "tpsl_attached": False,
        }

    def _store_option_order(
        self,
        *,
        ord_id: str,
        inst_id: str,
        side: str,
        sheets: float,
        avg_px: float,
    ) -> None:
        conn = self.get_db()
        try:
            conn.execute(
                """
                INSERT OR REPLACE INTO sim_option_orders(
                    ord_id, inst_id, side, sheets, avg_px, state, acc_fill_sz, created_at
                ) VALUES (?,?,?,?,?,'filled',?,?)
                """,
                (ord_id, inst_id, side, float(sheets), float(avg_px), float(sheets), _now()),
            )
            conn.commit()
        finally:
            conn.close()

    def get_option_order(self, ord_id: str) -> dict[str, Any] | None:
        conn = self.get_db()
        try:
            row = conn.execute(
                "SELECT * FROM sim_option_orders WHERE ord_id=?",
                (ord_id,),
            ).fetchone()
            if not row:
                return None
            return {
                "ok": True,
                "ord_id": row["ord_id"],
                "inst_id": row["inst_id"],
                "side": row["side"],
                "state": row["state"],
                "acc_fill_sz": float(row["acc_fill_sz"]),
                "avg_px": float(row["avg_px"]),
                "sim": True,
            }
        finally:
            conn.close()

    def place_option_buy(
        self,
        exchange_options: Any,
        *,
        inst_id: str,
        sheets: int,
        price: float | None = None,
        fee_rate: float | None = None,
        **_kwargs: Any,
    ) -> dict[str, Any]:
        n = int(sheets)
        if n < 1:
            return {"ok": False, "msg": "张数至少为 1"}
        fr = sim_fee_rate(fee_rate)
        bid, ask, ct_mult = _option_bid_ask(exchange_options, inst_id)
        if price is not None and float(price) > 0:
            # 限价: 用 min(limit, ask) 作为基准卖一近似, 仍走 option_fill 滑点
            ask = min(float(ask), float(price)) if float(price) > 0 else float(ask)
        qty = n * ct_mult
        pr = option_fill(action="open", bid=bid, ask=ask, qty=qty, fee_rate=fr)
        cost = pr.notional + pr.fee
        try:
            self.wallets.debit_trading(
                "USDC",
                cost,
                kind="option_open",
                note=f"buy {inst_id} x{n}@{pr.fill_px}",
            )
        except InsufficientFunds as e:
            return {"ok": False, "msg": str(e)}

        conn = self.get_db()
        try:
            existing = conn.execute(
                "SELECT * FROM sim_option_positions WHERE inst_id=?",
                (inst_id,),
            ).fetchone()
            if existing and float(existing["sheets"] or 0) > 1e-12:
                old_s = float(existing["sheets"])
                old_px = float(existing["entry_px"])
                old_prem = float(existing["premium_paid_usdc"] or 0)
                new_s = old_s + n
                entry = (old_px * old_s + pr.fill_px * n) / new_s
                conn.execute(
                    """
                    UPDATE sim_option_positions
                    SET sheets=?, entry_px=?, ct_mult=?, premium_paid_usdc=?, updated_at=?
                    WHERE inst_id=?
                    """,
                    (new_s, entry, ct_mult, old_prem + pr.notional, _now(), inst_id),
                )
            else:
                conn.execute(
                    """
                    INSERT INTO sim_option_positions(
                        inst_id, side, sheets, entry_px, ct_mult, premium_paid_usdc, updated_at
                    ) VALUES (?,?,?,?,?,?,?)
                    ON CONFLICT(inst_id) DO UPDATE SET
                        sheets=excluded.sheets,
                        entry_px=excluded.entry_px,
                        ct_mult=excluded.ct_mult,
                        premium_paid_usdc=excluded.premium_paid_usdc,
                        updated_at=excluded.updated_at
                    """,
                    (inst_id, "buy", float(n), pr.fill_px, ct_mult, pr.notional, _now()),
                )
            conn.commit()
        finally:
            conn.close()

        ord_id = f"sim-opt-{uuid.uuid4().hex[:16]}"
        self._store_option_order(
            ord_id=ord_id, inst_id=inst_id, side="buy", sheets=n, avg_px=pr.fill_px
        )
        return {
            "ok": True,
            "data": {"ordId": ord_id, "sCode": "0", "sMsg": "sim filled"},
            "raw": {"sim": True},
            "px": pr.fill_px,
            "ord_type": "ioc",
            "info": {"sim": True, "fee": pr.fee, "fill": pr.to_dict()},
        }

    def sell_option_close(
        self,
        exchange_options: Any,
        *,
        inst_id: str,
        sheets: int,
        price: float | None = None,
        fee_rate: float | None = None,
        **_kwargs: Any,
    ) -> dict[str, Any]:
        n = int(sheets)
        if n < 1:
            return {"ok": False, "msg": "张数至少为 1"}
        conn = self.get_db()
        try:
            row = conn.execute(
                "SELECT * FROM sim_option_positions WHERE inst_id=?",
                (inst_id,),
            ).fetchone()
            if not row or float(row["sheets"] or 0) <= 1e-12:
                return {"ok": False, "msg": "模拟期权无对应持仓"}
            pos_s = float(row["sheets"])
            ct_mult = float(row["ct_mult"] or 0.01)
            close_n = min(pos_s, float(n))
            if close_n <= 0:
                return {"ok": False, "msg": "平仓张数无效"}
            fr = sim_fee_rate(fee_rate)
            bid, ask, _ = _option_bid_ask(exchange_options, inst_id)
            if price is not None and float(price) > 0:
                bid = max(float(bid), float(price)) if float(price) > 0 else float(bid)
            qty = close_n * ct_mult
            pr = option_fill(action="close", bid=bid, ask=ask, qty=qty, fee_rate=fr)
            credit = pr.notional - pr.fee
            remain = pos_s - close_n
            if remain <= 1e-12:
                conn.execute("DELETE FROM sim_option_positions WHERE inst_id=?", (inst_id,))
            else:
                prem = float(row["premium_paid_usdc"] or 0) * (remain / pos_s)
                conn.execute(
                    """
                    UPDATE sim_option_positions
                    SET sheets=?, premium_paid_usdc=?, updated_at=?
                    WHERE inst_id=?
                    """,
                    (remain, prem, _now(), inst_id),
                )
            conn.commit()
        finally:
            conn.close()

        if credit > 0:
            self.wallets.credit_trading(
                "USDC",
                credit,
                kind="option_close",
                note=f"sell {inst_id} x{close_n}@{pr.fill_px}",
            )
        ord_id = f"sim-opt-close-{uuid.uuid4().hex[:16]}"
        self._store_option_order(
            ord_id=ord_id, inst_id=inst_id, side="sell", sheets=close_n, avg_px=pr.fill_px
        )
        return {
            "ok": True,
            "data": {"ordId": ord_id, "sCode": "0", "sMsg": "sim filled"},
            "raw": {"sim": True},
            "px": pr.fill_px,
            "ord_type": "ioc",
            "info": {"sim": True, "fee": pr.fee, "fill": pr.to_dict()},
        }

    def convert_usdt_usdc(
        self,
        exchange: Any,
        *,
        direction: str,
        amount: float,
        fee_rate: float | None = None,
        account: str = "trading",
        symbol: str = "USDC/USDT",
    ) -> dict[str, Any]:
        """模拟 USDC-USDT 现货市价兑换, 默认扣交易账户."""
        from lib.sim.pricing_lib import spot_usdc_usdt_fill

        fr = sim_fee_rate(fee_rate)
        bid, ask = _ticker_bid_ask(exchange, symbol)
        fill = spot_usdc_usdt_fill(
            direction=direction, amount=float(amount), bid=bid, ask=ask, fee_rate=fr
        )
        result = SimWallets(self.get_db).convert(
            from_ccy=fill.from_ccy,
            to_ccy=fill.to_ccy,
            amount=fill.from_amount,
            account=account or "trading",
            to_amount=fill.to_amount,
            rate=fill.fill_px,
            fee=fill.fee,
            note=f"USDC/USDT mkt {fill.fill_px:.6f} (bid {bid:.6f}/ask {ask:.6f})",
        )
        if not result.get("ok"):
            return result
        result.update(
            {
                "direction": fill.direction,
                "bid": bid,
                "ask": ask,
                "base_px": fill.base_px,
                "fill_px": fill.fill_px,
                "fee_rate": fr,
                "symbol": symbol,
            }
        )
        return result

    def _index_px_for_option(
        self,
        exchange: Any,
        inst_id: str,
        *,
        idx_cache: dict[str, float | None] | None = None,
    ) -> float | None:
        """到期结算/持仓展示用指数价:优先合约行情,否则 family 指数."""
        from lib.exchange.okx_options_lib import (
            fetch_index_price,
            inst_family_from_inst_id,
            quote_option_contract,
        )

        cache = idx_cache if idx_cache is not None else {}
        if exchange is None or not inst_id:
            return None
        try:
            q = quote_option_contract(exchange, inst_id)
            if q.get("ok") and q.get("index_px") is not None:
                return float(q["index_px"])
        except Exception:
            pass
        family = inst_family_from_inst_id(inst_id) or ""
        uly = family.replace("_UM", "") if family else ""
        if not uly:
            return None
        if uly not in cache:
            try:
                cache[uly] = fetch_index_price(exchange, uly)
            except Exception:
                cache[uly] = None
        return cache.get(uly)

    def settle_expired_option_positions(
        self,
        exchange: Any = None,
        *,
        now_ms: int | None = None,
    ) -> list[dict[str, Any]]:
        """模拟盘到期结算:按指数内在价值兑付后删除本地仓(无实盘交割).

        虚值兑付 0;实值 credit 交易账户 USDC.同时回写 options_trades 为 closed.
        """
        import time

        from lib.exchange.okx_options_lib import (
            expiry_ms_from_inst_id,
            option_fields_from_inst_id,
        )
        from lib.hedge_plan.hedge_plan_calc_lib import option_expiry_pnl

        now = int(now_ms if now_ms is not None else time.time() * 1000)
        settled: list[dict[str, Any]] = []
        idx_cache: dict[str, float | None] = {}

        for p in self.list_option_positions():
            inst_id = str(p.get("inst_id") or "").strip()
            if not inst_id:
                continue
            exp_ms = expiry_ms_from_inst_id(inst_id)
            if exp_ms is None or now < int(exp_ms):
                continue
            opt_type, strike = option_fields_from_inst_id(inst_id)
            if strike is None:
                continue
            spot = self._index_px_for_option(exchange, inst_id, idx_cache=idx_cache)
            if spot is None:
                # 无指数则本轮跳过,避免实值误按 0 结算
                continue

            sheets = float(p.get("sheets") or 0)
            ct_mult = float(p.get("ct_mult") or 0.01)
            prem = float(p.get("premium_paid_usdc") or 0)
            pnl = float(
                option_expiry_pnl(
                    opt_type=str(opt_type or "P"),
                    strike=float(strike),
                    spot=float(spot),
                    sheets=sheets,
                    ct_mult=ct_mult,
                    premium_paid=prem,
                )
            )
            settle_recv = round(max(0.0, prem + pnl), 4)
            o = (opt_type or "").strip().upper()
            if o in ("C", "CALL"):
                intrinsic_u = max(0.0, float(spot) - float(strike))
            elif o in ("P", "PUT"):
                intrinsic_u = max(0.0, float(strike) - float(spot))
            else:
                intrinsic_u = 0.0

            conn = self.get_db()
            try:
                conn.execute("DELETE FROM sim_option_positions WHERE inst_id=?", (inst_id,))
                try:
                    closed_at = _now()
                    conn.execute(
                        """
                        UPDATE options_trades
                        SET status = 'closed',
                            close_quote = ?,
                            premium_received = ?,
                            realized_pnl = ?,
                            closed_at = COALESCE(closed_at, ?),
                            signal_note = CASE
                                WHEN signal_note IS NULL OR TRIM(signal_note) = ''
                                THEN '到期结算'
                                ELSE signal_note
                            END
                        WHERE inst_id = ? AND status = 'open'
                        """,
                        (
                            round(intrinsic_u, 6),
                            settle_recv,
                            round(pnl, 4),
                            closed_at,
                            inst_id,
                        ),
                    )
                except Exception:
                    pass
                conn.commit()
            finally:
                conn.close()

            if settle_recv > 1e-12:
                self.wallets.credit_trading(
                    "USDC",
                    settle_recv,
                    kind="option_expiry",
                    note=f"expiry settle {inst_id} @{spot:g} recv={settle_recv}",
                )
            ord_id = f"sim-opt-exp-{uuid.uuid4().hex[:16]}"
            self._store_option_order(
                ord_id=ord_id,
                inst_id=inst_id,
                side="settle",
                sheets=sheets,
                avg_px=intrinsic_u,
            )
            try:
                from lib.options.options_positions_lib import forget_close_gate_for_inst

                forget_close_gate_for_inst(inst_id)
            except Exception:
                pass
            settled.append(
                {
                    "inst_id": inst_id,
                    "spot": spot,
                    "intrinsic": intrinsic_u,
                    "premium_received": settle_recv,
                    "realized_pnl": round(pnl, 4),
                    "ord_id": ord_id,
                }
            )
        return settled

    def option_positions_okx_rows(self, exchange: Any = None) -> list[dict[str, Any]]:
        """对齐 OKX positions 行字段, 供 format_position_row 使用.

        模拟盘补充公开行情的 idxPx / markPx, 否则指数价与平掉回本均为空.
        拉取前先结算已到期仓,避免虚值到期后一直挂在当前持仓.
        """
        from lib.exchange.okx_options_lib import (
            expiry_ms_from_inst_id,
            option_fields_from_inst_id,
            quote_option_contract,
        )

        try:
            self.settle_expired_option_positions(exchange)
        except Exception:
            pass

        rows: list[dict[str, Any]] = []
        idx_cache: dict[str, float | None] = {}
        for p in self.list_option_positions():
            inst_id = str(p["inst_id"] or "")
            sheets = float(p["sheets"])
            entry = float(p["entry_px"])
            ct_mult = float(p.get("ct_mult") or 0.01)
            opt_type, strike = option_fields_from_inst_id(inst_id)
            mark = entry
            idx = None
            exp_ms = expiry_ms_from_inst_id(inst_id)

            if exchange is not None and inst_id:
                try:
                    q = quote_option_contract(exchange, inst_id)
                    if q.get("ok"):
                        raw_mark = q.get("mark")
                        if raw_mark is None:
                            raw_mark = q.get("bid")
                        if raw_mark is not None and float(raw_mark) > 0:
                            mark = float(raw_mark)
                        if q.get("index_px") is not None:
                            idx = float(q["index_px"])
                        if q.get("opt_type"):
                            opt_type = str(q["opt_type"])
                        if q.get("strike") is not None:
                            strike = float(q["strike"])
                        if q.get("exp_time") is not None:
                            try:
                                exp_ms = int(float(q["exp_time"]))
                            except (TypeError, ValueError):
                                pass
                except Exception:
                    pass
                if idx is None:
                    idx = self._index_px_for_option(exchange, inst_id, idx_cache=idx_cache)

            eth = abs(sheets) * ct_mult
            upl = (mark - entry) * eth
            prem = float(p.get("premium_paid_usdc") or 0) or (entry * eth)
            upl_ratio = (upl / prem) if prem > 1e-12 else 0.0
            row: dict[str, Any] = {
                "instId": inst_id,
                "pos": str(sheets),
                "availPos": str(sheets),
                "avgPx": str(entry),
                "markPx": str(mark),
                "upl": str(round(upl, 4)),
                "uplRatio": str(round(upl_ratio, 6)),
                "posSide": "long",
                "mgnMode": "isolated",
            }
            if idx is not None:
                row["idxPx"] = str(idx)
            if opt_type:
                row["optType"] = opt_type
            if strike is not None:
                row["stk"] = str(strike)
            if exp_ms:
                row["expTime"] = str(exp_ms)
            rows.append(row)
        return rows