#!/usr/bin/env python3
"""ProfitProphet / Wisdom — desktop market-data uploader.

WoW addons can't reach the network, so the ProfitProphet addon writes its scans to a
SavedVariables Lua file on disk. This tool reads that file and uploads the latest realm/faction
price snapshot to the Wisdom `ingest` Edge Function, tied to your account via an upload key.

Zero third-party dependencies — standard library only (incl. tkinter for the setup window), so
it runs anywhere Python 3.8+ does, offline, and packages into a single .exe with PyInstaller.

Double-click (or run with no arguments) → a small setup window. Or use the CLI:
    pp_upload setup --token ppw_xxx --region US [--sv PATH] [--endpoint URL]
    pp_upload run                 # one upload, using saved config
    pp_upload watch [--every 30]  # upload every N minutes (foreground loop)
    pp_upload install [--every 30]# set up background auto-sync at login + start it
    pp_upload uninstall           # remove the background auto-sync
Config is saved to ~/.ppwisdom/config.json. The upload token is your only secret — treat it
like a password; revoke/rotate it at wowprofitprophet.com/account.html.
"""
from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
import time
import urllib.error
import urllib.request

DEFAULT_ENDPOINT = "https://kfjgazidjwrziotygcbw.supabase.co/functions/v1/ingest"
APP_NAME = "PPWisdomUploader"
CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".ppwisdom")
CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")

# --------------------------------------------------------------------------- #
# Config
# --------------------------------------------------------------------------- #

def load_config() -> dict:
    try:
        with open(CONFIG_PATH, "r", encoding="utf-8") as fh:
            return json.load(fh)
    except (OSError, ValueError):
        return {}


def save_config(cfg: dict) -> None:
    os.makedirs(CONFIG_DIR, exist_ok=True)
    with open(CONFIG_PATH, "w", encoding="utf-8") as fh:
        json.dump(cfg, fh, indent=2)
    try:
        os.chmod(CONFIG_PATH, 0o600)  # token lives here; keep it user-only where supported
    except OSError:
        pass


# --------------------------------------------------------------------------- #
# Minimal Lua-table parser for the WoW SavedVariables subset (no deps).
# --------------------------------------------------------------------------- #

class _LuaParser:
    def __init__(self, text: str):
        self.s = text
        self.i = 0
        self.n = len(text)

    def parse_assignment(self, name: str):
        idx = self.s.find(name)
        while idx != -1:
            before = self.s[:idx].rstrip()
            if before == "" or before[-1] in "\n;":
                self.i = idx + len(name)
                self._ws()
                if self._peek() == "=":
                    self.i += 1
                    self._ws()
                    return self._value()
            idx = self.s.find(name, idx + 1)
        raise ValueError(f"{name} not found in SavedVariables")

    def _peek(self):
        return self.s[self.i] if self.i < self.n else ""

    def _ws(self):
        while self.i < self.n:
            c = self.s[self.i]
            if c in " \t\r\n":
                self.i += 1
            elif c == "-" and self.s[self.i:self.i + 2] == "--":
                nl = self.s.find("\n", self.i)
                self.i = self.n if nl == -1 else nl + 1
            else:
                break

    def _value(self):
        self._ws()
        c = self._peek()
        if c == "{":
            return self._table()
        if c in "\"'":
            return self._string()
        if c == "[" and self.s[self.i:self.i + 2] == "[[":
            return self._long_string()
        return self._scalar()

    def _table(self):
        self.i += 1
        result, arr = {}, []
        while True:
            self._ws()
            c = self._peek()
            if c == "":
                raise ValueError("unterminated table")
            if c == "}":
                self.i += 1
                break
            if c in ",;":
                self.i += 1
                continue
            if c == "[":
                self.i += 1
                self._ws()
                key = self._string() if self._peek() in "\"'" else self._scalar()
                self._ws()
                if self._peek() == "]":
                    self.i += 1
                self._ws()
                if self._peek() == "=":
                    self.i += 1
                    result[key] = self._value()
                continue
            j = self.i
            while j < self.n and (self.s[j].isalnum() or self.s[j] == "_"):
                j += 1
            k = j
            while k < self.n and self.s[k] in " \t":
                k += 1
            if j > self.i and k < self.n and self.s[k] == "=" and self.s[k + 1:k + 2] != "=":
                key = self.s[self.i:j]
                self.i = k + 1
                result[key] = self._value()
            else:
                arr.append(self._value())
        if arr and not result:
            return arr
        if arr:
            for idx, v in enumerate(arr, 1):
                result.setdefault(idx, v)
        return result

    def _string(self):
        quote = self._peek()
        self.i += 1
        out = []
        while self.i < self.n:
            c = self.s[self.i]
            if c == "\\":
                nxt = self.s[self.i + 1:self.i + 2]
                out.append({"n": "\n", "t": "\t", "r": "\r"}.get(nxt, nxt))
                self.i += 2
                continue
            if c == quote:
                self.i += 1
                break
            out.append(c)
            self.i += 1
        return "".join(out)

    def _long_string(self):
        self.i += 2
        end = self.s.find("]]", self.i)
        end = self.n if end == -1 else end
        val = self.s[self.i:end]
        self.i = end + 2
        return val

    def _scalar(self):
        start = self.i
        while self.i < self.n and self.s[self.i] not in ",;}=] \t\r\n":
            self.i += 1
        tok = self.s[start:self.i]
        if tok == "true":
            return True
        if tok == "false":
            return False
        if tok == "nil":
            return None
        try:
            return int(tok)
        except ValueError:
            try:
                return float(tok)
            except ValueError:
                return tok


