#!/usr/bin/env python3
"""
MTP TradeLocker Auto-Sync
=========================
Pushes your CLOSED TradeLocker trades into your My Trader Pro journal, the same
way the MetaTrader Expert Advisor does.

WHY THIS IS A SCRIPT AND NOT AN EA
    TradeLocker is a browser/mobile platform. It does not run MQL programs, so
    there is nothing to "drag onto a chart". Instead it exposes a REST API, and
    this script is the bridge: it reads your own closed trades and forwards them
    to your journal. It never places, modifies or closes an order.

SETUP (about 3 minutes)
    1. Install Python 3.11+ , then:   pip install requests
    2. Fill in the CONFIG block below.
    3. Run it:                        python MTP-TradeLocker-Sync.py
       Leave it running. It checks every 60 seconds.
       (--once runs a single pass and exits, handy for a cron job.)

YOUR CREDENTIALS
    Your TradeLocker password stays on your machine, in this file. It is sent
    only to TradeLocker's own login endpoint to obtain a session token. My
    Trader Pro never receives it and never asks for it. If you would rather not
    store it in a file, set the environment variables instead:
        TL_EMAIL, TL_PASSWORD, TL_SERVER, MTP_KEY
"""

import os
import sys
import time
import json

try:
    import requests
except ImportError:
    sys.exit("Missing dependency. Run:  pip install requests")

# ----------------------------------------------------------------- CONFIG ---
CONFIG = {
    # From your portal: Signals & Sync -> Auto-Sync -> your key
    "mtp_key":     os.environ.get("MTP_KEY", "PASTE_YOUR_MTP_KEY_HERE"),
    "mtp_ingest":  "https://mytraderpro.com/wp-json/mtp/v1/ingest",

    # Your TradeLocker login (the same three things you type to sign in)
    "tl_email":    os.environ.get("TL_EMAIL", "you@example.com"),
    "tl_password": os.environ.get("TL_PASSWORD", "YOUR_TRADELOCKER_PASSWORD"),
    "tl_server":   os.environ.get("TL_SERVER", "YOUR_SERVER_NAME"),

    # "demo" or "live" — must match where you actually trade
    "tl_env":      os.environ.get("TL_ENV", "demo"),

    # Optional label so you can tell accounts apart inside MTP
    "account_label": "",

    "poll_seconds":  60,
    "lookback_days": 90,
}
# -----------------------------------------------------------------------------

BASE = {
    "demo": "https://demo.tradelocker.com/backend-api",
    "live": "https://live.tradelocker.com/backend-api",
}


def hold():
    """Keep the console open. Double-clicking a .py on Windows opens a window
    that closes the instant the script ends — so an error message flashes past
    unread and the script looks 'broken'. Wait for a keypress instead."""
    try:
        if os.name == "nt":
            print("")
            input("Press Enter to close this window...")
    except Exception:
        pass


def fail(msg):
    print("")
    print("=" * 62)
    print("  MTP TradeLocker Sync — STOPPED")
    print("=" * 62)
    print("  " + msg)
    print("")
    hold()
    sys.exit(1)


def login(cfg):
    """Exchange email/password/server for a JWT."""
    base = BASE.get(cfg["tl_env"])
    if not base:
        fail("tl_env must be 'demo' or 'live'.")
    r = requests.post(base + "/auth/jwt/token", timeout=30, json={
        "email": cfg["tl_email"],
        "password": cfg["tl_password"],
        "server": cfg["tl_server"],
    })
    if r.status_code == 401:
        fail("TradeLocker rejected the login. Check email, password and server name.")
    if not r.ok:
        fail("TradeLocker login failed (HTTP %s): %s" % (r.status_code, r.text[:200]))
    tok = r.json().get("accessToken") or r.json().get("access_token")
    if not tok:
        fail("Login succeeded but no access token came back: %s" % r.text[:200])
    return base, tok


