#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import os
import subprocess
from datetime import datetime, timezone
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
JOB_DIR = Path(os.environ.get("PI_SESSION_MEMORY_JOB_DIR", BASE_DIR / "sessions" / "session-memory-jobs"))
ANALYZER = Path(os.environ.get("PI_SESSION_MEMORY_ANALYZER", BASE_DIR / "scripts" / "session-memory-analyzer.py"))


def write_job(payload: dict[str, object]) -> Path:
    JOB_DIR.mkdir(parents=True, exist_ok=True)
    job_id = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
    job_file = JOB_DIR / f"{job_id}.json"
    job = {
        "job_id": job_id,
        "queued_at": datetime.now(timezone.utc).isoformat(),
        "status": "queued",
        "job_type": "session_memory_analysis",
        "payload": payload,
        "analysis": {
            "status": "queued",
            "save": None,
            "memory_id": None,
        },
    }
    job_file.write_text(json.dumps(job, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
    return job_file


def launch_analyzer(job_file: Path) -> None:
    log_file = job_file.with_suffix(".log")
    log_handle = log_file.open("ab")
    subprocess.Popen(
        ["python3", str(ANALYZER), "--job-file", str(job_file)],
        stdout=log_handle,
        stderr=subprocess.STDOUT,
        start_new_session=True,
        close_fds=True,
    )


class Handler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path != "/api/session-memory":
            self.send_response(404)
            self.end_headers()
            return

        length = int(self.headers.get("Content-Length", "0") or "0")
        raw = self.rfile.read(length)
        try:
            payload = json.loads(raw.decode("utf-8"))
        except Exception as exc:
            self.send_response(400)
            self.send_header("Content-Type", "application/json")
            self.end_headers()
            self.wfile.write(json.dumps({"error": f"invalid json: {exc}"}).encode())
            return

        try:
            job_file = write_job(payload)
            launch_analyzer(job_file)
            self.send_response(202)
            self.send_header("Content-Type", "application/json")
            self.end_headers()
            self.wfile.write(json.dumps({"status": "queued", "job_file": str(job_file)}).encode())
        except Exception as exc:
            self.send_response(502)
            self.send_header("Content-Type", "application/json")
            self.end_headers()
            self.wfile.write(json.dumps({"error": str(exc)}).encode())

    def log_message(self, fmt, *args):
        return


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=17882)
    args = parser.parse_args()

    server = ThreadingHTTPServer((args.host, args.port), Handler)
    print(f"session-memory-dispatcher listening on http://{args.host}:{args.port}/api/session-memory", flush=True)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        return 0
    return 0


if __name__ == "__main__":
    raise SystemExit(main())