import time
import datetime
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from typing import Optional # Used for type hints where a value might be None

def parse_binance_position(raw: dict, current_price: float) -> Optional[dict]:
    """
    Parse a raw Binance futures position dict into a unified dictionary schema.

    Parameters
    ----------
    raw           : Response dict from `futures_position_information()`.
    current_price : Latest mark price for PnL calculation.

    Returns
    -------
    Dictionary representing the position or None if no position is open.
    """
    # Extract relevant fields from the raw Binance data
    entry = float(raw.get("entryPrice", 0))
    amt   = float(raw.get("positionAmt", 0))
    lev   = float(raw.get("leverage", 1))

    # If entry price or amount is zero, there's no open position to track
    if entry == 0 or amt == 0:
        return None

    # Determine position direction (long or short)
    direction  = "long" if amt > 0 else "short"
    quantity   = abs(amt)
    notional   = quantity * current_price # Calculate current notional value
    pnl_usd    = float(raw.get("unrealizedProfit", 0))
    # Calculate PnL percentage relative to entry value
    pnl_pct    = (pnl_usd / (quantity * entry)) * 100 if entry else 0

    # Return a dictionary with normalized data
    return {
        "exchange":      "Binance",
        "symbol":        raw.get("symbol", ""),
        "direction":     direction,
        "entry_price":   entry,
        "current_price": current_price,
        "quantity":      quantity,
        "notional_usd":  round(notional, 2),
        "pnl_usd":       round(pnl_usd, 4),
        "pnl_pct":       round(pnl_pct, 4),
        "leverage":      lev,
        "timestamp":     datetime.datetime.now(datetime.UTC).strftime("%Y-%m-%d %H:%M:%S")
    }

def parse_bybit_position(raw: dict, current_price: float) -> Optional[dict]:
    """
    Parse a raw Bybit position dict into a unified dictionary schema.

    Parameters
    ----------
    raw           : Item from `get_positions()['result']['list']`.
    current_price : Latest mark price.

    Returns
    -------
    Dictionary representing the position or None if no position is open.
    """
    # Extract average entry price from raw Bybit data
    avg_price = raw.get("avgPrice", "0")
    # If no average price, no open position
    if avg_price in ("", "0"):
        return None

    entry     = float(avg_price)
    size      = float(raw.get("size", 0))
    side      = raw.get("side", "").lower()
    direction = "long" if side == "buy" else "short"
    pnl_usd   = float(raw.get("unrealisedPnl", 0))
    notional  = size * current_price
    pnl_pct   = (pnl_usd / (size * entry)) * 100 if entry else 0

    return {
        "exchange":      "Bybit",
        "symbol":        raw.get("symbol", ""),
        "direction":     direction,
        "entry_price":   entry,
        "current_price": current_price,
        "quantity":      size,
        "notional_usd":  round(notional, 2),
        "pnl_usd":       round(pnl_usd, 4),
        "pnl_pct":       round(pnl_pct, 4),
        "leverage":      float(raw.get("leverage", 1)),
        "timestamp":     datetime.datetime.now(datetime.UTC).strftime("%Y-%m-%d %H:%M:%S")
    }

def parse_kraken_position(raw: dict, current_price: float) -> Optional[dict]:
    """
    Parse a raw Kraken Futures position dict into a unified dictionary schema.

    Parameters
    ----------
    raw           : Item from `get_open_positions()['openPositions']`.
    current_price : Latest mark price.

    Returns
    -------
    Dictionary representing the position or None if no position is open.
    """
    # Extract position size, entry price, and side from raw Kraken data
    size  = float(raw.get("size", 0))
    entry = float(raw.get("price", 0))
    side  = raw.get("side", "").lower()

    # If size or entry price is zero, no open position
    if size == 0 or entry == 0:
        return None

    direction = "long" if side == "long" else "short"
    # Calculate PnL based on position direction
    if direction == "long":
        pnl_usd = (current_price - entry) * size
    else:
        pnl_usd = (entry - current_price) * size

    notional = size * current_price
    pnl_pct  = (pnl_usd / (size * entry)) * 100 if entry else 0

    return {
        "exchange":      "Kraken",
        "symbol":        raw.get("symbol", ""),
        "direction":     direction,
        "entry_price":   entry,
        "current_price": current_price,
        "quantity":      size,
        "notional_usd":  round(notional, 2),
        "pnl_usd":       round(pnl_usd, 4),
        "pnl_pct":       round(pnl_pct, 4),
        "leverage":      1.0, # Kraken raw data might not provide leverage directly, default to 1.0
        "timestamp":     datetime.datetime.now(datetime.UTC).strftime("%Y-%m-%d %H:%M:%S")
    }

