mt5-tools/view_live_mt5_eas.py

"""
view_ftp_tracker.py
===================
FTP-based multi-account MT5 tracker.
Pulls HTML reports from FTP, parses via mt5_parser, shows calendar + analysis.

Config: ftp_accounts.json  (labels, balances per account)
Cache:  cache/ftp_*.pkl    (parsed DataFrames, refreshed on demand)
FTP:    ftp_config.json    (host/user/pass)
"""

import streamlit as st
import pandas as pd
import plotly.graph_objects as go
from datetime import date, datetime, timedelta
import calendar
import pickle
import json
import ftplib
from pathlib import Path

try:
    from streamlit_autorefresh import st_autorefresh
    HAS_AUTOREFRESH = True
except ImportError:
    HAS_AUTOREFRESH = False

CONFIG_FILE   = Path("ftp_config.json")
ACCOUNTS_FILE = Path("ftp_accounts.json")
CACHE_DIR     = Path("cache")
CACHE_MAX_AGE = 5   # minutes before auto-refresh on load


# ── Config helpers ─────────────────────────────────────────────────────────────

def load_ftp_config() -> dict:
    if CONFIG_FILE.exists():
        return json.loads(CONFIG_FILE.read_text())
    return {}


def load_account_configs() -> list:
    if ACCOUNTS_FILE.exists():
        return json.loads(ACCOUNTS_FILE.read_text())
    return []


def save_account_configs(accounts: list):
    ACCOUNTS_FILE.write_text(json.dumps(accounts, indent=2))


# ── FTP + parse ────────────────────────────────────────────────────────────────

def ftp_list_accounts(cfg: dict) -> list:
    ftp = ftplib.FTP()
    ftp.connect(cfg["host"], cfg.get("port", 21), timeout=10)
    ftp.login(cfg["user"], cfg["password"])
    ftp.set_pasv(True)
    items = []
    ftp.retrlines("LIST", items.append)
    folders = [i.split()[-1] for i in items if i.startswith("d")]
    ftp.quit()
    return folders


def ftp_download_report(cfg: dict, account_folder: str) -> bytes | None:
    ftp = ftplib.FTP()
    ftp.connect(cfg["host"], cfg.get("port", 21), timeout=15)
    ftp.login(cfg["user"], cfg["password"])
    ftp.set_pasv(True)
    try:
        ftp.cwd(f"/{account_folder}")
    except ftplib.error_perm:
        ftp.quit()
        return None
    files = []
    ftp.retrlines("NLST", files.append)
    htm = next((f for f in files if f.lower().endswith(('.htm','.html'))), None)
    if not htm:
        ftp.quit()
        return None
    buf = []
    ftp.retrbinary(f"RETR {htm}", buf.append)
    ftp.quit()
    return b"".join(buf)


def _extract_report_date(raw: bytes) -> str | None:
    """Extract the report generation date from MT5 HTML report header."""
    import re
    for enc in ['utf-16', 'utf-8', 'latin-1']:
        try:
            text = raw.decode(enc)
            break
        except Exception:
            text = None
    if not text:
        return None
    # Look for Date: 2026.04.17 20:06 pattern in table cells
    # Strip tags first so whitespace/newlines between 'Date:' and value don't block match
    text_clean = re.sub(r'<[^>]+>', ' ', text)
    match = re.search(r'Date:\s*(\d{4}\.\d{2}\.\d{2}\s+\d{2}:\d{2})', text_clean)
    if match:
        try:
            from datetime import datetime as _dt
            return _dt.strptime(match.group(1).strip(), '%Y.%m.%d %H:%M').isoformat()
        except Exception:
            return None
    return None


def refresh_account(cfg: dict, account_folder: str, label: str = "") -> dict:
    """Download, parse, cache one account. Returns {df, stats, error}."""
    from mt5_parser import detect_and_parse, calc_stats
    raw = ftp_download_report(cfg, account_folder)
    if raw is None:
        return {"error": f"No report found for {account_folder}"}
    df, fmt = detect_and_parse(raw, f"{account_folder}.htm")
    if df is None:
        return {"error": f"Could not parse report for {account_folder}"}
    stats = calc_stats(df) if not df.empty else {}
    from mt5_parser import parse_open_positions
    df_open = parse_open_positions(raw)
    
    data = {
        "account_folder": account_folder,
        "label"         : label or account_folder,
        "df"            : df,
        "stats"         : stats,
        "fmt"           : fmt,
        "df_open"       : df_open,
        "fetched_at"    : datetime.now().isoformat(),
        "report_date"   : _extract_report_date(raw),
        "error"         : None,
    }
    CACHE_DIR.mkdir(exist_ok=True)
    (CACHE_DIR / f"ftp_{account_folder}.pkl").write_bytes(pickle.dumps(data))
    return data
    
    data = {
        "account_folder": account_folder,
        "label"         : label or account_folder,
        "df"            : df,
        "stats"         : stats,
        "fmt"           : fmt,
        "df_open"       : df_open,
        "fetched_at"    : datetime.now().isoformat(),
        "report_date"   : _extract_report_date(raw),
        "error"         : None,
    }
    CACHE_DIR.mkdir(exist_ok=True)
    (CACHE_DIR / f"ftp_{account_folder}.pkl").write_bytes(pickle.dumps(data))
    return data


def load_cache(account_folder: str) -> dict | None:
    p = CACHE_DIR / f"ftp_{account_folder}.pkl"
    if not p.exists():
        return None
    try:
        return pickle.loads(p.read_bytes())
    except Exception:
        return None


def cache_age_minutes(account_folder: str) -> float:
    p = CACHE_DIR / f"ftp_{account_folder}.pkl"
    if not p.exists():
        return float("inf")
    return (datetime.now().timestamp() - p.stat().st_mtime) / 60


def get_all_cached() -> list[dict]:
    if not CACHE_DIR.exists():
        return []
    out = []
    for p in sorted(CACHE_DIR.glob("ftp_*.pkl")):
        try:
            out.append(pickle.loads(p.read_bytes()))
        except Exception:
            pass
    return out


# ── Render ─────────────────────────────────────────────────────────────────────