def accounts(base, token):
    r = requests.get(base + "/auth/jwt/all-accounts", timeout=30,
                     headers={"Authorization": "Bearer " + token})
    if not r.ok:
        fail("Could not list accounts (HTTP %s): %s" % (r.status_code, r.text[:200]))
    data = r.json()
    accs = data.get("accounts") if isinstance(data, dict) else data
    if not accs:
        fail("No TradeLocker accounts found on this login.")
    return accs


def orders_history(base, token, acc):
    """Closed orders for one account. Shapes vary by build, so be forgiving."""
    acc_id = acc.get("id") or acc.get("accountId")
    acc_num = acc.get("accNum") or acc.get("accountNumber") or acc.get("accNumber")
    headers = {"Authorization": "Bearer " + token}
    if acc_num is not None:
        headers["accNum"] = str(acc_num)
    url = "%s/trade/accounts/%s/ordersHistory" % (base, acc_id)
    r = requests.get(url, headers=headers, timeout=30)
    if not r.ok:
        print("  ! history request failed (HTTP %s) %s" % (r.status_code, r.text[:160]))
        return []
    body = r.json()
    rows = body.get("d", body) if isinstance(body, dict) else body
    if isinstance(rows, dict):
        rows = rows.get("ordersHistory") or rows.get("orders") or []
    return rows or []


def acct_name(cfg, acc, multi):
    """The ROUTING KEY. The portal binds each of its journal accounts to this
    exact string and files every trade to its bound account automatically — so
    it must be UNIQUE per real account and STABLE across runs.

    Rules:
      * No label set -> "TradeLocker <env> <accNum>". The env is included
        because demo and live are separate universes whose account numbers can
        collide, and a demo trade must never route into a live journal.
      * Label set, ONE account   -> the label, exactly as typed.
      * Label set, MANY accounts -> "<label> <accNum>" — a bare label would
        give every account the same key and silently merge their histories,
        which is the one thing routing exists to prevent.
    """
    accid = str(acc.get("accNum") or acc.get("id") or acc.get("accountId") or "").strip()
    base = (cfg.get("account_label") or "").strip()
    if base:
        return (base + " " + accid).strip() if multi else base
    return ("TradeLocker " + cfg.get("tl_env", "") + " " + accid).strip()


def to_mtp(row, label):
    """Map one TradeLocker order onto the MTP ingest shape. Returns None if the
    row is not a completed, filled trade."""
    def g(*names):
        for n in names:
            if isinstance(row, dict) and row.get(n) not in (None, ""):
                return row[n]
        return None

    status = str(g("status", "state") or "").lower()
    if status and status not in ("filled", "closed", "done", "executed"):
        return None

    side = str(g("side", "direction", "type") or "").lower()
    if side.startswith("b"):
        direction = "buy"
    elif side.startswith("s"):
        direction = "sell"
    else:
        return None

    entry = g("avgPrice", "openPrice", "filledPrice", "price")
    exitp = g("closePrice", "exitPrice", "avgClosePrice")
    lots = g("qty", "quantity", "lots", "volume")
    if entry is None or lots is None:
        return None

    # epoch milliseconds in most builds; normalise to seconds
    def secs(v):
        try:
            v = int(float(v))
        except (TypeError, ValueError):
            return None
        return v // 1000 if v > 10_000_000_000 else v

    opened = secs(g("createdDate", "openTime", "openDate", "timestamp"))
    closed = secs(g("closedDate", "closeTime", "lastModified", "updatedDate")) or opened

    out = {
        "ticket": str(g("id", "orderId", "positionId") or ""),
        "symbol": str(g("symbol", "instrument", "tradableInstrument") or ""),
        "direction": direction,
        "lots": float(lots),
        "entry": float(entry),
        "profit": float(g("profit", "pnl", "netPnl") or 0),
        "account": label,
        "source": "TradeLocker Auto-Sync",
    }
    if exitp is not None:
        out["exit"] = float(exitp)
    for name, key in (("stopLoss", "sl"), ("takeProfit", "tp")):
        v = g(name)
        if v is not None:
            out[key] = float(v)
    # Unambiguous instants so your journal dates trades in YOUR timezone
    if opened:
        out["openUtc"] = opened
    if closed:
        out["closeUtc"] = closed
    if not out["ticket"] or not out["symbol"]:
        return None
    return out