def create_position_manager(tp_alert_pct: float = 2.0, sl_alert_pct: float = -1.0) -> dict:
    """
    Initializes a new position manager as a dictionary.

    Parameters
    ----------
    tp_alert_pct : PnL% threshold above which a TP alert is raised.
    sl_alert_pct : PnL% threshold below which an SL alert is raised.

    Returns
    -------
    A dictionary representing the position manager state.
    """
    return {
        "tp_alert_pct": tp_alert_pct,
        "sl_alert_pct": sl_alert_pct,
        "_positions":   [],
        "_snapshots":   []
    }

def add_position(manager: dict, pos: dict) -> None:
    """
    Registers a parsed position dictionary into the manager.
    """
    if pos is not None:
        manager["_positions"].append(pos)

def clear_positions(manager: dict) -> None:
    """
    Clears current positions in the manager (executed before each refresh cycle).
    """
    manager["_positions"] = []

def get_snapshot(manager: dict) -> pd.DataFrame:
    """
    Returns a DataFrame of all current positions and saves a historical snapshot.
    """
    positions_list = manager["_positions"]
    if not positions_list:
        # Define column names based on the expected keys in position dictionaries
        columns = [
            "exchange", "symbol", "direction", "entry_price", "current_price",
            "quantity", "notional_usd", "pnl_usd", "pnl_pct", "leverage", "timestamp"
        ]
        return pd.DataFrame(columns=columns)
    df = pd.DataFrame(positions_list)
    manager["_snapshots"].append(df)
    return df

def get_summary(manager: dict) -> dict:
    """
    Computes aggregate statistics across all tracked positions in the manager.
    """
    positions_list = manager["_positions"]
    if not positions_list:
        return {"total_positions": 0, "total_pnl_usd": 0, "total_notional": 0}

    total_pnl      = sum(p["pnl_usd"]       for p in positions_list)
    total_notional = sum(p["notional_usd"]   for p in positions_list)
    n_long         = sum(1 for p in positions_list if p["direction"] == "long")
    n_short        = sum(1 for p in positions_list if p["direction"] == "short")
    avg_pnl_pct    = np.mean([p["pnl_pct"] for p in positions_list]) if positions_list else 0

    return {
        "total_positions": len(positions_list),
        "long_positions":  n_long,
        "short_positions": n_short,
        "total_pnl_usd":   round(total_pnl, 4),
        "total_notional":  round(total_notional, 2),
        "avg_pnl_pct":     round(avg_pnl_pct, 4),
    }

def check_alerts(manager: dict) -> list[str]:
    """
    Evaluates Take-Profit (TP) and Stop-Loss (SL) alert conditions for positions in the manager.

    Returns
    -------
    List of alert message strings for positions breaching defined thresholds.
    """
    alerts = []
    tp_alert_pct = manager["tp_alert_pct"]
    sl_alert_pct = manager["sl_alert_pct"]
    for p in manager["_positions"]:
        if p["pnl_pct"] >= tp_alert_pct:
            alerts.append(f"[TP ALERT] {p['exchange']} {p['symbol']} {p['direction'].upper()} "
                           f"PnL: {p['pnl_pct']:.2f}% — Consider closing.")
        if p["pnl_pct"] <= sl_alert_pct:
            alerts.append(f"[SL ALERT] {p['exchange']} {p['symbol']} {p['direction'].upper()} "
                           f"PnL: {p['pnl_pct']:.2f}% — Risk threshold breached.")
    return alerts

