#!/usr/bin/env python3
"""
GENESIS Brain Feed — Hourly Telegram Broadcast
Every 60 minutes: scans all strategies in parallel, reports open trades,
P&L, what each strategy is seeing, and the outlook for the next hour.
"""
import os, json, time, logging, threading, sys
from datetime import datetime, timezone, timedelta
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed, TimeoutError
import subprocess, requests, yaml

sys.path.insert(0, str(Path(__file__).parent))
from mt5_bridge import bridge as _bridge

# ── Config ─────────────────────────────────────────────────────────────────────
TOKEN    = os.getenv("TELEGRAM_BOT_TOKEN")
CHAT_ID  = os.getenv("TELEGRAM_CHAT_ID", "")
AGENT    = "/opt/hermes-agent"
PYTHON   = f"{AGENT}/.venv-hermes/bin/python3"
SCAN_TIMEOUT = 55  # seconds per strategy scan

JOURNALS = {
    "GENESIS-v2": "/var/log/hermes/trade_journal.jsonl",
    "ARES-v1":    "/var/log/ares/trade_journal.jsonl",
    "APOLLO-v1":  "/var/log/apollo/trade_journal.jsonl",
    "ATHENA-v1":  "/var/log/athena/trade_journal.jsonl",
    "ARTEMIS-v1": "/var/log/artemis/trade_journal.jsonl",
    "HEPH-v1":    "/var/log/hephaestus/trade_journal.jsonl",
    "ZEUS-v1":    "/var/log/zeus/trade_journal.jsonl",
}

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
log = logging.getLogger(__name__)

def tg(msg: str):
    """Send message, splitting if >4000 chars."""
    for chunk in [msg[i:i+4000] for i in range(0, len(msg), 4000)]:
        try:
            requests.post(f"https://api.telegram.org/bot{TOKEN}/sendMessage",
                json={"chat_id": CHAT_ID, "text": chunk, "parse_mode": "Markdown"},
                timeout=10)
            time.sleep(0.3)
        except Exception as e:
            log.error(f"tg send error: {e}")

def bridge(path) -> dict:
    return _bridge(path)

def run_tool(name: str, tool_file: str, cmd: str, symbol: str = "") -> dict:
    """Run a strategy tool and return parsed JSON result with timeout."""
    args = [PYTHON, f"{AGENT}/{tool_file}", cmd]
    if symbol: args.append(symbol)
    try:
        result = subprocess.run(args, capture_output=True, text=True,
                                timeout=SCAN_TIMEOUT, cwd=AGENT)
        if result.stdout.strip():
            return json.loads(result.stdout.strip())
        return {"error": result.stderr.strip()[:100] or "No output"}
    except subprocess.TimeoutExpired:
        return {"error": "timeout"}
    except Exception as e:
        return {"error": str(e)[:100]}

def journal_summary(path: str, hours: int = 1) -> dict:
    """Summarize trades in the last N hours from a journal file."""
    p = Path(path)
    if not p.exists(): return {"trades": 0, "wins": 0, "losses": 0, "pnl": 0.0, "open": 0}
    cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
    trades = wins = losses = open_t = 0
    pnl = 0.0
    try:
        for line in p.read_text().strip().split("\n"):
            if not line: continue
            try:
                t = json.loads(line)
                opened = t.get("opened","")
                if opened:
                    try:
                        dt = datetime.fromisoformat(opened.replace("Z","+00:00"))
                        if dt < cutoff: continue
                    except: continue
                trades += 1
                result = t.get("result")
                p_val  = float(t.get("pnl") or 0)
                if result == "win":   wins += 1;     pnl += p_val
                elif result == "loss": losses += 1;  pnl += p_val
                elif result is None:  open_t += 1
            except: continue
    except: pass
    return {"trades": trades, "wins": wins, "losses": losses, "pnl": round(pnl,2), "open": open_t}

def icon(action):
    return "🟢" if action == "trade" else "⚪"

def fmt_strategy_result(name: str, result: dict) -> str:
    action = result.get("action","wait")
    if action == "trade":
        return (f"{icon(action)} *{name}*: SIGNAL {result.get('direction','?')} "
                f"`{result.get('symbol','?')}` "
                f"R:R {result.get('rr_ratio','?')} | "
                f"Vol {result.get('volume','?')} | "
                f"Score {result.get('confidence_score',result.get('confidence','?'))}")
    reason = result.get("reason","")[:80]
    layer  = result.get("layer","")
    prog   = f" [{layer}]" if layer else ""
    return f"{icon(action)} *{name}*: WAIT{prog} — {reason}"

