#!/usr/bin/env python3
import json
import os
import subprocess
import threading
import time
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import urlparse

BASE = Path("/home/pi/wunderkammer")
WEBROOT = BASE
STATUS_JSON = BASE / "data" / "prompt" / "status.json"
QUEUE_JSON  = BASE / "data" / "prompt" / "queue.json"
QUEUE_TXT   = BASE / "data" / "prompt" / "queue.txt"  # one prompt per line

GEN = BASE / "bin" / "gen_wunderkammer.py"
VENV_PY = Path("/home/pi/pixel/.venv/bin/python")

PORT = 8080

def read_json(path: Path):
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except Exception:
        return {}

def write_json(path: Path, obj: dict):
    path.parent.mkdir(parents=True, exist_ok=True)
    tmp = path.with_suffix(path.suffix + ".tmp")
    tmp.write_text(json.dumps(obj, ensure_ascii=False, indent=2), encoding="utf-8")
    os.replace(tmp, path)

def status_generating() -> bool:
    st = read_json(STATUS_JSON)
    return bool(st.get("generating"))

def queue_list():
    if not QUEUE_TXT.exists():
        return []
    lines = [l.strip() for l in QUEUE_TXT.read_text(encoding="utf-8").splitlines()]
    return [l for l in lines if l]

def queue_write(lines):
    QUEUE_TXT.parent.mkdir(parents=True, exist_ok=True)
    QUEUE_TXT.write_text("\n".join(lines) + ("\n" if lines else ""), encoding="utf-8")

def queue_update_meta():
    q = queue_list()
    meta = {
        "count": len(q),
        "next_prompt": q[0] if q else "",
        "updated": time.strftime("%Y-%m-%d %H:%M:%S"),
    }
    write_json(QUEUE_JSON, meta)

def clamp_prompt(txt: str, limit_chars: int = 260) -> str:
    if txt is None:
        return ""
    s = " ".join(txt.strip().split())
    if len(s) > limit_chars:
        s = s[:limit_chars].rstrip()
    return s

def start_generation_custom(prompt_text: str):
    cmd = [
        str(VENV_PY), str(GEN),
        "--work", "256",
        "--steps", "20",
        "--guidance", "7.0",
        "--palette", "32",
        "--custom_prompt", prompt_text,
    ]
    subprocess.Popen(cmd, cwd=str(WEBROOT))

def enqueue(prompt_text: str):
    q = queue_list()
    q.append(prompt_text)
    queue_write(q)
    queue_update_meta()
    return len(q)  # position

def pop_next():
    q = queue_list()
    if not q:
        return ""
    nxt = q.pop(0)
    queue_write(q)
    queue_update_meta()
    return nxt

def worker_loop():
    # If generator is idle and queue has entries -> start next
    while True:
        try:
            if (not status_generating()):
                nxt = pop_next()
                if nxt:
                    start_generation_custom(nxt)
            # Keep queue meta fresh
            if not QUEUE_JSON.exists():
                queue_update_meta()
        except Exception:
            pass
        time.sleep(1.0)

class Handler(SimpleHTTPRequestHandler):
    def translate_path(self, path):
        path = urlparse(path).path
        full = (WEBROOT / path.lstrip("/")).resolve()
        if not str(full).startswith(str(WEBROOT.resolve())):
            return str(WEBROOT / "data" / "prompt" / "index.html")
        return str(full)

    def do_POST(self):
        if self.path != "/api/generate":
            self.send_error(404, "Not found")
            return

        length = int(self.headers.get("Content-Length", "0"))
        body = self.rfile.read(length) if length else b""
        try:
            data = json.loads(body.decode("utf-8"))
        except Exception:
            self.send_error(400, "Invalid JSON")
            return

        prompt = clamp_prompt((data.get("prompt") or ""), 260)
        if not prompt:
            self.send_error(400, "Missing prompt")
            return

        # If currently generating -> enqueue
        if status_generating():
            pos = enqueue(prompt)
            self.send_response(202)
            self.send_header("Content-Type", "application/json; charset=utf-8")
            self.end_headers()
            self.wfile.write(json.dumps({
                "ok": True,
                "mode": "queued",
                "position": pos,
                "message": "Busy. Prompt queued for next run."
            }).encode("utf-8"))
            return

        # Start immediately
        start_generation_custom(prompt)
        queue_update_meta()
        self.send_response(202)
        self.send_header("Content-Type", "application/json; charset=utf-8")
        self.end_headers()
        self.wfile.write(json.dumps({
            "ok": True,
            "mode": "started",
            "message": "Accepted. Generation started now."
        }).encode("utf-8"))

def main():
    os.chdir(str(WEBROOT))
    queue_update_meta()
    t = threading.Thread(target=worker_loop, daemon=True)
    t.start()

    httpd = ThreadingHTTPServer(("0.0.0.0", PORT), Handler)
    print(f"Wunderweb listening on http://0.0.0.0:{PORT}/")
    httpd.serve_forever()

if __name__ == "__main__":
    main()
