"""Zion PM control CLI. Pure local state ops (no model calls) - safe to spam.

Usage:

  pm add "<task>" [--project P] [--type code|research|outreach|browser|ops|misc]

  pm ls [--all]

  pm show <id>

  pm approvals

  pm approve <id> | pm reject <id> [--reason "..."]

  pm status

  pm activity [N]

  pm tick

  pm start | pm stop

"""

import json, os, sys, time, subprocess, argparse, uuid

PM = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

ST = os.path.join(PM, "state")

INBOX = os.path.join(PM, "inbox")

def _load(p, default):

    try:

        with open(p) as f: return json.load(f)

    except Exception: return default

def _save(p, obj):

    tmp = p + ".tmp"

    with open(tmp, "w") as f: json.dump(obj, f, indent=2)

    os.replace(tmp, p)

def _ts(): return time.strftime("%Y-%m-%dT%H:%M:%S")

def _log(event, **kw):

    line = {"ts": _ts(), "event": event, **kw}

    with open(os.path.join(ST, "activity.jsonl"), "a") as f:

        f.write(json.dumps(line) + "\n")

def cmd_add(a):

    t = _load(os.path.join(ST, "tasks.json"), {"tasks": []})

    tid = "t-" + uuid.uuid4().hex[:8]

    task = {"id": tid, "title": a.task, "project": a.project, "type": a.type,

            "status": "open", "created": _ts(), "artifacts": [], "worker": None}

    t["tasks"].append(task)

    _save(os.path.join(ST, "tasks.json"), t)

    with open(os.path.join(INBOX, tid + ".task"), "w") as f:

        f.write(a.task + "\n")

    _log("task_added", id=tid, title=a.task)

    print(f"added {tid}: {a.task}")

def cmd_ls(a):

    t = _load(os.path.join(ST, "tasks.json"), {"tasks": []})

    for x in t["tasks"]:

        if a.all or x["status"] not in ("done", "cancelled"):

            print(f"{x['id']}  [{x['status']:>10}]  {x.get('project') or '-':<14} {x['title']}")

def cmd_show(a):

    t = _load(os.path.join(ST, "tasks.json"), {"tasks": []})

    for x in t["tasks"]:

        if x["id"] == a.id: print(json.dumps(x, indent=2)); return

    print("not found", file=sys.stderr); sys.exit(1)

def cmd_approvals(a):

    o = _load(os.path.join(ST, "outbox.json"), {"pending": [], "history": []})

    if not o["pending"]: print("no pending approvals"); return

    for p in o["pending"]:

        print(f"--- {p['id']}  ({p['kind']})  task={p.get('task')}")

        print(f"    {p.get('preview','')}")

def _move_outbox(oid, decision, reason):

    o = _load(os.path.join(ST, "outbox.json"), {"pending": [], "history": []})

    keep, hit = [], None

    for p in o["pending"]:

        (hit := p) if p["id"] == oid else keep.append(p)

    if not hit: print("not found", file=sys.stderr); sys.exit(1)

    hit["decision"] = decision; hit["decided_at"] = _ts(); hit["reason"] = reason

    o["pending"] = keep; o["history"].append(hit)

    _save(os.path.join(ST, "outbox.json"), o)

    _log("outbox_" + decision, id=oid, kind=hit["kind"])

    return hit

def cmd_approve(a):

    hit = _move_outbox(a.id, "approved", a.reason)

    print(f"approved {a.id}. run `pm flush` (or the conductor will) to execute.")

def cmd_reject(a):

    _move_outbox(a.id, "rejected", a.reason); print(f"rejected {a.id}")

def cmd_flush(a):

    subprocess.run(["bash", os.path.join(PM, "bin", "flush-outbox.sh")])

def cmd_status(a):

    c = _load(os.path.join(ST, "conductor_state.json"), {})

    print(json.dumps(c, indent=2))

    wdir = os.path.join(PM, "workers")

    running = [d for d in os.listdir(wdir) if os.path.isdir(os.path.join(wdir, d))

               and not os.path.exists(os.path.join(wdir, d, "result.json"))] if os.path.isdir(wdir) else []

    print("running workers:", running or "none")

def cmd_activity(a):

    p = os.path.join(ST, "activity.jsonl")

    if not os.path.exists(p): print("(no activity)"); return

    lines = open(p).read().splitlines()[-a.n:]

    for l in lines: print(l)

def cmd_tick(a):

    subprocess.run(["bash", os.path.join(PM, "bin", "conductor.sh"), "--once"])

def cmd_start(a):

    subprocess.run(["bash", os.path.join(PM, "bin", "conductor.sh"), "--daemon"])

def cmd_stop(a):

    subprocess.run(["tmux", "kill-session", "-t", "zion-pm"])

    print("stopped zion-pm loop")

def main():

    ap = argparse.ArgumentParser(prog="pm")

    sub = ap.add_subparsers(dest="cmd", required=True)

    s = sub.add_parser("add"); s.add_argument("task"); s.add_argument("--project", default=None)

    s.add_argument("--type", default="misc"); s.set_defaults(fn=cmd_add)

    s = sub.add_parser("ls"); s.add_argument("--all", action="store_true"); s.set_defaults(fn=cmd_ls)

    s = sub.add_parser("show"); s.add_argument("id"); s.set_defaults(fn=cmd_show)

    s = sub.add_parser("approvals"); s.set_defaults(fn=cmd_approvals)

    s = sub.add_parser("approve"); s.add_argument("id"); s.add_argument("--reason", default=""); s.set_defaults(fn=cmd_approve)

    s = sub.add_parser("reject"); s.add_argument("id"); s.add_argument("--reason", default=""); s.set_defaults(fn=cmd_reject)

    s = sub.add_parser("flush"); s.set_defaults(fn=cmd_flush)

    s = sub.add_parser("status"); s.set_defaults(fn=cmd_status)

    s = sub.add_parser("activity"); s.add_argument("n", nargs="?", type=int, default=20); s.set_defaults(fn=cmd_activity)

    s = sub.add_parser("tick"); s.set_defaults(fn=cmd_tick)

    s = sub.add_parser("start"); s.set_defaults(fn=cmd_start)

    s = sub.add_parser("stop"); s.set_defaults(fn=cmd_stop)

    a = ap.parse_args(); a.fn(a)

if __name__ == "__main__":

    main()