from signal_hub import submit_signal_ea  # EA hub
import os
import json
from datetime import datetime
try:
    from autogen import AssistantAgent, UserProxyAgent
except Exception:
    try:
        from autogen_agentchat.agents import AssistantAgent, UserProxyAgent
    except Exception:
        AssistantAgent = None
        UserProxyAgent = None
import time, threading
# from ai_loop import generate_signal as gpt_signal  # -> lazy import poniżej
from rl_decision_block import rl_generate_signal
from sentiment_engine import analyze_sentiment
import threading
import uuid

# ?? BEZPOŚREDNI KLUCZ (TYLKO DO TESTÓW, NIE PUBLICZNIE!)
import openai
openai.api_key = "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"

# ========== ?? CONFIG ==========
AUTOGEN_AVAILABLE = (AssistantAgent is not None and UserProxyAgent is not None)

llm_config = {
    "config_list": [{
        "model": "gpt-4o",
        "api_key": openai.api_key
    }],
    "temperature": 0.2,
    "max_tokens": 4096
}

# ========== ?? GPT CORE AGENT ==========
if AUTOGEN_AVAILABLE:
    agent = AssistantAgent(
        name="GPT_Imperium",
        llm_config=llm_config,
        system_message=(
            "Jesteś centralnym mózgiem systemu tradingowego. "
            "Twoim celem jest świadomie analizować dane z RL, GPT-loop, sentymentu rynkowego, equity.json i poprzednich decyzji. "
            "Podejmujesz autonomiczne decyzje BUY / SELL / HOLD i zapisujesz je w signal.json. "
            "Pamiętasz przeszłość, chronisz kapitał, nie modyfikujesz plików bez zgody."
        )
    )
    
    user = UserProxyAgent(
        name="DominikAI",
        code_execution_config={
            "work_dir": "/opt/quantconnect/lean_root/US100FinalPush_proj",
            "use_docker": False
        }
    )
    
    # ========== ?? POMOCNICZE FUNKCJE ==========
    def read_equity():
        try:
            with open("equity.json", "r") as f:
                return json.load(f)
        except:
            return {}
    
    def read_last_signal():
        try:
            with open("signal.json", "r") as f:
                return json.load(f)
        except:
            return {}
    
    def auto_set_tp_sl(decision, equity_data):
        base_equity = equity_data.get("net_profit", 10000)
        sl = round(base_equity * 0.01, 2)
        tp = round(base_equity * 0.02, 2)
        if decision == "hold":
            return None, None
        return sl, tp
    
    # ========== ?? CENTRALNA LOGIKA DECYZYJNA ==========
    def _lazy_gpt_signal():
    try:
        from ai_loop import generate_signal as _gen
        return _gen()
    except Exception as e:
        print(f'⚠️ lazy import generate_signal failed: {e}')
        return 'hold'

\1equity_data, last_signal):
        sentiment = analyze_sentiment()
        rl = rl_generate_signal()
        gpt = _lazy_gpt_signal()
    
        thought_log = {
            "sentiment": sentiment,
            "rl": rl,
            "gpt": gpt,
            "equity": equity_data,
            "previous": last_signal.get("signal", "none")
        }
    
        final = "hold"
        if gpt == rl:
            final = gpt
        elif sentiment == "bullish" and gpt == "buy":
            final = "buy"
        elif sentiment == "bearish" and gpt == "sell":
            final = "sell"
    
        thought_log["final_decision"] = final
        return final, thought_log
    # removed bad def submit_signal line
        signal = {
            "timestamp": datetime.utcnow().isoformat(),
            "symbol": "NAS100USD",
            "decision": final_decision,
            "open_price": None,
            "sl": sl,
            "tp": tp,
            "source": "GPT_Imperium_GD2"
        }
        with open("signal.json", "w") as f:
            json.dump(signal, f, indent=4)
    
    def write_decision_log(log):
        try:
            with open("decision_log.json", "a") as f:
                f.write(json.dumps(log) + "\n")
        except Exception as e:
            print(f"❌ Błąd zapisu logu decyzji: {e}")
    
    # ========== ?? RUN ==========
    user.initiate_chat(
        agent,
        message="Rozpocznij analizę rynku. Podejmij decyzję BUY/SELL/HOLD na podstawie RL, GPT-loop, sentymentu, equity.json i poprzedniego sygnału. Zapisz wynik do signal.json."
    )

