"""Connect your own Codex or Claude Code to a GidPro project (Python 3.9+)."""
import argparse
import json
import os
import re
import shutil
import subprocess
import sys
import tempfile
import threading
import time
import webbrowser
from pathlib import Path
from urllib.error import HTTPError
from urllib.request import HTTPRedirectHandler, Request, build_opener

ORIGIN = "https://ontwikkel.gid.pro"
APP_DIR = Path(os.environ.get("LOCALAPPDATA", Path.home() / ".local" / "share")) / "GidPro-koppelingen"
APPS = {"codex": "OpenAI Codex", "claude": "Claude Code"}

def project_id(value):
    if not isinstance(value, str) or not re.fullmatch(r"[a-z0-9][a-z0-9-]{0,79}", value):
        raise ValueError("Het projectnummer is ongeldig. Start een nieuwe koppeling.")
    return value


def profile_path(app, project=None):
    if app not in APPS:
        raise ValueError("Deze app is niet beschikbaar.")
    # No project argument identifies an existing registration made by the first helper.
    return APP_DIR / (app + ("-project-" + project_id(project) if project is not None else "") + ".json")


class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self, *args):
        return None


def call(path, data=None, token=None, extra=None):
    headers = {"Accept": "application/json, text/event-stream"}
    if token:
        headers["Authorization"] = "Bearer " + token
    if extra:
        headers.update(extra)
    if data is not None:
        headers["Content-Type"] = "application/json"
    req = Request(ORIGIN + "/api/team/" + path, headers=headers,
                  data=None if data is None else json.dumps(data).encode())
    try:
        response = build_opener(NoRedirect()).open(req, timeout=20)
    except HTTPError as exc:
        response = exc
    with response:
        raw = response.read(1_000_001)
        if len(raw) > 1_000_000:
            raise ValueError("Het antwoord is te groot.")
        try:
            return response.status, json.loads(raw) if raw else None
        except (ValueError, UnicodeError):
            raise ValueError("Het portaal gaf geen leesbaar antwoord.") from None


def save(app, data):
    path = profile_path(app, project_id(data.get("project")))
    APP_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile(mode="w", dir=APP_DIR, delete=False, encoding="utf-8") as tmp:
        json.dump(data, tmp)
    try:
        os.replace(tmp.name, path)
    finally:
        Path(tmp.name).unlink(missing_ok=True)


def pair(app, scope, announce):
    status, ticket = call("pair/start", {"name": APPS[app], "scope": scope})
    if status != 201:
        raise ValueError("De server kon geen code maken. Probeer later opnieuw.")
    url = ORIGIN + "/beheer/koppelen/"
    code = ticket["user_code"]
    announce("Open " + url + "\nCode op dit apparaat: " + code)
    webbrowser.open(url + "#code=" + code)
    deadline, delay = time.monotonic() + ticket["expires_in"], ticket["interval"]
    while time.monotonic() < deadline:
        time.sleep(delay)
        status, result = call("pair/token", {"device_code": ticket["device_code"]})
        if status == 200:
            save(app, {"token": result["access_token"], "project": result["project"]})
            return result["project"]
        error = result.get("error") if isinstance(result, dict) else None
        if error == "slow_down":
            delay = max(delay + 5, result.get("interval", 5))
        elif error != "authorization_pending":
            raise ValueError("De aanvraag is geweigerd of verlopen. Start opnieuw om een nieuwe code te krijgen.")
    raise ValueError("De code is verlopen.")


def register(app, project):
    profile = profile_path(app, project_id(project))
    if not profile.is_file():
        raise ValueError("Koppel dit project eerst via de browser.")
    cli = shutil.which(app)
    if not cli:
        raise ValueError(APPS[app] + " is op deze computer niet gevonden.")
    APP_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
    helper = APP_DIR / "gidpro_koppel.py"
    if helper.resolve() != Path(__file__).resolve():
        with tempfile.NamedTemporaryFile(dir=APP_DIR, delete=False) as tmp:
            tmp.write(Path(__file__).read_bytes())
        try:
            os.replace(tmp.name, helper)
        finally:
            Path(tmp.name).unlink(missing_ok=True)
    interpreter = Path(sys.executable)
    if interpreter.name.lower() == "pythonw.exe":
        interpreter = interpreter.with_name("python.exe")
    name = "gidpro-" + project
    command = [str(interpreter),str(helper),"serve","--app",app,"--project",project]
    args = ["mcp","add",name,"--",*command] if app == "codex" else [
        "mcp","add","--scope","user","--transport","stdio",name,"--",*command]
    marker = profile.with_suffix(".registered")
    exists = subprocess.run([cli,"mcp","get",name], capture_output=True, timeout=40).returncode == 0
    if exists:
        if marker.is_file():
            return
        raise ValueError("De MCP-naam " + name + " is al in gebruik. Controleer die registratie in je app.")
    result = subprocess.run([cli,*args], capture_output=True, timeout=40)
    if result.returncode:
        raise ValueError("Je app kon de MCP-verbinding " + name + " niet registreren. Controleer de MCP-instellingen van " + APPS[app] + ".")
    marker.touch()