def push(cfg, trades):
    r = requests.post(cfg["mtp_ingest"], timeout=30,
                      json={"key": cfg["mtp_key"], "trades": trades})
    if r.status_code == 401:
        fail("My Trader Pro rejected the key. Generating a new key in the portal "
             "invalidates the old one — copy the current key and paste it above.")
    if not r.ok:
        print("  ! MTP ingest failed (HTTP %s): %s" % (r.status_code, r.text[:160]))
        return 0
    return r.json().get("accepted", 0)


def handshake(cfg):
    r = requests.post(cfg["mtp_ingest"], timeout=30, json={
        "key": cfg["mtp_key"], "ping": True,
        "platform": "TradeLocker", "account": cfg.get("account_label") or "TradeLocker",
    })
    if r.status_code == 401:
        fail("My Trader Pro rejected the key. Copy the CURRENT key from "
             "Signals & Sync — generating a new key kills the previous one.")
    if not r.ok:
        fail("Could not reach My Trader Pro (HTTP %s)." % r.status_code)
    print("Connected to My Trader Pro.")


def run_once(cfg, base, token, accs, seen):
    total = 0
    multi = len(accs) > 1
    for acc in accs:
        label = acct_name(cfg, acc, multi)
        batch = []
        for row in orders_history(base, token, acc):
            t = to_mtp(row, label)
            if t and t["ticket"] not in seen:
                batch.append(t)
        if not batch:
            continue
        accepted = push(cfg, batch[:100])
        # only remember them once the server has actually taken them
        if accepted:
            for t in batch[:100]:
                seen.add(t["ticket"])
            total += accepted
    return total


def main():
    cfg = CONFIG
    if "PASTE_YOUR_MTP_KEY" in cfg["mtp_key"]:
        fail("This file has not been filled in yet.\n\n"
             "  Do NOT double-click this file to edit it — that RUNS it.\n"
             "  Right-click it and choose:  Open with  ->  Notepad\n\n"
             "  Then fill in the CONFIG block near the top:\n"
             "    mtp_key      - portal -> Signals & Sync -> Copy key\n"
             "    tl_email     - your TradeLocker login email\n"
             "    tl_password  - your TradeLocker password\n"
             "    tl_server    - the server name on the TradeLocker sign-in screen\n"
             "    tl_env       - 'demo' or 'live'\n\n"
             "  Save the file, then run it again.")
    for k, hint in (("tl_email", "you@example.com"), ("tl_password", "YOUR_TRADELOCKER_PASSWORD"),
                    ("tl_server", "YOUR_SERVER_NAME")):
        if cfg[k] == hint:
            fail("The CONFIG block still has the placeholder for '%s'.\n\n"
                 "  Right-click this file -> Open with -> Notepad, replace it, save, run again." % k)
    once = "--once" in sys.argv

    handshake(cfg)
    base, token = login(cfg)
    accs = accounts(base, token)
    print("Watching %d TradeLocker account(s). Closed trades sync automatically."
          % len(accs))

    seen = set()
    while True:
        try:
            n = run_once(cfg, base, token, accs, seen)
            if n:
                print("Sent %d closed trade(s) to your journal." % n)
        except requests.RequestException as e:
            print("  ! network problem, will retry: %s" % e)
        except Exception as e:                      # keep the bridge alive
            print("  ! %s" % e)
        if once:
            return
        time.sleep(max(15, int(cfg["poll_seconds"])))
        try:                                        # refresh the token hourly-ish
            base, token = login(cfg)
        except SystemExit:
            raise
        except Exception:
            pass


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nStopped.")
    except Exception as e:                       # never vanish without saying why
        print("")
        print("Unexpected error: %s" % e)
        hold()
        raise
    else:
        hold()