equity_data = read_equity()
last_signal = read_last_signal()
final_decision, log = deep_think_rl_gpt_sentiment(equity_data, last_signal)
sl, tp = auto_set_tp_sl(final_decision, equity_data)
submit_signal({"symbol": "NAS100USD", "decision": final_decision.upper(), "open_price": None, "sl": sl, "tp": tp}, source="GPT_Imperium")
write_decision_log(log)

print("✅ GPT_Imperium zakończył pełny cykl decyzyjny GD2.")

# ==== ⛵ SIGNAL HUB (EMBEDDED W GPT_Imperium) ====
# Jeden punkt zapisu do MT5, z anty-spam/anty-duplikacją.
PROJECT_ROOT = "/opt/quantconnect/lean_root"
EA_SIGNAL = "/root/.wine/drive_c/Program Files/MetaTrader 5/MQL5/Files/signal.json"
LOCAL_SIGNAL = os.path.join(PROJECT_ROOT, "signal.json")
PLAIN_SIGNAL = os.path.join(PROJECT_ROOT, "signal_plain.txt")
LAST_DECISION_FILE = os.path.join(PROJECT_ROOT, "last_decision.json")

_LOCK = threading.Lock()
_MIN_SECONDS_BETWEEN_WRITES = 8
_IGNORE_NEUTRAL_TO_MT5 = True
_state = {"last_write_ts": 0.0}

def _safe_write_json(path, data):
    tmp = f"{path}.tmp"
    with open(tmp, "w") as f:
        json.dump(data, f, indent=4)
    os.replace(tmp, path)

def submit_signal(payload: dict, source: str="GPT_Imperium"):
    """
    payload = {
      "symbol": "USTEC"/"NAS100USD"/..., "decision": "BUY"/"SELL"/"HOLD"/"NEUTRAL",
      "open_price": float|None, "sl": float|None, "tp": float|None, (opcjonalnie "meta": {...})
    }
    """
    now = time.time()
    with _LOCK:
        enriched = {
            "timestamp": datetime.utcnow().isoformat(),
            "source": source,
            **payload
        }

        # zawsze log lokalny
        try:
            _safe_write_json(LOCAL_SIGNAL, enriched)
            with open(PLAIN_SIGNAL, "a") as pf:
                pf.write(f"{enriched['timestamp']} {enriched.get('symbol')} {enriched.get('decision')} from {source}\n")
            print(f"?? GPT_Imperium/HUB: proposal saved locally: {enriched.get('decision')} {enriched.get('symbol')}")
        except Exception as e:
            print(f"❌ GPT_Imperium/HUB local save error: {e}")

        # anty-flood
        if now - _state["last_write_ts"] < _MIN_SECONDS_BETWEEN_WRITES:
            print("⏳ GPT_Imperium/HUB: debounced write.")
            return enriched

        # nie pchamy NEUTRAL/HOLD do MT5 (można wyłączyć flagą)
        if _IGNORE_NEUTRAL_TO_MT5 and str(enriched.get("decision","")).upper() in ("NEUTRAL","HOLD",""):
            print("?? GPT_Imperium/HUB: neutral/hold -> log only (no MT5).")
            _state["last_write_ts"] = now
            return enriched

        # zapis do EA
        try:
            _safe_write_json(EA_SIGNAL, enriched)
            print(f"✅ GPT_Imperium/HUB: MT5 signal written: {enriched.get('decision')} {enriched.get('symbol')}")
            _state["last_write_ts"] = now
        except Exception as e:
            print(f"❌ GPT_Imperium/HUB MT5 write error: {e}")

        return enriched

