"""
Exchange Order Manager — places TP/SL orders on Binance Futures.

Shared by all 3 strategies (WT, Scalp, Gerchik).

TP = regular LIMIT order (reduceOnly) → maker fee 0.02%, queryable
SL = STOP_MARKET (algo/conditional) → instant on Binance, NOT queryable
     but we detect SL fill by: position gone + TP order still unfilled

cancel_all_orders() clears both regular and algo orders.
"""

import logging
from typing import Optional

from trader import BinanceFuturesTrader

logger = logging.getLogger(__name__)

# Fees
MAKER_FEE_PCT = 0.02
TAKER_FEE_PCT = 0.04


class ExchangeOrderManager:
    """Manages exchange-side TP and SL orders."""

    def __init__(self, trader: BinanceFuturesTrader):
        self.trader = trader

    def place_tp_sl_orders(
        self,
        symbol: str,
        side: str,
        sl_price: float,
        sl_quantity: float,
        tp_levels: list[tuple[float, float]],
    ) -> dict:
        """
        Place SL + multiple TP orders on Binance.

        Args:
            symbol: e.g. "BTCUSDT"
            side: position side ("BUY" or "SELL")
            sl_price: stop loss trigger price
            sl_quantity: total position quantity for SL
            tp_levels: [(tp_price, quantity), ...] — TP levels with qty per level

        Returns:
            {"sl_order_id": int|None, "tp_order_ids": [int|None, ...]}
        """
        result = {"sl_order_id": None, "tp_order_ids": []}

        # Place SL (STOP_MARKET — algo order, not queryable but executes on Binance)
        sl_order = self.trader.place_stop_market(symbol, side, sl_quantity, sl_price)
        if sl_order:
            result["sl_order_id"] = sl_order["orderId"]  # This is algoId
            logger.info(f"SL placed: {symbol} algo#{sl_order['orderId']} @ ${sl_price:.6f}")
        else:
            logger.error(f"Failed to place SL for {symbol}")

        # Place TPs (regular LIMIT reduceOnly — queryable, maker fee)
        closing_side = "SELL" if side == "BUY" else "BUY"
        for tp_price, tp_qty in tp_levels:
            tp_order = self.trader.open_limit_order(
                symbol, closing_side, tp_qty, tp_price, reduce_only=True
            )
            if tp_order:
                result["tp_order_ids"].append(tp_order["orderId"])
                logger.info(f"TP limit: {symbol} #{tp_order['orderId']} @ ${tp_price:.6f} qty={tp_qty}")
            else:
                result["tp_order_ids"].append(None)
                logger.error(f"Failed to place TP for {symbol} @ ${tp_price:.6f}")

        return result

    def cancel_and_replace_sl(
        self,
        symbol: str,
        old_sl_order_id: Optional[int],
        side: str,
        new_sl_price: float,
        quantity: float,
    ) -> Optional[int]:
        """
        Cancel ALL orders for symbol, re-place SL + remaining TPs.

        Since algo orders can't be cancelled individually, we cancel everything
        then re-place the SL. Caller must re-place any remaining TP orders too.

        Returns new SL algo order ID or None.
        """
        # Cancel everything (works for both regular LIMIT and algo STOP_MARKET)
        self.trader.cancel_all_orders(symbol)

        # Place new SL
        sl_order = self.trader.place_stop_market(symbol, side, quantity, new_sl_price)
        if sl_order:
            logger.info(f"SL replaced: {symbol} algo#{sl_order['orderId']} @ ${new_sl_price:.6f}")
            return sl_order["orderId"]

        logger.error(f"Failed to replace SL for {symbol}")
        return None

    def replace_sl_and_tps(
        self,
        symbol: str,
        side: str,
        new_sl_price: float,
        sl_quantity: float,
        remaining_tp_levels: list[tuple[float, float]],
    ) -> dict:
        """
        Cancel all orders and re-place SL + remaining TPs.

        Used after TP1/TP2 fills when SL needs to move.

        Returns {"sl_order_id": int|None, "tp_order_ids": [int|None, ...]}
        """
        # Cancel all (regular + algo) — now with verification
        success = self.trader.cancel_all_orders(symbol)
        if not success:
            logger.error(f"replace_sl_and_tps: cancel failed for {symbol}, placing anyway")

        # Re-place everything
        return self.place_tp_sl_orders(
            symbol, side, new_sl_price, sl_quantity, remaining_tp_levels
        )

    def cancel_all_for_symbol(self, symbol: str) -> bool:
        """Cancel all open orders (manual close, external close, time-stop)."""
        return self.trader.cancel_all_orders(symbol)