def render():
    st.title("📡 Live MT5 EA's")

    ftp_cfg = load_ftp_config()
    if not ftp_cfg:
        st.warning("⚙️ **FTP not configured** — follow the setup guide below to get started.")

        st.markdown("---")
        st.markdown("## 📡 Setup Guide")
        st.markdown(
            "The Live MT5 EAs page pulls account history HTML reports from an FTP server "
            "that each MT5 terminal publishes to automatically. No MetaTrader5 Python library "
            "is required — the connection uses Python's built-in `ftplib`."
        )

        st.markdown("""
**Architecture overview:**
- **Remote Windows machine** — one or more MT5 terminals running EAs, each configured to auto-publish account history reports to a FileZilla FTP server every 5 minutes
- **FTP server (FileZilla Server)** — receives reports and stores them in per-account subfolders
- **MT5 Tools** — pulls reports from FTP, parses them, and displays them here

> **Key point:** MT5 and FileZilla are typically on the same machine. MT5 connects to FileZilla via `127.0.0.1` (loopback) so no firewall rule is needed between them. The only firewall rule needed is **port 21 open inbound** so MT5 Tools can connect from outside the LAN.
""")

        with st.expander("**Part 1 — FileZilla Server Setup**", expanded=True):
            st.markdown("""
**Installation**

Download FileZilla Server from [filezilla-project.org](https://filezilla-project.org) and install it on the remote Windows machine that runs the MT5 terminals. The free version is sufficient.

**Create FTP User**

After installation, open the FileZilla Server interface (system tray icon or Start menu):

| Step | Action |
|------|--------|
| 1 | Go to **Server → Configure** (or Edit → Users in older versions) |
| 2 | Click **Add user** and create a user named `mt5ftp` (or any name you choose) |
| 3 | Set a strong password for the user |
| 4 | Under **Directories** (or Mount Points), add a home directory — e.g. `C:\\MT5FTP\\` |
| 5 | Grant the user **Read** and **Write** permissions on that directory |
| 6 | Click **OK** to save |

*The home directory becomes the FTP root. MT5 will create subfolders here — one per account.*

**Disable TLS (Required for MT5 Compatibility)**

MT5's built-in FTP publisher uses plain FTP and does not support TLS. FileZilla Server defaults to requiring TLS, which causes a connection failure.

| Step | Action |
|------|--------|
| 1 | In FileZilla Server, go to **Server → Configure** |
| 2 | Navigate to the **FTP over TLS** settings section |
| 3 | Change from **Require explicit FTP over TLS** to **Allow plain FTP** |
| 4 | Click OK to save and restart FileZilla Server if prompted |

> ⚠️ **Security note:** Plain FTP transmits credentials unencrypted. This is acceptable on a private local network. If exposing the FTP server to the internet, consider using a VPN.

**Passive Mode Port Range**

FileZilla Server uses passive mode for data connections. If accessing from outside the local network, open the passive port range in the Windows firewall. The default range is `49152–65534`. You can restrict this (e.g. `50000–50100`) in FileZilla Server settings to reduce the number of ports to open.

**Verify FileZilla is Running**

Confirm FileZilla Server is running and listening on port 21 by checking the system tray. You can also test from FileZilla Client on the same machine using `127.0.0.1` as the host.
""")

        with st.expander("**Part 2 — MT5 Terminal Configuration**"):
            st.markdown("""
Each MT5 terminal must be configured individually to publish its account history to a dedicated subfolder on the FTP server.

**FTP Publisher Settings**

In each MT5 terminal:

| Step | Action |
|------|--------|
| 1 | Go to **Tools → Options** |
| 2 | Click the **Publisher** tab (some versions label it FTP or Report Publishing) |
| 3 | Check **Enable automatic publishing of reports via FTP** |
| 4 | Set **Server** to `127.0.0.1` (loopback — MT5 and FileZilla are on the same machine) |
| 5 | Set **Port** to `21` |
| 6 | Set **Login** to the FileZilla username (e.g. `mt5ftp`) |
| 7 | Set **Password** to the FileZilla user password |
| 8 | Set **Path** to `/ACCOUNT_NUMBER/` — e.g. `/123456/` — using the account number of that terminal |
| 9 | Check **Passive mode** |
| 10 | Set the publishing interval (recommended: **5 minutes**) |
| 11 | Click **Test** — you should see a success message |
| 12 | Click **OK** to save, then click **Publish manually** to create the first report |

> MT5 creates the subfolder automatically on first publish. The path must be unique per terminal — use the account number to keep them separate.

**Common Issues**

| Issue | Fix |
|-------|-----|
| TLS error on Test | TLS has not been disabled in FileZilla Server — see Part 1 |
| Test succeeds but no file appears | Ensure path is set correctly (e.g. `/123456/` not `/inetpub/shots`). Click Publish manually and check FileZilla Server log |
| Settings not saving | Try running MT5 as Administrator. Check each instance has its own data folder via File → Open Data Folder |
""")

        with st.expander("**Part 3 — CLI Verification**"):
            st.markdown("""
Before using this page, verify the FTP connection using the included CLI tool `ftp_sync_cli.py`.

**Initial connection test:**
```
python ftp_sync_cli.py --host 192.168.x.x --user mt5ftp --password yourpass --list
```

**Save credentials to ftp_config.json:**
```
python ftp_sync_cli.py --host 192.168.x.x --user mt5ftp --password yourpass --save
```

**Pull and parse a single account:**
```
python ftp_sync_cli.py --config --account 123456
```

**Cache all accounts:**
```
python ftp_sync_cli.py --config --account 123456 --save-cache
python ftp_sync_cli.py --config --account 789012 --save-cache
```

Each account is saved to `cache/ftp_ACCOUNT.pkl`. This page loads these automatically on startup.
""")

        with st.expander("**Part 4 — Configuration Files**"):
            st.markdown("""
| File | Location | Contents |
|------|----------|----------|
| `ftp_config.json` | MT5Tools/ | FTP host, user, password, port — **gitignored** |
| `ftp_accounts.json` | MT5Tools/ | Account labels, balances, types, prop settings — **gitignored** |
| `cache/ftp_*.pkl` | MT5Tools/cache/ | Parsed DataFrames per account — **gitignored**, auto-refreshed |

Ensure your `.gitignore` contains:
```
ftp_config.json
ftp_accounts.json
mt5_accounts.json
cache/
```
""")

        with st.expander("**Part 5 — Troubleshooting**"):
            st.markdown("""
| Issue | Solution |
|-------|----------|
| Connection refused on port 21 | Check FileZilla Server is running (system tray). Check port 21 is open in Windows firewall. Try FileZilla Client first to isolate. |
| 530 Login incorrect | Verify username and password in `ftp_config.json` match exactly. Passwords are case-sensitive. |
| No .htm/.html file found | MT5 terminal has not published yet. Go to Tools → Options → Publisher and click manual publish. Check FileZilla Server log. |
| Could not parse report | Try uploading the HTML file directly to Trade Analysis to test parsing. |
| Old data after Refresh All | MT5 publishes on a timer. Wait for the next publish cycle or trigger a manual publish in MT5. |
""")

        st.info("Once `ftp_config.json` is created via the CLI, refresh this page and the live dashboard will load.")
        return

    acc_cfgs = load_account_configs()

    # ── Account config expander ──────────────────────────────────────────────
    with st.expander("⚙️ Account Configuration", expanded=not acc_cfgs):
        st.caption("Add accounts by folder name (must match FTP folder). Set label and starting balance.")

        # ── Add account form ──────────────────────────────────────────────────
        st.markdown("**Add Account**")
        add_c1, add_c2, add_c3, add_c4, add_c5 = st.columns([2, 2, 2, 2, 1])
        new_folder  = add_c1.text_input("FTP Folder", placeholder="123456",
                                         key="cfg_new_folder")
        new_label   = add_c2.text_input("Label", placeholder="Gold EA",
                                         key="cfg_new_label")
        new_balance = add_c3.number_input("Starting Balance ($)", value=10000.0,
                                           min_value=0.0, step=1000.0, format="%.0f",
                                           key="cfg_new_balance")
        new_type    = add_c4.selectbox("Type", ["Demo","Personal","Prop"],
                                        key="cfg_new_type")
        add_c5.markdown("<br>", unsafe_allow_html=True)
        if add_c5.button("➕ Add", key="cfg_add"):
            if not new_folder.strip():
                st.error("FTP folder name is required.")
            else:
                # Verify folder exists on FTP
                try:
                    ftp_folders = ftp_list_accounts(ftp_cfg)
                    if new_folder.strip() not in ftp_folders:
                        st.error(f"Folder `{new_folder}` not found on FTP. "
                                 f"Available: {', '.join(ftp_folders)}")
                    else:
                        existing_accs = load_account_configs()
                        if any(a["account"] == new_folder.strip() for a in existing_accs):
                            st.warning(f"Account `{new_folder}` already configured.")
                        else:
                            existing_accs.append({
                                "account": new_folder.strip(),
                                "label"  : new_label.strip() or new_folder.strip(),
                                "balance": float(new_balance),
                                "type"   : new_type,
                            })
                            save_account_configs(existing_accs)
                            acc_cfgs = existing_accs
                            st.success(f"✓ Added `{new_folder}`")
                            st.rerun()
                except Exception as e:
                    st.error(f"FTP error: {e}")

        # ── Existing accounts ─────────────────────────────────────────────────
        if acc_cfgs:
            st.markdown("**Configured Accounts**")
            hdr = st.columns([1, 2, 2, 2, 2, 1, 1])
            hdr[0].markdown("**Folder**")
            hdr[1].markdown("**Label**")
            hdr[2].markdown("**Balance ($)**")
            hdr[3].markdown("**Type**")
            hdr[4].markdown("**Last Report**")
            hdr[5].markdown("**Order**")
            hdr[6].markdown("**Remove**")
            updated = []
            for idx_ac, ac in enumerate(acc_cfgs):
                if idx_ac > 0:
                    st.divider()
                c1, c2, c3, c4, c5, c6, c7 = st.columns([1, 2, 2, 2, 2, 1, 1])
                c1.markdown(f"`{ac['account']}`")
                label   = c2.text_input("", value=ac.get("label", ac["account"]),
                                        key=f"lbl_{ac['account']}",
                                        label_visibility="collapsed")
                balance = c3.number_input("", value=float(ac.get("balance", 10000)),
                                          min_value=0.0, step=1000.0, format="%.0f",
                                          key=f"bal_{ac['account']}",
                                          label_visibility="collapsed")
                acc_type = c4.selectbox("", ["Demo", "Personal", "Prop"],
                                        index=["Demo","Personal","Prop"].index(
                                            ac.get("type","Demo")),
                                        key=f"type_{ac['account']}",
                                        label_visibility="collapsed")
                # Prop-specific target/loss fields
                if acc_type == "Prop":
                    prop_c1, prop_c2, prop_c3 = st.columns(3)
                    profit_target = prop_c1.number_input(
                        "Profit target %",
                        value=float(ac.get("profit_target", 10.0)),
                        min_value=0.0, max_value=100.0, step=1.0, format="%.1f",
                        key=f"pt_{ac['account']}")
                    max_loss = prop_c2.number_input(
                        "Max loss %",
                        value=float(ac.get("max_loss", 10.0)),
                        min_value=0.0, max_value=100.0, step=1.0, format="%.1f",
                        key=f"ml_{ac['account']}")
                    daily_loss = prop_c3.number_input(
                        "Daily loss %",
                        value=float(ac.get("daily_loss", 5.0)),
                        min_value=0.0, max_value=100.0, step=0.5, format="%.1f",
                        key=f"dl_{ac['account']}")
                else:
                    profit_target = ac.get("profit_target", 10.0)
                    max_loss      = ac.get("max_loss", 10.0)
                    daily_loss    = ac.get("daily_loss", 5.0)
                # Last report date from cache
                cached = load_cache(ac["account"])
                if cached and cached.get("fetched_at"):
                    try:
                        dt = datetime.fromisoformat(cached["fetched_at"])
                        last_report = dt.strftime("%d %b %H:%M")
                    except Exception:
                        last_report = "—"
                else:
                    last_report = "No cache"
                c5.markdown(f'<div style="padding-top:8px;font-size:13px;color:#A0A8B8">{last_report}</div>',
                           unsafe_allow_html=True)
                # Up / down ordering buttons
                ob1, ob2 = c6.columns(2)
                if ob1.button("↑", key=f"up_{ac['account']}", disabled=(idx_ac == 0)):
                    acc_cfgs.insert(idx_ac - 1, acc_cfgs.pop(idx_ac))
                    save_account_configs(acc_cfgs)
                    st.rerun()
                if ob2.button("↓", key=f"dn_{ac['account']}", disabled=(idx_ac == len(acc_cfgs) - 1)):
                    acc_cfgs.insert(idx_ac + 1, acc_cfgs.pop(idx_ac))
                    save_account_configs(acc_cfgs)
                    st.rerun()
                if c7.button("🗑", key=f"rm_{ac['account']}"):
                    remaining = [a for a in acc_cfgs if a["account"] != ac["account"]]
                    save_account_configs(remaining)
                    # Clear account selector so removed account disappears
                    if "ftp_sel_accounts" in st.session_state:
                        del st.session_state["ftp_sel_accounts"]
                    st.rerun()
                updated.append({"account": ac["account"], "label": label,
                                 "balance": balance, "type": acc_type,
                                 "profit_target": profit_target,
                                 "max_loss": max_loss,
                                 "daily_loss": daily_loss})

            if st.button("💾 Save Changes", type="primary", key="cfg_save"):
                save_account_configs(updated)
                acc_cfgs = updated
                st.success("Saved.")
                st.rerun()

        # ── Refresh controls inside expander ─────────────────────────────────
        st.divider()
        rc1, rc2 = st.columns([1, 1])
        with rc1:
            do_refresh = st.button("🔄 Refresh All", type="primary",
                                   use_container_width=True, key="ftp_refresh_btn")
        with rc2:
            poll_interval = st.number_input("Auto-refresh (min)", min_value=0,
                                             max_value=60, value=5, step=5,
                                             key="ftp_poll_interval",
                                             help="0 = disabled. Page must be open.")

    if not acc_cfgs:
        st.info("Configure account labels above, then click Refresh All.")
        return

    acc_map = {a["account"]: a for a in acc_cfgs}

    # Initialise auto-refresh timer — first load always pulls from FTP
    first_load = "ftp_last_auto_refresh" not in st.session_state
    if first_load:
        st.session_state["ftp_last_auto_refresh"] = 0  # force pull on first load

    # ── Updated timestamp + autorefresh JS ───────────────────────────────────
    ages = [cache_age_minutes(a["account"]) for a in acc_cfgs
            if cache_age_minutes(a["account"]) < float("inf")]
    no_cache = any(cache_age_minutes(a["account"]) == float("inf") for a in acc_cfgs)

    if ages:
        oldest = max(ages)
        st.caption(f"🕐 Updated {oldest:.0f}m ago")

    # JavaScript-based auto-refresh — triggers a full rerun on a timer
    if poll_interval > 0:
        if HAS_AUTOREFRESH:
            st_autorefresh(interval=poll_interval * 60 * 1000, key="ftp_autorefresh")
        else:
            st.caption("💡 Install `streamlit-autorefresh` for auto-refresh: "
                       "`pip install streamlit-autorefresh`")

    # Pull from FTP on first load or when poll interval has elapsed
    last_auto        = st.session_state.get("ftp_last_auto_refresh", 0)
    now_ts           = datetime.now().timestamp()
    interval_elapsed = poll_interval > 0 and (now_ts - last_auto) >= poll_interval * 60
    auto_refresh     = first_load or interval_elapsed

    if do_refresh or no_cache or auto_refresh:
        st.session_state["ftp_last_auto_refresh"] = datetime.now().timestamp()
        label_text = "Loading..." if (no_cache or first_load) else "Refreshing..."
        prog = st.progress(0, text=label_text)
        errors = []
        for i, acfg in enumerate(acc_cfgs):
            prog.progress((i + 1) / len(acc_cfgs),
                          text=f"Fetching {acfg['label']}...")
            result = refresh_account(ftp_cfg, acfg["account"], acfg["label"])
            if result.get("error"):
                errors.append(f"**{acfg['label']}**: {result['error']}")
        prog.empty()
        if errors:
            for e in errors:
                st.error(e)
        elif do_refresh:
            st.success(f"✓ Refreshed {len(acc_cfgs)} accounts")
        st.rerun()

    # ── Load all cached data ──────────────────────────────────────────────────
    all_data = []
    for acfg in acc_cfgs:
        data = load_cache(acfg["account"])
        if data:
            data["balance"] = acfg["balance"]
            data["label"]   = acfg["label"]
            all_data.append(data)

    if not all_data:
        st.info("No cached data. Click **Refresh All**.")
        return

    # ── Account selector ──────────────────────────────────────────────────────
    st.divider()
    all_labels  = [d["label"] for d in all_data]
    sel_labels  = st.multiselect("Accounts", all_labels, default=all_labels,
                                 key="ftp_sel_accounts")
    sel_data    = [d for d in all_data if d["label"] in sel_labels]

    if not sel_data:
        st.info("Select at least one account.")
        return

    # Merge all selected DataFrames (skip empty dfs from new accounts)
    dfs = []
    for d in sel_data:
        df = d["df"].copy()
        if df.empty or "close_time" not in df.columns:
            continue
        df["_account"]  = d["label"]
        df["_balance"]  = d["balance"]
        dfs.append(df)
    if dfs:
        df_all = pd.concat(dfs, ignore_index=True)
        df_all["close_time"] = pd.to_datetime(df_all["close_time"], errors="coerce")
        df_all["open_time"]  = pd.to_datetime(df_all["open_time"],  errors="coerce")
        df_all = df_all.dropna(subset=["close_time"]).sort_values("close_time").reset_index(drop=True)
    else:
        df_all = pd.DataFrame()

    total_balance = sum(d["balance"] for d in sel_data)

    # ── Account summary table ────────────────────────────────────────────────
    st.markdown("**Account Summary**")
    _sum_cards = []
    for d in sel_data:
        acfg      = acc_map.get(d["account_folder"], {})
        acc_type  = acfg.get("type", "Demo")
        balance   = d["balance"]
        df_tmp    = d["df"].copy()

        # New account with no closed trades yet — ensure required columns exist
        if df_tmp.empty or "net_profit" not in df_tmp.columns:
            df_tmp = pd.DataFrame(columns=["net_profit", "close_time", "open_time", "win"])

        df_tmp["net_profit"]  = pd.to_numeric(df_tmp["net_profit"], errors="coerce").fillna(0)
        df_tmp["close_time"]  = pd.to_datetime(df_tmp["close_time"], errors="coerce")
        df_tmp["open_time"]   = pd.to_datetime(df_tmp["open_time"],  errors="coerce")
        df_tmp = df_tmp.sort_values("close_time").reset_index(drop=True)

        current_pnl = df_tmp["net_profit"].sum()
        current_bal = balance + current_pnl
        pnl_pct     = round(current_pnl / balance * 100, 2) if balance else 0
        pnl_color   = "#34C27A" if current_pnl >= 0 else "#E05555"
        badge_bg    = {"Demo":"rgba(124,106,247,0.3)","Personal":"rgba(52,194,122,0.3)",
                       "Prop":"rgba(255,165,0,0.3)"}.get(acc_type,"rgba(128,128,128,0.2)")

        # Report date
        rpt_date = d.get("report_date")
        try:
            fetched_str = (datetime.fromisoformat(rpt_date).strftime("%d %b %Y %H:%M")
                           if rpt_date else
                           datetime.fromisoformat(d.get("fetched_at","")).strftime("%d %b %H:%M"))
        except Exception:
            fetched_str = "—"

        # ── Recovery factor: net_profit / abs(max_dd) ─────────────────────────
        from mt5_parser import calc_stats as _cs
        _stats    = _cs(df_tmp, deposit=balance)
        max_dd    = _stats.get("max_drawdown", 0)
        recovery  = round(current_pnl / abs(max_dd), 2) if max_dd != 0 else "—"
        rec_color = "#34C27A" if isinstance(recovery, float) and recovery >= 1 else "#E05555"

        # ── Consecutive loss streak (most recent trades) ──────────────────────
        if not df_tmp.empty:
            streak = 0
            for _, row in df_tmp[::-1].iterrows():
                if row.get("win") == False or (isinstance(row.get("win"), bool) and not row["win"]):
                    streak += 1
                else:
                    break
        else:
            streak = 0
        streak_color = "#E05555" if streak >= 3 else ("#F5A623" if streak >= 1 else "#34C27A")

        # ── Stagnation: days since last equity high ───────────────────────────
        if not df_tmp.empty:
            df_tmp["_cum"]  = df_tmp["net_profit"].cumsum()
            df_tmp["_peak"] = df_tmp["_cum"].cummax()
            at_peak = df_tmp[df_tmp["_cum"] >= df_tmp["_peak"]]
            if not at_peak.empty:
                last_high = pd.to_datetime(at_peak["close_time"].max())
                stag_days = (datetime.now() - last_high).days
            else:
                stag_days = 0
        else:
            stag_days = 0
        stag_color = "#E05555" if stag_days >= 14 else ("#F5A623" if stag_days >= 7 else "#34C27A")

        # ── Today's P&L for daily loss tracking ──────────────────────────────
        today_str  = date.today().isoformat()
        today_df   = df_tmp[df_tmp["close_time"].dt.date == date.today()]
        today_pnl  = today_df["net_profit"].sum()
        today_pct  = round(today_pnl / balance * 100, 2) if balance else 0

        # ── Prop bars ─────────────────────────────────────────────────────────
        prop_bars = ""
        ea_stopped = False
        if acc_type == "Prop":
            pt   = acfg.get("profit_target", 10.0)
            ml   = acfg.get("max_loss", 10.0)
            dl   = acfg.get("daily_loss", 5.0)
            pbw  = round(min(max(pnl_pct,0), pt) / pt * 100, 1) if pt else 0
            lbw  = round(min(max(-pnl_pct,0), ml) / ml * 100, 1) if ml else 0
            dlv  = min(max(-today_pct,0), dl)
            dbw  = round(dlv / dl * 100, 1) if dl else 0
            dl_color = "#E05555" if dbw >= 80 else ("#F5A623" if dbw >= 50 else "#34C27A")
            # EA hard stop triggered when today's loss >= daily limit
            ea_stopped = dl > 0 and (-today_pct) >= dl
            stopped_banner = (
                '<div style="background:rgba(220,80,80,0.15);border:1px solid rgba(220,80,80,0.4);'
                'border-radius:4px;padding:6px 10px;margin-top:8px;font-size:12px;font-weight:600;color:#E05555">'
                '⛔ EA stopped — daily loss limit reached</div>'
            ) if ea_stopped else ""
            prop_bars = (
                '<div style="margin-top:8px">'
                f'<div style="font-size:13px;color:#A0A8B8;margin-bottom:2px">Profit {pnl_pct:+.2f}% / {pt:.0f}%</div>'
                f'<div style="background:rgba(128,128,128,0.12);border-radius:3px;height:6px;margin-bottom:6px">'
                f'<div style="background:#34C27A;width:{pbw}%;height:100%;border-radius:3px"></div></div>'
                f'<div style="font-size:13px;color:#A0A8B8;margin-bottom:2px">Max loss {min(max(-pnl_pct,0),ml):.2f}% / {ml:.0f}%</div>'
                f'<div style="background:rgba(128,128,128,0.12);border-radius:3px;height:6px;margin-bottom:6px">'
                f'<div style="background:#E05555;width:{lbw}%;height:100%;border-radius:3px"></div></div>'
                f'<div style="font-size:13px;color:#A0A8B8;margin-bottom:2px">Daily loss {today_pct:.2f}% / {dl:.0f}%</div>'
                f'<div style="background:rgba(128,128,128,0.12);border-radius:3px;height:6px">'
                f'<div style="background:{dl_color};width:{dbw}%;height:100%;border-radius:3px"></div></div>'
                f'{stopped_banner}'
                '</div>'
            )

        card = (
            '<div style="background:rgba(255,255,255,0.03);border:1px solid rgba(255,255,255,0.07);'
            'border-radius:8px;padding:12px 16px;flex:0 0 280px;min-width:280px;max-width:280px">'
            f'<div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:4px">'
            f'<span style="font-size:15px;font-weight:600">{d["label"]}</span>'
            f'<span style="font-size:12px;padding:2px 8px;border-radius:4px;background:{badge_bg};font-weight:600">{acc_type}</span>'
            '</div>'
            f'<div style="font-size:13px;color:#A0A8B8;margin-bottom:6px">Updated: {fetched_str}</div>'
            f'<div style="font-size:20px;font-weight:700;color:{pnl_color}">{current_pnl:+,.2f} ({pnl_pct:+.2f}%)</div>'
            f'<div style="font-size:13px;color:#A0A8B8;margin-top:2px">Balance: ${balance:,.0f}  →  Current: ${current_bal:,.2f}</div>'
            f'<div style="display:flex;gap:12px;margin-top:8px;flex-wrap:wrap">'
            f'<div style="font-size:13px;color:#A0A8B8">Recovery: <b style="color:{rec_color}">{recovery}</b></div>'
            f'<div style="font-size:13px;color:#A0A8B8">Loss streak: <b style="color:{streak_color}">{streak}</b></div>'
            f'<div style="font-size:13px;color:#A0A8B8">Stagnation: <b style="color:{stag_color}">{stag_days}d</b></div>'
            f'<div style="font-size:13px;color:#A0A8B8">Today: <b style="color:{"#34C27A" if today_pnl>=0 else "#E05555"}">{today_pnl:+.2f} ({today_pct:+.2f}%)</b></div>'
            '</div>'
            f'{prop_bars}'
            '</div>'
        )
        _sum_cards.append(card)

    st.markdown(
        '<div style="display:flex;gap:12px;flex-wrap:wrap;margin-bottom:16px">'
        + "".join(_sum_cards) + '</div>',
        unsafe_allow_html=True)

    # ── Open trades ──────────────────────────────────────────────────────────
    _all_open = []
    for d in sel_data:
        # Prefer parsed df_open from Open Positions section
        df_op = d.get("df_open")
        if df_op is not None and not df_op.empty:
            df_op = df_op.copy()
            df_op["_account"] = d["label"]
            _all_open.append(df_op)

    if _all_open:
        open_df = pd.concat(_all_open, ignore_index=True)
        col_order = ["_account","open_time","position","symbol","type","volume",
                     "open_price","sl","tp","market_price","swap","profit","comment"]
        show_cols = [c for c in col_order if c in open_df.columns]
        rename_map = {
            "_account"    : "Account",
            "open_time"   : "Time",
            "position"    : "Position",
            "symbol"      : "Symbol",
            "type"        : "Type",
            "volume"      : "Volume",
            "open_price"  : "Price",
            "sl"          : "S/L",
            "tp"          : "T/P",
            "market_price": "Market Price",
            "swap"        : "Swap",
            "profit"      : "Profit",
            "comment"     : "Comment",
        }
        disp = open_df[show_cols].rename(columns=rename_map).copy()
        if "Time" in disp.columns:
            disp["Time"] = pd.to_datetime(
                disp["Time"], errors="coerce"
            ).dt.strftime("%d.%m.%Y %H:%M")
        with st.expander(f"🔴 Open Positions ({len(open_df)})", expanded=True):
            st.dataframe(disp, use_container_width=True, hide_index=True)
    else:
        st.caption("No open positions in current reports.")

    # ── Correlation matrix ────────────────────────────────────────────────────
    if len(sel_data) > 1:
        with st.expander("📊 Symbol Correlation across Accounts", expanded=False):
            corr_rows = []
            for d in sel_data:
                df_c = d["df"].copy()
                if df_c.empty or "net_profit" not in df_c.columns:
                    continue
                df_c["net_profit"] = pd.to_numeric(df_c["net_profit"], errors="coerce").fillna(0)
                df_c["close_time"] = pd.to_datetime(df_c["close_time"], errors="coerce")
                by_sym = df_c.groupby("symbol")["net_profit"].sum()
                by_sym.name = d["label"]
                corr_rows.append(by_sym)
            corr_df = pd.DataFrame(corr_rows).T.fillna(0)
            if corr_df.shape[1] > 1 and len(corr_df) > 2:
                corr_matrix = corr_df.corr().round(2)
                labels = corr_matrix.columns.tolist()
                z      = corr_matrix.values.tolist()
                fig_corr = go.Figure(go.Heatmap(
                    z=z, x=labels, y=labels,
                    colorscale=[[0,"#E05555"],[0.5,"#f0f0f0"],[1,"#34C27A"]],
                    zmin=-1, zmax=1,
                    text=[[f"{v:.2f}" for v in row] for row in z],
                    texttemplate="%{text}",
                    showscale=True,
                ))
                fig_corr.update_layout(
                    height=300, title="Account Correlation (by symbol P&L)",
                    plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
                    font=dict(family="sans-serif"),
                    margin=dict(l=80,r=20,t=40,b=80),
                )
                st.plotly_chart(fig_corr, use_container_width=True, key="ftp_corr")
            else:
                st.caption("Not enough shared symbols across accounts to compute correlation."
                           " Symbols need to overlap between at least 2 accounts.")

    # Force balance update when account selection changes
    _bal_key = f"ftp_bal_{'_'.join(sorted(sel_labels))}"
    if st.session_state.get("ftp_last_bal_key") != _bal_key:
        st.session_state["ftp_last_bal_key"]  = _bal_key
        st.session_state["ftp_cal_balance"]   = float(total_balance)

    # ── Calendar section ──────────────────────────────────────────────────────
    st.subheader("Calendar")
    cal_bal = st.number_input(
        "Combined Balance ($) — for % calc",
        value=st.session_state.get("ftp_cal_balance", float(total_balance)),
        min_value=100.0, step=1000.0, format="%.0f",
        key="ftp_cal_balance",
        help="Auto-set from selected account balances. Override if needed."
    )
    cal_c1, cal_c2 = st.columns([2, 2])
    cal_view = cal_c1.radio("Calendar", ["Month", "Week", "Year"],
                             horizontal=True, key="ftp_cal_view")
    cal_unit = cal_c2.radio("Calendar unit", ["$", "%"],
                             horizontal=True, key="ftp_cal_unit")

    today = date.today()
    if "ftp_cal_y" not in st.session_state:
        st.session_state["ftp_cal_y"] = today.year
        st.session_state["ftp_cal_m"] = today.month
        st.session_state["ftp_cal_w"] = today.isocalendar()[1]

    nav1, nav2, nav3 = st.columns([1, 3, 1])
    with nav1:
        if st.button("◀", key="ftp_prev"):
            if cal_view == "Month":
                m = st.session_state["ftp_cal_m"] - 1
                if m < 1: m = 12; st.session_state["ftp_cal_y"] -= 1
                st.session_state["ftp_cal_m"] = m
            elif cal_view == "Week":
                w = st.session_state["ftp_cal_w"] - 1
                if w < 1:
                    st.session_state["ftp_cal_y"] -= 1
                    w = 52
                st.session_state["ftp_cal_w"] = w
            else:
                st.session_state["ftp_cal_y"] -= 1
            st.rerun()
    with nav3:
        if st.button("▶", key="ftp_next"):
            if cal_view == "Month":
                m = st.session_state["ftp_cal_m"] + 1
                if m > 12: m = 1; st.session_state["ftp_cal_y"] += 1
                st.session_state["ftp_cal_m"] = m
            elif cal_view == "Week":
                w = st.session_state["ftp_cal_w"] + 1
                if w > 52:
                    st.session_state["ftp_cal_y"] += 1
                    w = 1
                st.session_state["ftp_cal_w"] = w
            else:
                st.session_state["ftp_cal_y"] += 1
            st.rerun()
    with nav2:
        if cal_view == "Month":
            nav_label = f"{calendar.month_name[st.session_state['ftp_cal_m']]} {st.session_state['ftp_cal_y']}"
        elif cal_view == "Week":
            nav_label = f"Week {st.session_state['ftp_cal_w']} — {st.session_state['ftp_cal_y']}"
        else:
            nav_label = str(st.session_state["ftp_cal_y"])
        st.markdown(f"<h3 style='text-align:center;margin:4px 0'>{nav_label}</h3>",
                    unsafe_allow_html=True)

    # Build daily aggregates
    if df_all.empty:
        day_map = {}
    else:
        df_all["_day"] = df_all["close_time"].dt.date
        day_agg = df_all.groupby("_day").agg(
            pnl_dollar = ("net_profit", "sum"),
            trades     = ("net_profit", "count"),
            wins       = ("win",        "sum"),
        ).reset_index()
        day_agg["losses"]  = day_agg["trades"] - day_agg["wins"]
        day_agg["pnl_pct"] = (day_agg["pnl_dollar"] / cal_bal * 100).round(3)
        day_map = {row["_day"]: row for _, row in day_agg.iterrows()}

    # ── Summary cards for selected period ─────────────────────────────────────
    sel_y = st.session_state["ftp_cal_y"]
    sel_m = st.session_state["ftp_cal_m"]
    sel_w = st.session_state["ftp_cal_w"]

    if cal_view == "Month":
        period_days = [d for d in day_map if d.year == sel_y and d.month == sel_m]
    elif cal_view == "Week":
        period_days = [d for d in day_map
                       if d.isocalendar()[0] == sel_y and d.isocalendar()[1] == sel_w]
    else:
        period_days = [d for d in day_map if d.year == sel_y]

    period_rows = day_agg[day_agg["_day"].isin(period_days)]
    tot_pnl   = period_rows["pnl_dollar"].sum()
    tot_pct   = period_rows["pnl_pct"].sum()
    tot_tr    = int(period_rows["trades"].sum())
    tot_w     = int(period_rows["wins"].sum())
    tot_l     = int(period_rows["losses"].sum())
    wr        = round(tot_w / tot_tr * 100, 1) if tot_tr > 0 else 0
    trd_days  = len(period_rows)

    sc1,sc2,sc3,sc4,sc5,sc6 = st.columns(6)
    sc1.metric("P&L ($)",       f"${tot_pnl:,.2f}")
    sc2.metric("P&L (%)",       f"{tot_pct:+.2f}%")
    sc3.metric("Trades",        tot_tr)
    sc4.metric("Win Rate",      f"{wr}%")
    sc5.metric("Wins / Losses", f"{tot_w} / {tot_l}")
    sc6.metric("Trading Days",  trd_days)

    st.markdown("<br>", unsafe_allow_html=True)

    # ── Calendar grid ─────────────────────────────────────────────────────────
    if cal_view == "Month":
        _render_month_grid(sel_y, sel_m, day_map, today, cal_unit, cal_bal)
    elif cal_view == "Week":
        _render_week_grid(sel_y, sel_w, day_map, today, cal_unit, cal_bal)
    else:
        _render_year_grid(sel_y, day_map, today, cal_unit, cal_bal)

    # ── Trade Analysis section ────────────────────────────────────────────────
    st.divider()

    st.divider()
    st.subheader("Trade Analysis")

    if df_all.empty:
        st.info("No closed trades yet. Trade analysis will appear once trades are recorded.")
        return

    # Filters
    fc1, fc2, fc3, fc4, fc5 = st.columns(5)
    with fc1:
        valid_times = df_all["open_time"].dropna()
        d_min = valid_times.min().date()
        d_max = valid_times.max().date()
        date_from = st.date_input("From", value=d_min, min_value=d_min,
                                  max_value=d_max, key="ftp_from")
        date_to   = st.date_input("To",   value=d_max, min_value=d_min,
                                  max_value=d_max, key="ftp_to")
    with fc2:
        syms    = sorted(df_all["symbol"].dropna().unique().tolist())
        sel_sym = st.multiselect("Symbol", syms, key="ftp_sym")
    with fc3:
        # Algo from comment field
        algos    = sorted(df_all["comment"].dropna().unique().tolist())
        algos    = [a for a in algos if a.strip()]
        sel_algo = st.multiselect("Algo (comment)", algos, key="ftp_algo")
    with fc4:
        days     = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
        sel_days = st.multiselect("Day of week", days, key="ftp_days")
        sel_type = st.multiselect("Type", ["buy","sell"], key="ftp_type")
    with fc5:
        sel_accs = st.multiselect("Account", all_labels, default=sel_labels,
                                  key="ftp_acc_filter")
        # Auto-calculate balance from selected accounts in filter
        _acc_bal = sum(
            d["balance"] for d in all_data if d["label"] in (sel_accs or sel_labels)
        )
        _dep_key = f"ftp_dep_{'_'.join(sorted(sel_accs or sel_labels))}"
        if st.session_state.get("ftp_last_dep_key") != _dep_key:
            st.session_state["ftp_last_dep_key"] = _dep_key
            st.session_state["ftp_deposit"]      = float(_acc_bal)
        deposit = st.number_input(
            "Balance ($)",
            value=st.session_state.get("ftp_deposit", float(_acc_bal)),
            min_value=100.0, step=1000.0, format="%.0f",
            key="ftp_deposit",
            help="Auto-set from selected accounts. Override if needed."
        )

    # Apply filters
    df = df_all.copy()
    df = df[(df["open_time"].dt.date >= date_from) &
            (df["open_time"].dt.date <= date_to)]
    if sel_sym:   df = df[df["symbol"].isin(sel_sym)]
    if sel_algo:  df = df[df["comment"].isin(sel_algo)]
    if sel_days:  df = df[df["day_of_week"].isin(sel_days)]
    if sel_type:  df = df[df["type"].isin(sel_type)]
    if sel_accs:  df = df[df["_account"].isin(sel_accs)]
    df = df.reset_index(drop=True)

    st.caption(f"Showing **{len(df)}** trades after filters  ·  "
               f"Combined balance: **${deposit:,.0f}**")

    if df.empty:
        st.info("No trades match the current filters.")
        return

    # Analysis mode
    from mt5_parser import calc_stats
    mode = st.radio("Analysis mode",
                    ["Overall", "By Account", "By Symbol", "By Algo", "By Day of Week"],
                    horizontal=True, key="ftp_mode")
    st.divider()

    if mode == "Overall":
        _render_analysis(df, calc_stats(df, deposit=deposit), deposit, key_prefix="ftp_overall")

    elif mode == "By Account":
        accs = sorted(df["_account"].dropna().unique())
        rows = []
        for a in accs:
            s = calc_stats(df[df["_account"] == a], deposit=next((d["balance"] for d in all_data if d["label"]==a), 0))
            rows.append({"Account": a, "Trades": s["total_trades"],
                         "Net P&L": s["net_profit"], "Win Rate %": s["win_rate"],
                         "Profit Factor": s["profit_factor"],
                         "Expectancy": s["expectancy"], "Max DD": s["max_drawdown"]})
        st.dataframe(pd.DataFrame(rows).sort_values("Net P&L", ascending=False),
                     use_container_width=True, hide_index=True)
        st.divider()
        sel = st.selectbox("Account detail", accs, key="ftp_acc_sel")
        if sel:
            sub = df[df["_account"] == sel]
            _render_analysis(sub, calc_stats(sub, deposit=deposit), deposit, key_prefix=f"ftp_acc_{sel}")

    elif mode == "By Symbol":
        syms_u = sorted(df["symbol"].dropna().unique())
        rows   = []
        for s in syms_u:
            st_ = calc_stats(df[df["symbol"] == s], deposit=deposit)
            rows.append({"Symbol": s, "Trades": st_["total_trades"],
                         "Net P&L": st_["net_profit"], "Win Rate %": st_["win_rate"],
                         "Profit Factor": st_["profit_factor"],
                         "Expectancy": st_["expectancy"], "Max DD": st_["max_drawdown"]})
        st.dataframe(pd.DataFrame(rows).sort_values("Net P&L", ascending=False),
                     use_container_width=True, hide_index=True)
        sel = st.selectbox("Symbol detail", syms_u, key="ftp_sym_sel")
        if sel:
            sub = df[df["symbol"] == sel]
            _render_analysis(sub, calc_stats(sub, deposit=deposit), deposit, key_prefix=f"ftp_sym_{sel}")

    elif mode == "By Algo":
        algo_u = sorted(df["comment"].dropna().unique())
        algo_u = [a for a in algo_u if a.strip()]
        rows   = []
        for a in algo_u:
            st_ = calc_stats(df[df["comment"] == a], deposit=deposit)
            rows.append({"Algo": a, "Trades": st_["total_trades"],
                         "Net P&L": st_["net_profit"], "Win Rate %": st_["win_rate"],
                         "Profit Factor": st_["profit_factor"],
                         "Expectancy": st_["expectancy"], "Max DD": st_["max_drawdown"]})
        st.dataframe(pd.DataFrame(rows).sort_values("Net P&L", ascending=False),
                     use_container_width=True, hide_index=True)
        sel = st.selectbox("Algo detail", algo_u, key="ftp_algo_sel")
        if sel:
            sub = df[df["comment"] == sel]
            _render_analysis(sub, calc_stats(sub, deposit=deposit), deposit, key_prefix=f"ftp_algo_{sel}")

    elif mode == "By Day of Week":
        _render_dow(df)
        _render_hour(df)