def parse_saved_variables(path: str) -> dict:
    with open(path, "r", encoding="utf-8", errors="replace") as fh:
        text = fh.read()
    return _LuaParser(text).parse_assignment("PROFITPROPHET_DB")


# WoW install folder → Wisdom flavor slug. The file's location tells us the game version,
# so the uploader auto-detects it (no user input needed).
FLAVOR_BY_FOLDER = {
    "_retail_": "retail",
    "_anniversary_": "anniversary",
    "_classic_era_": "era",
    "_classic_ptr_": "wrath",
    "_classic_": "wrath",
    "_ptr_": "retail",
}


def detect_flavor(sv_path: str | None) -> str:
    p = (sv_path or "").lower().replace("\\", "/")
    for folder, fl in FLAVOR_BY_FOLDER.items():
        if folder in p:
            return fl
    return "anniversary"


def select_realm_bucket(db: dict) -> tuple[dict, str, str]:
    """Return (bucket, realm, faction) for the realm whose market data we should upload.

    The addon scopes market data per realm (PP_Scope.lua, `scopeV: 2`):
    `D.realms["<Realm>|<Faction>"] = { latest = { items, t }, history, ... }`, with the active
    bucket named by `D.meta.boundRealmKey`. Older SavedVariables kept a single flat `D.latest`
    with realm/faction on `D.meta`. Read the scoped layout first and fall back to the flat one,
    so the uploader works against both.
    """
    realms = db.get("realms")
    meta = db.get("meta") or {}
    if isinstance(realms, dict) and realms:
        key = str(meta.get("boundRealmKey") or "").strip()
        if key not in realms:
            # Not bound (or bound to a stale key) — take the bucket with the most scanned items.
            key = max(
                realms,
                key=lambda k: len((((realms.get(k) or {}).get("latest") or {}).get("items") or {}))
                if isinstance(realms.get(k), dict) else -1,
            )
        bucket = realms.get(key) or {}
        realm, _, faction = str(key).partition("|")
        # A bucket's own label wins over the key when present (the key is an internal id).
        label = bucket.get("label") if isinstance(bucket.get("label"), dict) else {}
        realm = str(label.get("realm") or meta.get("boundRealmName") or realm or "").strip()
        faction = str(label.get("faction") or faction or meta.get("faction") or "").strip()
        return bucket, realm, faction
    # Legacy flat layout.
    return db, str(meta.get("realm") or "").strip(), str(meta.get("faction") or "").strip()