def display_positions(manager: dict) -> None:
    """
    Prints a formatted position table and summary to the console for the manager's positions.

    Includes alerts for TP/SL breaches.
    """
    df  = get_snapshot(manager)
    sm  = get_summary(manager)
    als = check_alerts(manager)

    print("\n" + "="*70)
    print(f" POSITION SNAPSHOT — {datetime.datetime.now(datetime.UTC).strftime('%Y-%m-%d %H:%M:%S')} UTC")
    print("="*70)
    if df.empty:
        print(" No open positions.")
    else:
        # Select and rename columns for display to match the original class output format
        display_df = df[[
            "exchange", "symbol", "direction", "entry_price", "current_price",
            "quantity", "notional_usd", "pnl_usd", "pnl_pct", "leverage", "timestamp"
        ]]
        display_df.columns = [
            "Exchange", "Symbol", "Direction", "Entry Price", "Current Price",
            "Quantity", "Notional (USD)", "PnL (USD)", "PnL (%)", "Leverage", "Snapshot Time"
        ]
        print(display_df.to_string(index=False))
    print("-"*70)
    for k, v in sm.items():
        print(f"  {k:<22}: {v}")
    if als:
        print("-"*70)
        for alert in als:
            print(f"  ⚠  {alert}")
    print("="*70 + "\n")

def simulated_positions():
    """
    Return synthetic position list for testing the monitor loop.

    Each call generates a slightly varied current price.
    """
    import random
    # Simulate a fluctuating current price for BTC
    price = 50_000 + random.uniform(-500, 500)
    raw   = {"symbol": "BTCUSDT", "entryPrice": "50000.0",
             "positionAmt": "0.1", "unrealizedProfit": str((price-50_000)*0.1), "leverage": "2"}
    # Return a list containing one simulated Binance position dictionary
    return [parse_binance_position(raw, price)]

# ── Generate synthetic position data ──────────────────────────────────────
# Initialize position manager with custom alert thresholds
manager = create_position_manager(tp_alert_pct=2.0, sl_alert_pct=-1.0)

# Simulated raw data from exchanges ──────────────────────────────────────

# Binance position (BTC long example)
binance_raw = {"symbol": "BTCUSDT", "entryPrice": "68000.0", "positionAmt": "0.15",
               "unrealizedProfit": "210.0", "leverage": "5"}
btc_current_price = 69_400.0
# Parse and add the Binance position to the manager
add_position(manager, parse_binance_position(binance_raw, btc_current_price))

# Bybit position (ETH short example)
bybit_raw = {"symbol": "ETHUSDT", "avgPrice": "3500.0", "size": "2.0",
             "side": "Sell", "unrealisedPnl": "80.0", "leverage": "3"}
eth_current_price = 3_460.0
# Parse and add the Bybit position to the manager
add_position(manager, parse_bybit_position(bybit_raw, eth_current_price))

# Kraken position (BTC short in loss example)
kraken_raw = {"symbol": "PF_XBTUSD", "price": "69000.0", "size": "0.05", "side": "short"}
# Parse and add the Kraken position to the manager
add_position(manager, parse_kraken_position(kraken_raw, 69_500.0))

# ── Display manager output ─────────────────────────────────────────────────
# Display the aggregated positions, summary, and any alerts
display_positions(manager)

def run_position_monitor(get_positions_fn, interval_s: int = 10,
                          max_cycles: int = None) -> None:
    """
    Run a continuous position monitoring loop.

    Parameters
    ----------
    get_positions_fn : Callable() → list[dict] — fetches fresh position data.
    interval_s       : Seconds between refresh cycles.
    max_cycles       : Optional limit for number of cycles (None = infinite).
    """
    # Initialize a new position manager for the monitor
    manager = create_position_manager()
    cycle   = 0
    print(f"[MONITOR] Starting position tracker. Refresh: {interval_s}s")

    while True:
        # Clear existing positions in the manager before fetching new ones
        clear_positions(manager)
        try:
            positions = get_positions_fn() # Fetch fresh position data (list of dicts)
            for pos in positions:
                add_position(manager, pos) # Add each fetched position to the manager
            display_positions(manager) # Display the updated positions and summary
        except Exception as e:
            print(f"[ERROR] Failed to fetch positions: {e}")

        cycle += 1
        if max_cycles is not None and cycle >= max_cycles:
            print("[MONITOR] Max cycles reached. Stopping.")
            break # Exit loop if max cycles are reached
        time.sleep(interval_s) # Pause for the defined interval before the next cycle

# To run the continuous monitoring, uncomment the line below:
# run_position_monitor(simulated_positions, interval_s=2, max_cycles=3)