# ── Analysis helpers ───────────────────────────────────────────────────────────

def _render_analysis(df, stats, deposit, key_prefix="ftp"):
    """Stats cards + equity + drawdown + daily P&L + DOW + hour + monthly."""
    _render_stats(stats)
    _render_equity(df, key_prefix)
    col1, col2 = st.columns(2)
    with col1:
        _render_dow(df, key_prefix)
    with col2:
        _render_hour(df, key_prefix)
    st.divider()
    _render_monthly(df, deposit, key_prefix)


def _render_stats(stats):
    c1,c2,c3,c4,c5 = st.columns(5)
    c1.metric("Net Profit",    f"${stats['net_profit']:,.2f}")
    c2.metric("Win Rate",      f"{stats['win_rate']}%")
    c3.metric("Profit Factor", f"{stats['profit_factor']}")
    c4.metric("R:R Ratio",     f"{stats['rr_ratio']}")
    c5.metric("Expectancy",    f"${stats['expectancy']:,.2f}")

    c1,c2,c3,c4,c5 = st.columns(5)
    c1.metric("Total Trades",  stats['total_trades'])
    c2.metric("Avg Win",       f"${stats['avg_win']:,.2f}")
    c3.metric("Avg Loss",      f"${stats['avg_loss']:,.2f}")
    _dd_abs = stats['max_drawdown']
    _dd_pct = stats.get('max_drawdown_pct', 0)
    c4.metric("Max DD", f"${_dd_abs:,.2f} ({abs(_dd_pct):.2f}%)")
    c5.metric("Best Trade",    f"${stats['best_trade']:,.2f}")

    c1,c2,c3,c4,c5 = st.columns(5)
    c1.metric("Max Consec W",  stats['max_consec_wins'])
    c2.metric("Max Consec L",  stats['max_consec_losses'])
    c3.metric("Trading Days",  stats.get('trading_days', 0))
    c4.metric("Trades/Day",    stats.get('trades_per_day', 0))
    c5.metric("Worst Trade",   f"${stats['worst_trade']:,.2f}")

    c1,c2,c3,c4 = st.columns(4)
    c1.metric("Long Trades",   stats['long_trades'])
    c2.metric("Long WR",       f"{stats['long_win_rate']}%")
    c3.metric("Short Trades",  stats['short_trades'])
    c4.metric("Short WR",      f"{stats['short_win_rate']}%")