def collect_char_ledger(db: dict, realm: str) -> dict | None:
    """Union sales/buys across this realm's characters (`D.chars["<Name>-<Realm>"]`)."""
    chars = db.get("chars")
    if not isinstance(chars, dict) or not chars:
        return None
    suffix = ("-" + realm).lower()
    sales: list = []
    buys: list = []
    for key, ch in chars.items():
        if not isinstance(ch, dict):
            continue
        if realm and not str(key).lower().endswith(suffix):
            continue  # another realm's character — its ledger belongs to that realm's upload
        if isinstance(ch.get("sales"), list):
            sales.extend(ch["sales"])
        if isinstance(ch.get("buys"), list):
            buys.extend(ch["buys"])
    if not sales and not buys:
        return None
    sales.sort(key=lambda e: e.get("t") or 0 if isinstance(e, dict) else 0)
    buys.sort(key=lambda e: e.get("t") or 0 if isinstance(e, dict) else 0)
    return {"sales": sales, "buys": buys}


def build_payload(db: dict, region: str, token: str, flavor: str = "anniversary") -> dict:
    bucket, realm, faction = select_realm_bucket(db)
    meta = db.get("meta") or {}
    latest = bucket.get("latest") or {}
    items_tbl = latest.get("items") or {}
    if faction not in ("Alliance", "Horde", "Neutral"):
        faction = "Neutral"
    if not realm:
        raise ValueError("SavedVariables has no realm yet — do a scan in-game first")
    if not items_tbl:
        raise ValueError(f"no scanned items for {realm} yet — run a full AH scan in-game first")
    items = []
    for name, entry in items_tbl.items():
        if not isinstance(entry, dict):
            continue
        name = str(name).strip()
        if not name:
            continue  # the addon keeps an unnamed roll-up row; it isn't a real item
        price = entry.get("p")
        if not isinstance(price, (int, float)) or price <= 0:
            continue
        # qty = total units listed. Per ProfitProphet.lua: "q = total units available
        # (Σ stack counts); nl = number of listings". `n` is a scan counter, NOT a quantity —
        # sending it made every item look like depth-1 and broke the liquidity signal.
        qty = entry.get("q")
        if not isinstance(qty, (int, float)) or qty < 0:
            qty = entry.get("nl") if isinstance(entry.get("nl"), (int, float)) else 0
        items.append({"item": name, "price": int(price), "qty": int(qty or 0)})
    # Private ledger (your own sales/buys) — sent to your account only, never crowd-shared.
    def _ledger(entries, fields):
        out = []
        for e in (entries or [])[-1000:]:
            if isinstance(e, dict) and e.get("item") and e.get("t"):
                row = {"t": e.get("t"), "item": str(e.get("item"))}
                for f in fields:
                    row[f] = e.get(f)
                out.append(row)
        return out
    # Ledger is scoped per CHARACTER (D.chars[charKey]), not per realm — see PP_Scope.lua.
    # Union every character on this realm so the web ledger matches the in-game one; fall back
    # to the legacy flat D.sales/D.buys for pre-scoping SavedVariables.
    ledger_src = collect_char_ledger(db, realm) or {"sales": db.get("sales"), "buys": db.get("buys")}
    sales = _ledger(ledger_src.get("sales"), ("gross", "net", "qty"))
    buys = _ledger(ledger_src.get("buys"), ("price", "qty"))

    payload = {
        "token": token,
        "region": region,
        "flavor": flavor,
        "realm": realm,
        "faction": faction,
        "scannedAt": int(latest.get("t") or meta.get("lastScan") or time.time()),
        "items": items,
    }
    if sales or buys:
        payload["ledger"] = {"sales": sales, "buys": buys}
    return payload


def upload(endpoint: str, payload: dict) -> dict:
    body = json.dumps(payload).encode("utf-8")
    req = urllib.request.Request(endpoint, data=body, method="POST",
                                 headers={"Content-Type": "application/json"})
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            return json.loads(resp.read().decode("utf-8"))
    except urllib.error.HTTPError as e:
        raise RuntimeError(f"upload rejected ({e.code}): {e.read().decode('utf-8', 'replace')}")
    except urllib.error.URLError as e:
        raise RuntimeError(f"could not reach the server: {e.reason}")