def fmt_heph_status(result: dict) -> str:
    if "error" in result:
        return f"⚙️ *HEPHAESTUS*: {result['error'][:80]}"
    enabled = result.get("enabled", False)
    bl = result.get("buy_level",0); sl = result.get("sell_level",0)
    lots = result.get("total_lots",0); pnl = result.get("unrealized_pnl",0)
    status = "RUNNING" if enabled else f"DISABLED — {result.get('killed_reason','?')}"
    return (f"⚙️ *HEPHAESTUS*: {status} | "
            f"Buy L{bl} Sell L{sl} | {lots}lots | PnL €{pnl:.2f}")

def estimate_next_hour(scan_results: dict) -> list[str]:
    """Generate outlook text based on current scan results + session timing."""
    now_utc  = datetime.now(timezone.utc)
    hr       = now_utc.hour + now_utc.minute/60
    weekday  = now_utc.weekday()  # 0=Mon 4=Fri 5=Sat 6=Sun

    signals  = [(n,r) for n,r in scan_results.items() if r.get("action")=="trade"]
    waits    = [(n,r) for n,r in scan_results.items() if r.get("action")!="trade"]
    lines    = []

    # ── Session context ────────────────────────────────────────────
    is_weekend = weekday >= 5
    in_asia    = 0  <= hr <  5
    in_london  = 7  <= hr < 11
    in_ny      = 12 <= hr < 17
    in_session = not is_weekend and (5 <= hr < 21)

    if is_weekend:
        opens_in = (6 - weekday) * 24 - hr + 22  # hours until Mon 22:00 UTC
        lines.append(f"🌙 *Weekend* — markets closed.")
        lines.append(f"  Forex opens ~{round(opens_in,1)}h from now (Mon 22:00 UTC)")
        lines.append(f"  Hermes resumes scanning at session open.")
    elif in_london:
        lines.append("🏦 *London session active* (07:00–11:00 UTC)")
        lines.append("  Zeus + Apollo most active here. Expect 1–3 scan cycles.")
    elif in_ny:
        lines.append("🗽 *New York session active* (12:00–17:00 UTC)")
        lines.append("  Zeus + Apollo most active. Ares/Athena also scanning.")
    elif in_asia:
        lines.append("🌏 *Asian session* (00:00–05:00 UTC) — lower volatility")
        lines.append("  Ares + Athena may fire on GBPJPY/XAUUSD ranging moves.")
    elif not in_session:
        next_open = 5 - hr if hr < 5 else 29 - hr  # next 05:00 UTC
        lines.append(f"🌙 *Off-hours* — strategies paused.")
        lines.append(f"  Next session opens in ~{abs(round(next_open,1))}h (05:00 UTC)")
        lines.append(f"  London killzone in ~{round(max(0,7-hr),1)}h — Zeus high-probability window")

    lines.append("")

    # ── Live signals ───────────────────────────────────────────────
    if signals:
        lines.append(f"🔥 *{len(signals)} live signal(s) ready:*")
        for name, r in signals:
            lines.append(f"  → {name}: {r.get('direction')} `{r.get('symbol')}` "
                         f"— Hermes will evaluate for execution")

    # ── Almost-ready signals ───────────────────────────────────────
    for name, r in waits:
        reason = r.get("reason","")
        layer  = r.get("layer","")
        score  = r.get("score", r.get("confidence_score", 0)) or 0
        if "cooldown" in reason.lower():
            lines.append(f"⏱ {name}: cooldown — resets shortly")
        elif "2/3" in layer or "3/3" in layer:
            lines.append(f"🔶 {name}: *{layer}* — one more confirmation needed")
        elif isinstance(score, (int, float)) and score > 50:
            lines.append(f"🔶 {name}: score {score}/100 — approaching threshold (65)")

    if not signals and not any(
        "cooldown" in r.get("reason","").lower() or
        r.get("score",0) > 50
        for _, r in waits
    ):
        if in_session:
            lines.append("📊 All strategies in WAIT — market likely in low-conviction state")
            lines.append("  Hermes scanning every 5min cycle. Will fire when conditions align.")
        elif not is_weekend:
            lines.append("📊 Strategies dormant during off-hours — normal behaviour")

    return lines