def _render_equity(df, key_prefix):
    df_s = df.sort_values("close_time").copy()
    df_s["_cum"]  = df_s["net_profit"].cumsum()
    df_s["_peak"] = df_s["_cum"].cummax()
    df_s["_dd"]   = df_s["_cum"] - df_s["_peak"]

    # Drawdown unit toggle
    dd_unit = st.radio("Drawdown", ["$", "%"], horizontal=True,
                       key=f"{key_prefix}_dd_unit")
    # Running balance for % dd — use peak equity as denominator
    if dd_unit == "%":
        # % drawdown = dd / peak * 100 (avoid div by zero)
        peak_safe = df_s["_peak"].replace(0, float("nan"))
        dd_vals   = (df_s["_dd"] / peak_safe * 100).fillna(0)
        dd_prefix = ""
        dd_suffix = "%"
    else:
        dd_vals   = df_s["_dd"]
        dd_prefix = "$"
        dd_suffix = ""

    LAYOUT = dict(plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
                  font=dict(family="sans-serif"),
                  margin=dict(l=60,r=20,t=40,b=40),
                  xaxis=dict(gridcolor="rgba(128,128,128,0.15)"),
                  yaxis=dict(gridcolor="rgba(128,128,128,0.15)", tickprefix="$"))

    fig_eq = go.Figure(go.Scatter(
        x=df_s["close_time"], y=df_s["_cum"], mode="lines", name="Equity",
        line=dict(color="#7c6af7", width=2, shape="spline", smoothing=0.6),
        fill="tozeroy", fillcolor="rgba(124,106,247,0.08)"))
    fig_eq.update_layout(height=300, title="Equity Curve",
                         hovermode="x unified", **LAYOUT)
    st.plotly_chart(fig_eq, use_container_width=True, key=f"{key_prefix}_eq")

    st.markdown("**Drawdown**")
    fig_dd = go.Figure(go.Scatter(
        x=df_s["close_time"], y=dd_vals, mode="lines",
        fill="tozeroy",
        line=dict(color="rgba(220,80,80,0.8)", width=1.5,
                  shape="spline", smoothing=0.6),
        fillcolor="rgba(220,80,80,0.15)",
        hovertemplate=f"%{{x}}<br>DD: {dd_prefix}%{{y:.2f}}{dd_suffix}<extra></extra>"))
    fig_dd.update_layout(height=130, showlegend=False,
                         xaxis=dict(gridcolor="rgba(128,128,128,0.15)",
                                    showticklabels=False),
                         yaxis=dict(gridcolor="rgba(128,128,128,0.15)",
                                    tickprefix=dd_prefix,
                                    ticksuffix=dd_suffix),
                         plot_bgcolor="rgba(0,0,0,0)",
                         paper_bgcolor="rgba(0,0,0,0)",
                         font=dict(family="sans-serif"),
                         margin=dict(l=60,r=20,t=8,b=4))
    st.plotly_chart(fig_dd, use_container_width=True, key=f"{key_prefix}_dd")

    st.markdown("**Daily P&L**")
    daily = df_s.groupby(df_s["close_time"].dt.date)["net_profit"].sum().reset_index()
    daily.columns = ["date","pnl"]
    fig_d = go.Figure(go.Bar(
        x=[str(d) for d in daily["date"]], y=daily["pnl"].round(2).tolist(),
        marker_color=["rgba(52,194,122,0.85)" if v>=0
                      else "rgba(220,80,80,0.85)" for v in daily["pnl"]]))
    fig_d.update_layout(height=160, showlegend=False,
                        xaxis=dict(type="category",
                                   gridcolor="rgba(128,128,128,0.15)",
                                   showticklabels=False),
                        yaxis=dict(gridcolor="rgba(128,128,128,0.15)",
                                   tickprefix="$", zeroline=True,
                                   zerolinecolor="rgba(128,128,128,0.3)"),
                        plot_bgcolor="rgba(0,0,0,0)",
                        paper_bgcolor="rgba(0,0,0,0)",
                        font=dict(family="sans-serif"),
                        margin=dict(l=60,r=20,t=4,b=40))
    st.plotly_chart(fig_d, use_container_width=True, key=f"{key_prefix}_daily")