def serve(app, project=None):
    profile = profile_path(app, project)
    data = json.loads(profile.read_text(encoding="utf-8"))
    if project is not None and data.get("project") != project:
        raise ValueError("Dit profiel hoort bij een ander project. Vraag een nieuwe koppeling aan.")
    token = data["token"]
    protocol = None
    for line in sys.stdin:
        message = None
        try:
            message = json.loads(line)
            if not isinstance(message, dict):
                raise ValueError()
            headers = {"MCP-Protocol-Version": protocol} if protocol else None
            status, reply = call("bridge/mcp", message, token, headers)
            if status >= 400:
                raise ValueError("Toegang geweigerd of het portaal is niet bereikbaar.")
            if message.get("method") == "initialize" and isinstance(reply, dict):
                protocol = reply.get("result", {}).get("protocolVersion")
        except (ValueError, OSError):
            if not isinstance(message, dict) or "id" not in message:
                continue
            reply = {"jsonrpc":"2.0","id":message["id"],"error":{"code":-32000,"message":"GidPro is niet bereikbaar of de toestemming is verlopen. Open de koppelhulp."}}
        if reply is not None:
            print(json.dumps(reply), flush=True)


def window():
    import tkinter as tk
    from tkinter import ttk
    win = tk.Tk()
    win.title("GidPro · App koppelen")
    pane = ttk.Frame(win, padding=22)
    pane.pack(fill="both", expand=True)
    ttk.Label(pane, text="Koppel je eigen app", font=("Segoe UI", 19, "bold")).pack(anchor="w")
    ttk.Label(pane, text="Kies je app. Selecteer één project in je browser. Herhaal dit voor elk extra project.",wraplength=420).pack(anchor="w", pady=8)
    app, suggestions = tk.StringVar(value="codex"), tk.BooleanVar(value=False)
    for key, title in APPS.items():
        ttk.Radiobutton(pane, text=title, variable=app, value=key).pack(anchor="w")
    ttk.Checkbutton(pane,text="Ook suggesties mogen indienen",variable=suggestions).pack(anchor="w",pady=7)
    status = tk.StringVar()
    def begin():
        target, scope = app.get(), "suggest" if suggestions.get() else "read"
        button.state(["disabled"])
        def notify(value):
            win.after(0, status.set, value)
        def work():
            try:
                if not shutil.which(target):
                    raise ValueError("Installeer eerst de commandoregelversie van " + APPS[target] + " op deze computer.")
                project = pair(target, scope, notify)
                register(target, project)
                notify("Gekoppeld als gidpro-" + project + ". Open je app opnieuw. Je kunt nu een volgend project koppelen.")
            except (ValueError, OSError, subprocess.SubprocessError) as exc:
                notify(str(exc))
            finally:
                win.after(0, lambda: button.state(["!disabled"]))
        threading.Thread(target=work, daemon=True).start()
    button = ttk.Button(pane,text="Start koppeling",command=begin)
    button.pack(anchor="w",pady=5)
    ttk.Label(pane,textvariable=status,wraplength=430).pack(anchor="w",pady=8)
    win.mainloop()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("mode", nargs="?", choices=("pair","register","serve"))
    parser.add_argument("--app", choices=tuple(APPS), default="codex")
    parser.add_argument("--suggest", action="store_true")
    parser.add_argument("--register", action="store_true")
    parser.add_argument("--project", help="Goedgekeurd project voor een lokale registratie of MCP-sessie")
    opts = parser.parse_args()
    if not opts.mode:
        window()
    elif opts.mode == "serve":
        serve(opts.app, opts.project)
    elif opts.mode == "register":
        if not opts.project:
            parser.error("Kies het eerder gekoppelde project met --project.")
        register(opts.app, opts.project)
    else:
        if opts.project:
            parser.error("Voor een nieuwe koppeling kies je het project in de browser.")
        project = pair(opts.app, "suggest" if opts.suggest else "read", lambda s: print(s, file=sys.stderr, flush=True))
        if opts.register:
            register(opts.app, project)
        print("Gekoppeld aan " + project)
