"""
Config centralizzata per la strategia del RETTANGOLO.
Legge lista asset da rettangolo_assets.csv (modificabile a mano, no riavvio per il monitor).
"""
import csv
from pathlib import Path

ASSETS_CSV = Path(__file__).parent / "rettangolo_assets.csv"

# Mapping timeframe testuale -> minuti (per Bybit API)
TF_TO_MIN = {
    "1m": "1", "5m": "5", "15m": "15", "30m": "30",
    "1H": "60", "2H": "120", "3H": "180", "4H": "240",
    "6H": "360", "12H": "720", "1D": "D", "D": "D",
}

# === MANIFESTO CHART: size + leva fisse (per Mattia, 2026-07-15) ===
# Regola: ogni ordine ha order value (nozionale) <= 1500 USDT e leva 3x fissa.
# Quindi margin massimo = 1500 / 3 = 500 USDT per ordine (size fissa = 500 USDT margin).
# FIX 2026-07-16 (Verifier): portato da 500 a 1500 nozionale (= 500 margin con leva 3x)
# per matchare Charter live convention "MAX 500 USDT per ordine" = margin, non nozionale.
ORDER_VALUE_USD = 1500.0  # nozionale massimo per ordine (qty * price) = 500 USDT margin con leva 3x
LEVERAGE = 3              # leva fissa (impostata su Bybit per symbol)

# === SAFETY CAP: max posizioni aperte contemporaneamente su Bybit (2026-07-15) ===
# Ragione: Pine puo' aprire 2-3 posizioni in pochi minuti, e se siamo gia' pieni
# meglio skippare nuovi entry piuttosto che andare in over-exposure.
# Vecchia regola "max 3" hardcoded che Mattia ricordava: NON esiste piu' nel codice.
# Alzo a 10 per dare margine (5 strategie x 2 side = 10 worst-case).
MAX_OPEN_POSITIONS = 10


def max_qty_for_order_value(current_price):
    """Calcola la qty massima che mantiene l'order value entro ORDER_VALUE_USD.
    Return float. NON side-specific (LONG e SHORT usano la stessa size)."""
    if not current_price or current_price <= 0:
        return 0.0
    return ORDER_VALUE_USD / float(current_price)


def load_assets(only_enabled=True, strategy=None):
    """Ritorna lista di dict {symbol, timeframe, tf_min, enabled, strategy, notes}.
    Se only_enabled=True, filtra solo gli asset con enabled=true.
    Se strategy != None, filtra solo gli asset con quella strategy (es. 'rettangolo', 'vptr3').
    Se il CSV non esiste o e' vuoto, ritorna lista vuota (mai eccezione).
    Backward-compat: se colonna 'strategy' manca nel CSV, default 'rettangolo'."""
    if not ASSETS_CSV.exists():
        return []
    out = []
    try:
        with open(ASSETS_CSV, "r", encoding="utf-8") as f:
            reader = csv.DictReader(f)
            for row in reader:
                symbol = (row.get("symbol") or "").strip().upper()
                tf_txt = (row.get("timeframe") or "").strip()
                if not symbol or not tf_txt:
                    continue
                tf_min = TF_TO_MIN.get(tf_txt, "60")
                enabled = (row.get("enabled") or "").strip().lower() in ("true", "1", "yes", "y")
                if only_enabled and not enabled:
                    continue
                strat = (row.get("strategy") or "rettangolo").strip().lower() or "rettangolo"
                if strategy and strat != strategy.lower():
                    continue
                out.append({
                    "symbol": symbol,
                    "timeframe": tf_txt,
                    "tf_min": tf_min,
                    "enabled": enabled,
                    "strategy": strat,
                    "notes": (row.get("notes") or "").strip(),
                })
    except Exception:
        return []
    return out


def load_symbol_tf(only_enabled=True, strategy=None):
    """Shortcut: ritorna dict {symbol: tf_min} per SLTP engine (TUTTE le strategie)."""
    return {a["symbol"]: a["tf_min"] for a in load_assets(only_enabled=only_enabled, strategy=strategy)}


def get_strategy_for_symbol(symbol: str, default: str = "rettangolo") -> str:
    """Ritorna la strategia registrata per il symbol in rettangolo_assets.csv.
    Se il symbol non e' nel CSV, ritorna `default` (default: 'rettangolo').
    Usata dal webhook per validare che Pine Alert strategy matchi con quella registrata.
    Esempi:
      get_strategy_for_symbol('BTCUSDT') -> 'rettangolo' (se BTC e' in CSV con strategy=rettangolo)
      get_strategy_for_symbol('DASHUSDT') -> 'vptr3' (se DASH e' in CSV con strategy=vptr3)
      get_strategy_for_symbol('XYZUSDT')   -> 'rettangolo' (default, XYZ non e' in CSV)
    """
    if not symbol:
        return default
    sym = symbol.strip().upper()
    for asset in load_assets():
        if asset["symbol"] == sym:
            return asset["strategy"]
    return default


def is_symbol_in_csv(symbol: str) -> bool:
    """True se il symbol e' registrato in rettangolo_assets.csv (qualsiasi strategia)."""
    if not symbol:
        return False
    sym = symbol.strip().upper()
    for asset in load_assets():
        if asset["symbol"] == sym:
            return True
    return False


def load_symbols(only_enabled=True, strategy=None):
    """Shortcut: ritorna lista di symbol strings (TUTTE le strategie di default)."""
    return [a["symbol"] for a in load_assets(only_enabled=only_enabled, strategy=strategy)]


if __name__ == "__main__":
    # mini-test
    print("Assets enabled:", load_assets())
    print("Symbols:", load_symbols())
    print("SYMBOL_TF:", load_symbol_tf())