def _render_dow(df, key_prefix="ftp_dow"):
    dow_order = ["Monday","Tuesday","Wednesday","Thursday","Friday"]
    present   = [d for d in dow_order if d in df["day_of_week"].values]
    wins_dow  = df[df["win"]].groupby("day_of_week")["net_profit"].sum().reindex(present, fill_value=0)
    losses_dow= df[~df["win"]].groupby("day_of_week")["net_profit"].sum().reindex(present, fill_value=0)
    fig = go.Figure()
    fig.add_trace(go.Bar(x=present, y=wins_dow.values,   name="Profit",
                         marker_color="rgba(52,194,122,0.85)"))
    fig.add_trace(go.Bar(x=present, y=losses_dow.values, name="Loss",
                         marker_color="rgba(220,80,80,0.85)"))
    fig.update_layout(height=260, title="P&L by Day of Week", barmode="relative",
                      plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
                      font=dict(family="sans-serif"),
                      xaxis=dict(type="category",
                                 gridcolor="rgba(128,128,128,0.15)"),
                      yaxis=dict(gridcolor="rgba(128,128,128,0.15)",
                                 tickprefix="$"),
                      legend=dict(bgcolor="rgba(0,0,0,0)"),
                      margin=dict(l=60,r=20,t=40,b=40))

    st.plotly_chart(fig, use_container_width=True, key=f"{key_prefix}_dow")