# ==== EA Signal Hub Adapter (bez naruszania istniejących funkcji) ====
PROJECT_ROOT = "/opt/quantconnect/lean_root"
EA_SIGNAL = "/root/.wine/drive_c/Program Files/MetaTrader 5/MQL5/Files/signal.json"
LOCAL_SIGNAL = os.path.join(PROJECT_ROOT, "signal.json")
PLAIN_SIGNAL = os.path.join(PROJECT_ROOT, "signal_plain.txt")
RICH_SIGNAL = os.path.join(PROJECT_ROOT, "signal_rich.json")
LAST_ACTIONS = os.path.join(PROJECT_ROOT, "last_actions.json")

_LOCK = threading.Lock()
_MIN_SECONDS_BETWEEN_WRITES = 8
_IGNORE_NEUTRAL_TO_MT5 = True

def _safe_write_json(path, data):
    tmp = f"{path}.tmp"
    with open(tmp, "w") as f:
        json.dump(data, f, indent=4)
    os.replace(tmp, path)

def _read_json(path, default):
    try:
        with open(path, "r") as f:
            return json.load(f)
    except:
        return default

def _map_symbol(symbol: str) -> str:
    m = {"NAS100USD":"USTEC","NAS100":"USTEC","US100":"USTEC","USTEC":"USTEC","XAUUSD":"XAUUSD","BTCUSD":"BTCUSD"}
    return m.get((symbol or "").upper(), symbol)

def _map_action(decision: str) -> str:
    d = (decision or "").strip().upper()
    if d in ("BUY","LONG"): return "BUY"
    if d in ("SELL","SHORT"): return "SELL"
    if d in ("HOLD","NEUTRAL",""): return "NEUTRAL"
    return "NEUTRAL"

def submit_signal_ea(payload: dict, source: str="GPT_Imperium"):
    """
    Przyjmuje payload (decision/sl/tp/...), loguje bogato i zapisuje plik EA:
    { "type": BUY/SELL, "symbol": "USTEC", "id": "...", "lot": 1.0 }
    """
    now = time.time()
    with _LOCK:
        rich = {"timestamp": datetime.utcnow().isoformat(), "source": source, **payload}
        try:
            _safe_write_json(RICH_SIGNAL, rich)
            with open(PLAIN_SIGNAL, "a") as pf:
                pf.write(f"{rich['timestamp']} {rich.get('symbol')} {rich.get('decision')} from {source}\n")
        except Exception as e:
            print(f"❌  Rich save error: {e}")

        sym = _map_symbol(rich.get("symbol","USTEC"))
        act = _map_action(rich.get("decision",""))

        if _IGNORE_NEUTRAL_TO_MT5 and act in ("NEUTRAL","HOLD"):
            print("ℹ️  NEUTRAL/HOLD -> tylko log rich, bez wysyłki do MT5.")
            return rich

        last = _read_json(LAST_ACTIONS, {})
        prev = last.get(sym, {"action": None, "ts": 0})
        if prev["action"] == act and (now - prev["ts"]) < _MIN_SECONDS_BETWEEN_WRITES:
            print(f"⏳  Debounce: {sym} {act} (zbyt szybko po poprzednim).")
            return rich

        lotfile = os.path.join(os.path.dirname(EA_SIGNAL), f"lot_{sym}.json")
        lot = float(_read_json(lotfile, 1.0)) if os.path.exists(lotfile) else 1.0

        ea = {
            "type": act,  # EA czyta 'type'
            "symbol": sym,
            "id": f"{sym.lower()}_{uuid.uuid4().hex[:6]}",
            "lot": lot    # EA czyta 'lot'
        }

        try:
            _safe_write_json(EA_SIGNAL, ea)
            last[sym] = {"action": act, "ts": now}
            _safe_write_json(LAST_ACTIONS, last)
            print(f"✅  EA signal written -> {ea}")
        except Exception as e:
            print(f"❌  EA write error: {e}")

        return rich