def default_sv_path() -> str | None:
    candidates = []
    if sys.platform.startswith("win"):
        base = r"C:\Program Files (x86)\World of Warcraft"
        for flavour in ("_classic_era_", "_anniversary_", "_classic_", "_retail_"):
            candidates.append(os.path.join(base, flavour, "WTF", "Account"))
    else:
        home = os.path.expanduser("~")
        for p in (".wine", "Games", "Applications", "Library/Application Support"):
            candidates.append(os.path.join(home, p))
    for root in candidates:
        if not os.path.isdir(root):
            continue
        for dirpath, _dirs, files in os.walk(root):
            if "ProfitProphet.lua" in files and "SavedVariables" in dirpath:
                return os.path.join(dirpath, "ProfitProphet.lua")
    return None


# --------------------------------------------------------------------------- #
# One upload from saved config
# --------------------------------------------------------------------------- #

# Server-side guards in the ingest function (keep these in sync with it):
#   MAX_ITEMS_PER_REQUEST = 5000, MIN_SECONDS_BETWEEN_UPLOADS = 20 per key.
# A full scan on a busy realm exceeds 5000 items, so send it in batches and wait out the
# per-key rate limit between them rather than letting the whole upload 413.
BATCH_ITEMS = 4500
BATCH_PAUSE_SECONDS = 21
# Mirrors `day >= current_date - 8` in the market_board / market_signals RPCs.
BOARD_WINDOW_DAYS = 8