def _render_hour(df, key_prefix="ftp_hour"):
    all_hours = sorted(df["hour"].dropna().unique())
    str_hours = [str(int(h)) for h in all_hours]
    wins_h    = df[df["win"]].groupby("hour")["net_profit"].sum().reindex(all_hours, fill_value=0)
    losses_h  = df[~df["win"]].groupby("hour")["net_profit"].sum().reindex(all_hours, fill_value=0)
    fig = go.Figure()
    fig.add_trace(go.Bar(x=str_hours, y=wins_h.values,   name="Profit",
                         marker_color="rgba(52,194,122,0.85)"))
    fig.add_trace(go.Bar(x=str_hours, y=losses_h.values, name="Loss",
                         marker_color="rgba(220,80,80,0.85)"))
    fig.update_layout(height=260, title="P&L by Hour of Day", barmode="relative",
                      plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
                      font=dict(family="sans-serif"),
                      xaxis=dict(type="category", title="Hour (UTC)",
                                 gridcolor="rgba(128,128,128,0.15)"),
                      yaxis=dict(gridcolor="rgba(128,128,128,0.15)",
                                 tickprefix="$"),
                      legend=dict(bgcolor="rgba(0,0,0,0)"),
                      margin=dict(l=60,r=20,t=40,b=40))
    st.plotly_chart(fig, use_container_width=True, key=f"{key_prefix}_hour")