def build_report(acc, positions, scan_results, heph_result, journal_summaries) -> str:
    now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
    balance = float(acc.get("balance",0))
    equity  = float(acc.get("equity",0))
    profit  = float(acc.get("profit",0))

    lines = [
        f"🧠 *GENESIS — Hourly Brain Feed*",
        f"📅 {now}",
        f"",
        f"━━━━━ 💰 ACCOUNT ━━━━━",
        f"Balance: `€{balance:,.2f}` | Equity: `€{equity:,.2f}`",
        f"Floating P&L: `€{profit:+.2f}`",
        f"",
    ]

    # ── Open Positions ─────────────────────────────────────────────
    lines.append("━━━━━ 📈 OPEN POSITIONS ━━━━━")
    if isinstance(positions, list) and positions:
        for p in positions:
            pnl_val = float(p.get("profit",0))
            pnl_icon = "🟢" if pnl_val >= 0 else "🔴"
            lines.append(
                f"{pnl_icon} `{p.get('symbol')}` {p.get('orderType')} "
                f"{p.get('lots')}lot | P&L: `€{pnl_val:+.2f}` | [{p.get('comment')}]"
            )
    else:
        lines.append("  No open positions")

    # ── Journal summary (last hour) ────────────────────────────────
    lines.append(f"")
    lines.append("━━━━━ 📒 LAST HOUR TRADES ━━━━━")
    total_trades = total_wins = total_losses = 0
    total_pnl = 0.0
    any_activity = False
    for strat, summ in journal_summaries.items():
        if summ["trades"] > 0:
            any_activity = True
            total_trades += summ["trades"]
            total_wins   += summ["wins"]
            total_losses += summ["losses"]
            total_pnl    += summ["pnl"]
            lines.append(
                f"  `{strat}`: {summ['trades']} trade(s) | "
                f"{summ['wins']}W {summ['losses']}L | "
                f"P&L: `€{summ['pnl']:+.2f}`"
            )
    if not any_activity:
        lines.append("  No completed trades in the last hour")
    else:
        lines.append(f"  *Total:* {total_trades} trades | "
                     f"{total_wins}W {total_losses}L | `€{total_pnl:+.2f}`")

    # ── Strategy Scans ─────────────────────────────────────────────
    lines.append(f"")
    lines.append("━━━━━ 🔬 STRATEGY SCANS ━━━━━")
    for name, result in scan_results.items():
        lines.append(fmt_strategy_result(name, result))
    lines.append(fmt_heph_status(heph_result))

    # ── Next Hour Outlook ──────────────────────────────────────────
    lines.append(f"")
    lines.append("━━━━━ 🔭 NEXT HOUR OUTLOOK ━━━━━")
    for l in estimate_next_hour(scan_results):
        lines.append(l)

    lines.append(f"")
    lines.append("_Next broadcast in ~60 min_")

    return "\n".join(lines)

def run_broadcast():
    log.info("=== Brain Feed broadcast starting ===")
    start = time.time()

    # ── Parallel strategy scans ────────────────────────────────────
    scan_tasks = {
        "ARES":    ("strategies/ares/ares_tool.py",        "analyze", "EURUSDxx"),
        "APOLLO":  ("strategies/apollo/apollo_tool.py",    "analyze", "EURUSDxx"),
        "ATHENA":  ("strategies/athena/athena_tool.py",    "analyze", "EURUSDxx"),
        "ARTEMIS": ("strategies/artemis/artemis_tool.py",  "analyze", "EURUSDxx"),
        "ZEUS":    ("strategies/zeus/zeus_tool.py",        "analyze", "EURUSDxx"),
    }
    scan_results = {}
    heph_result  = {}

    with ThreadPoolExecutor(max_workers=6) as ex:
        futures = {
            ex.submit(run_tool, name, tool, cmd, sym): name
            for name, (tool, cmd, sym) in scan_tasks.items()
        }
        futures[ex.submit(run_tool, "HEPH", "strategies/hephaestus/hephaestus_tool.py", "status", "")] = "HEPH"

        for fut in as_completed(futures, timeout=SCAN_TIMEOUT+10):
            name = futures[fut]
            try:
                result = fut.result(timeout=1)
                if name == "HEPH":
                    heph_result = result
                else:
                    scan_results[name] = result
            except Exception as e:
                if name == "HEPH": heph_result = {"error": str(e)[:60]}
                else: scan_results[name] = {"action":"wait","reason":f"Scan error: {str(e)[:60]}"}

    # ── Account + positions ────────────────────────────────────────
    acc       = bridge("/balance")
    positions = bridge("/positions")
    if not isinstance(positions, list): positions = []

    # ── Journal summaries ──────────────────────────────────────────
    journal_summaries = {tag: journal_summary(path, hours=1)
                         for tag, path in JOURNALS.items()}

    # ── Build and send ─────────────────────────────────────────────
    report = build_report(acc, positions, scan_results, heph_result, journal_summaries)
    tg(report)
    elapsed = round(time.time() - start, 1)
    log.info(f"=== Brain Feed sent ({elapsed}s) ===")

if __name__ == "__main__":
    run_broadcast()