def do_upload(cfg: dict, progress=None) -> str:
    token = cfg.get("token")
    endpoint = cfg.get("endpoint") or DEFAULT_ENDPOINT
    region = cfg.get("region") or "US"
    sv = cfg.get("sv") or default_sv_path()
    if not token:
        raise RuntimeError("no upload key configured — run setup first")
    if not sv or not os.path.isfile(sv):
        raise RuntimeError("could not find ProfitProphet.lua — set the SavedVariables path")
    db = parse_saved_variables(sv)
    payload = build_payload(db, region, token, detect_flavor(sv))
    items = payload["items"]
    if not items:
        return "nothing to upload yet (no priced items in the latest scan)"

    batches = [items[i:i + BATCH_ITEMS] for i in range(0, len(items), BATCH_ITEMS)]
    accepted = dropped = 0
    for n, batch in enumerate(batches, 1):
        body = dict(payload)
        body["items"] = batch
        # The ledger is per-account, not per-item — send it once, with the first batch only.
        if n > 1:
            body.pop("ledger", None)
        if n > 1:
            if progress:
                progress(f"waiting {BATCH_PAUSE_SECONDS}s for the rate limit…")
            time.sleep(BATCH_PAUSE_SECONDS)
        if progress and len(batches) > 1:
            progress(f"uploading batch {n}/{len(batches)} ({len(batch)} items)…")
        result = upload(endpoint, body)
        accepted += int(result.get("accepted") or 0)
        dropped += int(result.get("dropped") or 0)

    where = f"{payload['realm']}-{payload['faction']}"
    extra = f" in {len(batches)} batches" if len(batches) > 1 else ""
    msg = f"uploaded {accepted} items for {where}{extra} (dropped {dropped})"

    # The market board only shows scans from the last BOARD_WINDOW_DAYS, because it reports the
    # market *now*. Data is dated when it was SCANNED, not when it was uploaded (re-dating it
    # would misrepresent stale prices as current), so an old scan uploads fine and then doesn't
    # appear. Say so here — otherwise a first-time contributor sees a success message and an
    # empty board with nothing connecting the two.
    age_days = int((time.time() - payload["scannedAt"]) // 86400)
    if age_days > BOARD_WINDOW_DAYS:
        msg += (f"\n  NOTE: this scan is {age_days} days old, so it won't show on the market board"
                f" (which shows the last {BOARD_WINDOW_DAYS} days). It's stored and counts toward"
                f" price history. Run a fresh AH scan in-game and upload again to populate the board.")
    return msg


def _log(msg: str) -> None:
    """Append to a log file so the (windowless) background sync leaves a trace."""
    line = time.strftime("%Y-%m-%d %H:%M") + " - " + msg
    print(line)
    try:
        os.makedirs(CONFIG_DIR, exist_ok=True)
        with open(os.path.join(CONFIG_DIR, "uploader.log"), "a", encoding="utf-8") as fh:
            fh.write(line + "\n")
    except OSError:
        pass


def watch(cfg: dict, every_min: int) -> None:
    _log(f"auto-sync started — every {every_min} min")
    while True:
        try:
            _log(do_upload(cfg))
        except Exception as e:  # keep the loop alive across transient errors
            _log("skipped: " + str(e))
        time.sleep(max(60, every_min * 60))


# --------------------------------------------------------------------------- #
# Autostart (cross-platform) — launches `watch` in the background at login.
# --------------------------------------------------------------------------- #

def _self_cmd(extra: list[str]) -> list[str]:
    """The command that re-launches this program with the given args."""
    if getattr(sys, "frozen", False):          # packaged .exe / app bundle
        return [sys.executable] + extra
    return [sys.executable, os.path.abspath(__file__)] + extra


def install_autostart(every_min: int) -> str:
    args = ["watch", "--every", str(every_min)]
    if sys.platform.startswith("win"):
        exe = _self_cmd(args)
        cmd = " ".join(f'"{a}"' if " " in a else a for a in exe)
        subprocess.run(["schtasks", "/Create", "/TN", APP_NAME, "/TR", cmd,
                        "/SC", "ONLOGON", "/RL", "LIMITED", "/F"], check=True,
                       capture_output=True, text=True)
        return f'installed Windows scheduled task "{APP_NAME}" (runs at login)'
    elif sys.platform == "darwin":
        plist_dir = os.path.expanduser("~/Library/LaunchAgents")
        os.makedirs(plist_dir, exist_ok=True)
        plist = os.path.join(plist_dir, "com.profitprophet.wisdom.plist")
        progargs = "".join(f"<string>{a}</string>" for a in _self_cmd(args))
        with open(plist, "w", encoding="utf-8") as fh:
            fh.write(f'<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<plist version="1.0"><dict>'
                     f'<key>Label</key><string>com.profitprophet.wisdom</string>'
                     f'<key>ProgramArguments</key><array>{progargs}</array>'
                     f'<key>RunAtLoad</key><true/><key>KeepAlive</key><true/></dict></plist>')
        subprocess.run(["launchctl", "load", plist], capture_output=True, text=True)
        return f"installed macOS LaunchAgent ({plist})"
    else:  # Linux — autostart .desktop launches the continuous watch loop
        ad = os.path.expanduser("~/.config/autostart")
        os.makedirs(ad, exist_ok=True)
        path = os.path.join(ad, "ppwisdom.desktop")
        exec_cmd = " ".join(_self_cmd(args))
        with open(path, "w", encoding="utf-8") as fh:
            fh.write("[Desktop Entry]\nType=Application\nName=ProfitProphet Wisdom Uploader\n"
                     f"Exec={exec_cmd}\nX-GNOME-Autostart-enabled=true\nNoDisplay=true\n")
        return f"installed Linux autostart entry ({path})"


def uninstall_autostart() -> str:
    if sys.platform.startswith("win"):
        subprocess.run(["schtasks", "/Delete", "/TN", APP_NAME, "/F"], capture_output=True, text=True)
        return "removed the Windows scheduled task"
    elif sys.platform == "darwin":
        plist = os.path.expanduser("~/Library/LaunchAgents/com.profitprophet.wisdom.plist")
        subprocess.run(["launchctl", "unload", plist], capture_output=True, text=True)
        try:
            os.remove(plist)
        except OSError:
            pass
        return "removed the macOS LaunchAgent"
    else:
        try:
            os.remove(os.path.expanduser("~/.config/autostart/ppwisdom.desktop"))
        except OSError:
            pass
        return "removed the Linux autostart entry"


# --------------------------------------------------------------------------- #
# Setup GUI (tkinter — stdlib). Shown when double-clicked / run with no args.
# --------------------------------------------------------------------------- #

def run_gui() -> int:
    try:
        import tkinter as tk
        from tkinter import ttk, filedialog, messagebox
    except Exception:
        print("Setup window unavailable on this system. Use the CLI: pp_upload setup --help")
        return 1

    cfg = load_config()
    root = tk.Tk()
    root.title("ProfitProphet Wisdom — Uploader")
    root.geometry("560x360")
    frm = ttk.Frame(root, padding=18)
    frm.pack(fill="both", expand=True)

    ttk.Label(frm, text="Wisdom market-data uploader", font=("Segoe UI", 13, "bold")).pack(anchor="w")
    ttk.Label(frm, text="Get your upload key at wowprofitprophet.com/account.html, paste it below,\n"
                        "then Save & start — it syncs every 30 minutes in the background.",
              foreground="#555").pack(anchor="w", pady=(2, 12))

    def row(label, default=""):
        ttk.Label(frm, text=label).pack(anchor="w")
        var = tk.StringVar(value=default)
        e = ttk.Entry(frm, textvariable=var, width=64)
        e.pack(anchor="w", pady=(0, 8))
        return var, e

    token_var, _ = row("Upload key (ppw_…)", cfg.get("token", ""))
    region_var, _ = row("Region (US / EU / KR / TW)", cfg.get("region", "US"))
    sv_var, sv_entry = row("SavedVariables file (ProfitProphet.lua)",
                           cfg.get("sv") or (default_sv_path() or ""))

    def browse():
        p = filedialog.askopenfilename(title="Select ProfitProphet.lua",
                                       filetypes=[("Lua", "*.lua"), ("All", "*.*")])
        if p:
            sv_var.set(p)
    ttk.Button(frm, text="Browse…", command=browse).pack(anchor="w", pady=(0, 10))

    status = ttk.Label(frm, text="", foreground="#0a7")
    status.pack(anchor="w")

    def save_and_start():
        c = {"token": token_var.get().strip(), "region": region_var.get().strip() or "US",
             "sv": sv_var.get().strip(), "endpoint": cfg.get("endpoint") or DEFAULT_ENDPOINT}
        if not c["token"].startswith("ppw_"):
            messagebox.showerror("Missing key", "Paste your ppw_ upload key from the account page.")
            return
        save_config(c)
        try:
            status.config(text="Uploading… " + do_upload(c))
            root.update()
            status.config(text=install_autostart(30) + " — you're set. Safe to close this window.")
        except Exception as e:
            messagebox.showerror("Problem", str(e))
            status.config(text="Config saved, but the first sync failed — check the key/path.", foreground="#c33")

    btns = ttk.Frame(frm)
    btns.pack(anchor="w", pady=14)
    ttk.Button(btns, text="Save & start auto-sync", command=save_and_start).pack(side="left")
    ttk.Button(btns, text="Stop auto-sync", command=lambda: status.config(text=uninstall_autostart())).pack(side="left", padx=8)
    root.mainloop()
    return 0


# --------------------------------------------------------------------------- #
# CLI
# --------------------------------------------------------------------------- #

def main() -> None:
    if len(sys.argv) == 1:            # double-click / no args → setup window
        sys.exit(run_gui())

    ap = argparse.ArgumentParser(description="ProfitProphet Wisdom uploader")
    sub = ap.add_subparsers(dest="cmd")

    s = sub.add_parser("setup", help="save your upload key + settings")
    s.add_argument("--token", required=True)
    s.add_argument("--region", default="US")
    s.add_argument("--sv", default=None)
    s.add_argument("--endpoint", default=DEFAULT_ENDPOINT)

    sub.add_parser("run", help="one upload using saved config")
    w = sub.add_parser("watch", help="upload every N minutes (foreground)")
    w.add_argument("--every", type=int, default=30)
    i = sub.add_parser("install", help="background auto-sync at login")
    i.add_argument("--every", type=int, default=30)
    sub.add_parser("uninstall", help="remove background auto-sync")
    sub.add_parser("gui", help="open the setup window")

    args = ap.parse_args()
    if args.cmd == "setup":
        cfg = load_config()
        cfg.update({"token": args.token, "region": args.region, "endpoint": args.endpoint})
        if args.sv:
            cfg["sv"] = args.sv
        save_config(cfg)
        print("saved config to", CONFIG_PATH)
    elif args.cmd == "run":
        print(do_upload(load_config()))
    elif args.cmd == "watch":
        watch(load_config(), args.every)
    elif args.cmd == "install":
        cfg = load_config()
        print(do_upload(cfg))
        print(install_autostart(args.every))
    elif args.cmd == "uninstall":
        print(uninstall_autostart())
    elif args.cmd == "gui":
        sys.exit(run_gui())
    else:
        ap.print_help()


if __name__ == "__main__":
    main()