def _render_monthly(df, deposit, key_prefix):
    tmp = df[["close_time","net_profit"]].dropna().copy()
    tmp["close_time"] = pd.to_datetime(tmp["close_time"], errors="coerce")
    tmp["year"]  = tmp["close_time"].dt.year
    tmp["month"] = tmp["close_time"].dt.month
    monthly = tmp.groupby(["year","month"])["net_profit"].sum().reset_index()
    if monthly.empty:
        return
    pivot = monthly.pivot(index="year", columns="month",
                          values="net_profit").fillna(0)
    pivot.columns = [pd.Timestamp(2000,int(m),1).strftime("%b") for m in pivot.columns]
    pivot["YTD"]  = pivot.sum(axis=1)
    pivot = pivot.sort_index(ascending=False)
    month_order = ["Jan","Feb","Mar","Apr","May","Jun",
                   "Jul","Aug","Sep","Oct","Nov","Dec","YTD"]
    cols = [c for c in month_order if c in pivot.columns]

    c1, c2 = st.columns([1, 5])
    toggle = c1.radio("", ["$", "%"], horizontal=True, key=f"{key_prefix}_mt_toggle", label_visibility="collapsed")

    def _cell(v):
        pv  = round(v / deposit * 100, 2) if toggle == "%" else v
        bg  = "rgba(52,194,122,0.18)" if pv>0 else ("rgba(220,80,80,0.18)" if pv<0 else "transparent")
        fg  = "#34C27A" if pv>0 else ("#E05555" if pv<0 else "#888")
        txt = (f"{pv:+.2f}%" if pv!=0 else "—") if toggle=="%" else (f"{pv:+.2f}" if pv!=0 else "—")
        return f'<td style="background:{bg};color:{fg};padding:5px 10px;text-align:right;font-size:12px;font-family:monospace;border-bottom:1px solid rgba(128,128,128,0.1)">{txt}</td>'

    rows_html = ""
    for year, row in pivot[cols].iterrows():
        cells = f'<td style="padding:5px 10px;font-size:12px;font-weight:600;border-bottom:1px solid rgba(128,128,128,0.1)">{year}</td>'
        for col in cols:
            cells += _cell(row.get(col, 0))
        rows_html += f"<tr>{cells}</tr>"

    hdr = '<tr><th style="padding:5px 10px;font-size:11px;color:#888;text-align:right;border-bottom:1px solid rgba(128,128,128,0.2)">Year</th>'
    hdr += "".join(f'<th style="padding:5px 10px;font-size:11px;color:#888;text-align:right;border-bottom:1px solid rgba(128,128,128,0.2)">{c}</th>' for c in cols)
    hdr += "</tr>"

    st.markdown(
        f'<div style="overflow-x:auto"><table style="width:100%;border-collapse:collapse">'
        f'<thead>{hdr}</thead><tbody>{rows_html}</tbody></table></div>',
        unsafe_allow_html=True)


# ── Calendar grid renderers ────────────────────────────────────────────────────

def _cell_html(day_num: int, row, is_today: bool, unit: str, balance: float) -> str:
    if row is not None:
        val  = row["pnl_pct"] if unit == "%" else row["pnl_dollar"]
        pos  = val >= 0
        bg   = "rgba(52,194,122,0.15)" if pos else "rgba(220,80,80,0.15)"
        vc   = "#34C27A" if pos else "#E05555"
        sign = "+" if pos else ""
        disp = f"{sign}{val:.2f}%" if unit=="%" else f"${val:,.2f}"
        alt  = f"${row['pnl_dollar']:,.2f}" if unit=="%" else f"{row['pnl_pct']:+.2f}%"
        tr   = int(row["trades"])
        content = (
            f'<div style="font-size:14px;font-weight:700;color:{vc}">'
            f'{disp} <span style="font-size:10px;font-weight:400;opacity:0.7">({alt})</span></div>'
            f'<div style="font-size:12px;color:#aaa;margin-top:3px">{tr} trade{"s" if tr!=1 else ""}</div>'
            f'<div style="font-size:12px;color:#888">✅{int(row["wins"])} ❌{int(row["losses"])}</div>'
        )
    else:
        bg = "rgba(255,255,255,0.02)"
        content = '<div style="color:#333;font-size:11px">—</div>'

    border = "border:2px solid rgba(124,106,247,0.6);" if is_today \
             else "border:1px solid rgba(255,255,255,0.06);"
    return (
        f'<td style="padding:3px;vertical-align:top">'
        f'<div style="background:{bg};border-radius:6px;{border}'
        f'padding:6px 8px;min-height:80px;min-width:90px">'
        f'<div style="font-size:13px;color:#A0A8B8;margin-bottom:3px">{day_num}</div>'
        f'{content}</div></td>'
    )


def _table_wrap(hdr: str, body: str) -> str:
    return (
        '<div style="overflow-x:auto">'
        '<table style="width:100%;border-collapse:separate;border-spacing:0">'
        f'<thead><tr>{hdr}</tr></thead><tbody>{body}</tbody></table></div>'
    )


def _dow_header() -> str:
    days_hdr = "".join(
        f'<th style="text-align:center;padding:6px 0;font-size:11px;'
        f'color:#888;font-weight:500">{d}</th>'
        for d in ["Mon","Tue","Wed","Thu","Fri"]
    )
    week_hdr = '<th style="text-align:center;padding:6px 8px;font-size:11px;color:#888;font-weight:500;border-left:1px solid rgba(128,128,128,0.15)">Weekly Total</th>'
    return days_hdr + week_hdr


def _render_month_grid(year, month, day_map, today, unit, balance):
    cal  = calendar.monthcalendar(year, month)
    body = ""
    for week in cal:
        row_html = ""
        # Mon-Fri only (indices 0-4), skip Sat(5) Sun(6)
        for dow in range(5):
            day_num = week[dow]
            if day_num == 0:
                row_html += '<td style="padding:3px"></td>'
            else:
                d = date(year, month, day_num)
                row_html += _cell_html(day_num, day_map.get(d), d==today, unit, balance)

        # Weekly summary cell
        week_days = [date(year, month, week[i]) for i in range(5) if week[i] != 0]
        if week_days:
            week_rows = [day_map[d] for d in week_days if d in day_map]
            if week_rows:
                w_pnl_d = sum(r["pnl_dollar"] for r in week_rows)
                w_pnl_p = sum(r["pnl_pct"]    for r in week_rows)
                w_tr    = sum(int(r["trades"])  for r in week_rows)
                w_wins  = sum(int(r["wins"])    for r in week_rows)
                w_loss  = sum(int(r["losses"])  for r in week_rows)
                pos     = (w_pnl_d if unit == "$" else w_pnl_p) >= 0
                bg      = "rgba(52,194,122,0.12)" if pos else "rgba(220,80,80,0.12)"
                vc      = "#34C27A" if pos else "#E05555"
                disp    = f"${w_pnl_d:,.2f}" if unit == "$" else f"{w_pnl_p:+.2f}%"
                alt     = f"{w_pnl_p:+.2f}%" if unit == "$" else f"${w_pnl_d:,.2f}"
                week_cell = (
                    f'<td style="padding:3px;vertical-align:top;border-left:1px solid rgba(128,128,128,0.15)">'
                    f'<div style="background:{bg};border-radius:6px;border:1px solid rgba(255,255,255,0.06);'
                    f'padding:6px 8px;min-height:80px;min-width:80px">'
                    f'<div style="font-size:10px;color:#777;margin-bottom:3px;font-weight:500;text-transform:uppercase;letter-spacing:0.03em">Weekly</div>'
                    f'<div style="font-size:13px;font-weight:700;color:{vc}">{disp}</div>'
                    f'<div style="font-size:10px;color:{vc};opacity:0.7">({alt})</div>'
                    f'<div style="font-size:11px;color:#aaa;margin-top:3px">{w_tr} trades</div>'
                    f'<div style="font-size:11px;color:#888">✅{w_wins} ❌{w_loss}</div>'
                    f'</div></td>'
                )
            else:
                week_cell = '<td style="padding:3px;border-left:1px solid rgba(128,128,128,0.15)"><div style="min-height:80px"></div></td>'
        else:
            week_cell = '<td style="padding:3px;border-left:1px solid rgba(128,128,128,0.15)"></td>'

        body += f"<tr>{row_html}{week_cell}</tr>"
    st.markdown(_table_wrap(_dow_header(), body), unsafe_allow_html=True)


def _render_week_grid(year, week_num, day_map, today, unit, balance):
    # Get the Monday of the given ISO week
    jan4 = date(year, 1, 4)
    week_start = jan4 + timedelta(weeks=week_num - jan4.isocalendar()[1],
                                   days=-jan4.weekday())
    days = [week_start + timedelta(days=i) for i in range(5)]  # Mon-Fri only
    cells = ""
    for d in days:
        cells += _cell_html(d.day, day_map.get(d), d==today, unit, balance)
    date_hdr = "".join(
        f'<th style="text-align:center;padding:6px 4px;font-size:11px;color:#888">'
        f'{["Mon","Tue","Wed","Thu","Fri"][i]}<br>'
        f'<span style="color:#A0A8B8">{days[i].strftime("%d %b")}</span></th>'
        for i in range(5)
    )
    body = f"<tr>{cells}</tr>"
    st.markdown(_table_wrap(date_hdr, body), unsafe_allow_html=True)


def _render_year_grid(year, day_map, today, unit, balance):
    """Year view — one row per month, columns = ISO weeks or just month summary."""
    month_order = list(range(1, 13))
    hdr = '<th style="padding:5px 10px;font-size:11px;color:#888;text-align:left">Month</th>'
    hdr += '<th style="padding:5px 10px;font-size:11px;color:#888;text-align:right">P&L</th>'
    hdr += '<th style="padding:5px 10px;font-size:11px;color:#888;text-align:right">Trades</th>'
    hdr += '<th style="padding:5px 10px;font-size:11px;color:#888;text-align:right">Win Rate</th>'
    hdr += '<th style="padding:5px 10px;font-size:11px;color:#888;text-align:right">Trading Days</th>'

    body = ""
    for m in month_order:
        days_in_month = [d for d in day_map if d.year==year and d.month==m]
        if not days_in_month:
            continue
        rows   = [day_map[d] for d in days_in_month]
        pnl    = sum(r["pnl_dollar"] for r in rows)
        pct    = sum(r["pnl_pct"] for r in rows)
        trades = sum(int(r["trades"]) for r in rows)
        wins   = sum(int(r["wins"]) for r in rows)
        wr     = round(wins/trades*100,1) if trades else 0
        td     = len(days_in_month)

        val  = pct if unit=="%" else pnl
        pos  = val >= 0
        bg   = "rgba(52,194,122,0.12)" if pos else "rgba(220,80,80,0.12)"
        fg   = "#34C27A" if pos else "#E05555"
        disp = f"{val:+.2f}%" if unit=="%" else f"${val:,.2f}"

        body += (
            f'<tr style="border-bottom:1px solid rgba(128,128,128,0.08)">'
            f'<td style="padding:6px 10px;font-size:12px;font-weight:600">'
            f'{calendar.month_name[m]}</td>'
            f'<td style="padding:6px 10px;text-align:right;background:{bg};'
            f'color:{fg};font-family:monospace;font-size:12px">{disp}</td>'
            f'<td style="padding:6px 10px;text-align:right;font-size:12px">{trades}</td>'
            f'<td style="padding:6px 10px;text-align:right;font-size:12px">{wr}%</td>'
            f'<td style="padding:6px 10px;text-align:right;font-size:12px">{td}</td>'
            f'</tr>'
        )

    st.markdown(
        f'<div style="overflow-x:auto">'
        f'<table style="width:100%;border-collapse:collapse">'
        f'<thead><tr>{hdr}</tr></thead><tbody>{body}</tbody></table></div>',
        unsafe_allow_html=True)