#!/usr/bin/env python3
"""Independent Shell Protocol v1 provider AND consumer fixture (Python stdlib).

Not a ZeRaLD installation. Localhost-only simulator for documented wire-format
interoperability; the configured fixture bearer and grants are NOT central ZeRaLD
partner identity, approval, production authentication, or installed authority.
No imports from ZeRaLD. No real partner can enroll with this script.
"""
from __future__ import annotations

import argparse
import hashlib
import json
import mimetypes
import re
import secrets
import sqlite3
import threading
from datetime import datetime, timezone
from email.parser import BytesParser
from email.policy import default as email_default_policy
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.error import HTTPError
from urllib.parse import parse_qs, urlencode, urlsplit
from urllib.request import Request, urlopen

PROTOCOL = "1"
CAPABILITIES = {"database.resource": {"read": {"list", "read"},
                                      "write": {"create", "update", "delete", "update_many", "delete_many"}},
                "media.store": {"read": {"list", "metadata", "download"},
                                "write": {"upload", "replace", "delete"}}}
REF = re.compile(r"^m_[a-f0-9]{32}$")


def envelope(service_id: int, op: str, result):
    return {"ok": True, "protocol_version": PROTOCOL, "service_id": service_id,
            "operation": op, "result": result}


def error(code: str):
    return {"ok": False, "protocol_version": PROTOCOL, "error": {"code": code}}


class FixtureState:
    """A test stand-in for the central identity/grant answers, NOT their implementation."""

    def __init__(self, bearer: str, grants: dict[int, set[str]] | None = None):
        self.bearer = bearer
        self.grants = grants or {101: {"read", "write"}, 202: {"read", "write"}}
        self.lock = threading.RLock()
        self.database = sqlite3.connect(":memory:", check_same_thread=False)
        self.database.execute("CREATE TABLE published_records (id INTEGER PRIMARY KEY, label TEXT)")
        self.database.execute("INSERT INTO published_records VALUES (?, ?)", (1, "first"))
        self.database.commit()
        self.media: dict[str, tuple[dict, bytes]] = {}

    def database_call(self, op: str, payload: dict):
        with self.lock:
            db = self.database
            if op == "list":
                limit, offset = payload.get("limit", 50), payload.get("offset", 0)
                if not isinstance(limit, int) or not isinstance(offset, int) or limit < 0 or offset < 0:
                    raise ValueError("invalid pagination")
                if payload.get("filters", []) or payload.get("sort", []):
                    raise ValueError("fixture does not implement filters/sorts")
                return [dict(zip(("id", "label"), r)) for r in db.execute(
                    "SELECT id, label FROM published_records ORDER BY id LIMIT ? OFFSET ?", (limit, offset))]
            if op == "read":
                row = db.execute("SELECT id,label FROM published_records WHERE id=?", (payload.get("id"),)).fetchone()
                return dict(zip(("id", "label"), row)) if row else None
            if op == "create":
                values = payload.get("values", {})
                if not isinstance(values, dict) or not isinstance(values.get("label"), str):
                    raise ValueError("invalid values")
                db.execute("INSERT INTO published_records (label) VALUES (?)", (values["label"],))
                db.commit()
                return 1
            if op == "update":
                values = payload.get("values", {})
                if not isinstance(values, dict) or not isinstance(values.get("label"), str):
                    raise ValueError("invalid values")
                cur = db.execute("UPDATE published_records SET label=? WHERE id=?", (values["label"], payload.get("id")))
                db.commit()
                return cur.rowcount
            if op == "delete":
                cur = db.execute("DELETE FROM published_records WHERE id=?", (payload.get("id"),))
                db.commit()
                return cur.rowcount
            if op in ("update_many", "delete_many"):
                # Fixture only supports explicitly unrestricted, all-row bulk calls.
                if payload.get("filters", None) != []:
                    raise ValueError("unsupported fixture bulk filter")
                if op == "update_many":
                    values = payload.get("values", {})
                    if not isinstance(values, dict) or not isinstance(values.get("label"), str):
                        raise ValueError("invalid values")
                    cur = db.execute("UPDATE published_records SET label=?", (values["label"],))
                else:
                    cur = db.execute("DELETE FROM published_records")
                db.commit()
                return cur.rowcount
        raise ValueError("unsupported operation")

    def media_call(self, op: str, data: dict, file: tuple[str, bytes] | None = None):
        with self.lock:
            if op in ("upload", "replace"):
                if not file:
                    raise ValueError("binary file is required")
                name, binary = file
                ref = data.get("reference") if op == "replace" else "m_" + secrets.token_hex(16)
                if op == "replace" and (not isinstance(ref, str) or ref not in self.media):
                    raise KeyError("media_not_found")
                now = datetime.now(timezone.utc).isoformat()
                old = self.media.get(ref)
                metadata = {"reference": ref, "name": name,
                            "mime": mimetypes.guess_type(name)[0] or "application/octet-stream",
                            "bytes": len(binary), "sha256": hashlib.sha256(binary).hexdigest(),
                            "created_at": old[0]["created_at"] if old else now, "updated_at": now}
                self.media[ref] = (metadata, binary)
                return dict(metadata)
            if op == "list":
                offset, limit = data.get("offset", 0), data.get("limit", 50)
                if not isinstance(offset, int) or not isinstance(limit, int) or offset < 0 or limit < 1:
                    raise ValueError("invalid pagination")
                refs = sorted(self.media)
                return {"objects": [self.media[r][0].copy() for r in refs[offset:offset+limit]], "total": len(refs)}
            ref = data.get("reference")
            if not isinstance(ref, str) or not REF.fullmatch(ref):
                raise ValueError("invalid reference")
            if ref not in self.media:
                raise KeyError("media_not_found")
            meta, binary = self.media[ref]
            if op == "metadata":
                return dict(meta)
            if op == "download":
                return dict(meta), binary
            if op == "delete":
                del self.media[ref]
                return {"deleted": True, "reference": ref}
        raise ValueError("unsupported operation")


def make_handler(state: FixtureState):
    class Handler(BaseHTTPRequestHandler):
        server_version = "ShellProtocolFixture/1"

        def log_message(self, format, *args):  # No bearer or media contents in logs.
            pass

        def json_reply(self, status, payload):
            encoded = json.dumps(payload, separators=(",", ":")).encode("utf-8")
            self.send_response(status)
            self.send_header("Content-Type", "application/json")
            self.send_header("Cache-Control", "no-store")
            self.send_header("Content-Length", str(len(encoded)))
            self.end_headers()
            self.wfile.write(encoded)

        def dispatch(self, method):
            parsed = urlsplit(self.path)
            if parsed.path not in ("/shell-database.php", "/shell-media.php"):
                return self.json_reply(404, error("service_unavailable"))
            if method == "GET" and parsed.path != "/shell-media.php":
                return self.json_reply(405, error("method_not_allowed"))
            token = self.headers.get("Authorization", "")
            if token != "Bearer " + state.bearer:
                return self.json_reply(401, error("token_invalid"))
            raw = b""
            multipart = False
            if method == "POST":
                size = int(self.headers.get("Content-Length", "0"))
                if size < 0 or size > 16_777_216:  # Local fixture input bound, not ZeRaLD policy.
                    return self.json_reply(422, error("invalid_payload"))
                raw = self.rfile.read(size)
                content_type = self.headers.get("Content-Type", "")
                multipart = content_type.lower().startswith("multipart/form-data")
                if multipart:
                    message = BytesParser(policy=email_default_policy).parsebytes(
                        b"Content-Type: " + content_type.encode() + b"\r\nMIME-Version: 1.0\r\n\r\n" + raw)
                    fields = {}
                    uploaded = None
                    for part in message.iter_parts():
                        field_name = part.get_param("name", header="content-disposition")
                        if field_name == "file":
                            uploaded = (part.get_filename() or "media", part.get_payload(decode=True))
                        else:
                            fields[field_name] = part.get_content()
                    data = fields
                else:
                    try:
                        data = json.loads(raw)
                    except (UnicodeDecodeError, ValueError):
                        return self.json_reply(422, error("invalid_payload"))
                    uploaded = None
            else:
                data = {k: v[-1] for k, v in parse_qs(parsed.query).items()}
                uploaded = None
            if not isinstance(data, dict):
                return self.json_reply(422, error("invalid_payload"))
            try:
                sid = data.get("service_id")
                if isinstance(sid, bool) or not str(sid).isdigit() or int(sid) < 1:
                    raise ValueError("invalid service")
                sid = int(sid)
                capability = "database.resource" if parsed.path == "/shell-database.php" else "media.store"
                expected_sid = 101 if capability == "database.resource" else 202
                op = "download" if method == "GET" else data.get("operation")
                if sid != expected_sid:
                    return self.json_reply(404, error("service_unavailable"))
                scopes = CAPABILITIES[capability]
                if not isinstance(op, str) or not any(op in v for v in scopes.values()):
                    return self.json_reply(422, error("operation_unsupported"))
                required_scope = "read" if op in scopes["read"] else "write"
                if required_scope not in state.grants.get(sid, set()):
                    return self.json_reply(404, error("service_unavailable"))
                if capability == "database.resource":
                    payload = data.get("payload")
                    if not isinstance(payload, dict):
                        raise ValueError("invalid payload")
                    return self.json_reply(200, envelope(sid, op, state.database_call(op, payload)))
                if op in ("upload", "replace") and not multipart:
                    raise ValueError("binary multipart required")
                result = state.media_call(op, data, uploaded)
                if op == "download":
                    metadata, binary = result
                    self.send_response(200)
                    self.send_header("Content-Type", metadata["mime"])
                    self.send_header("Content-Length", str(len(binary)))
                    self.send_header("X-ZeRaLD-Media-Reference", metadata["reference"])
                    self.send_header("Cache-Control", "no-store")
                    self.end_headers()
                    self.wfile.write(binary)
                    return
                return self.json_reply(200, envelope(sid, op, result))
            except KeyError:
                return self.json_reply(404, error("media_not_found"))
            except (ValueError, TypeError, sqlite3.Error):
                return self.json_reply(422, error("invalid_payload"))

        def do_POST(self):
            self.dispatch("POST")

        def do_GET(self):
            self.dispatch("GET")

    return Handler


class ProtocolClient:
    """An independent consumer client for either a simulator or a permitted peer."""

    def __init__(self, base: str, bearer: str):
        self.base = base.rstrip("/")
        self.bearer = bearer

    def call(self, path: str, body: dict | None = None, *, reference: str | None = None,
             file: tuple[str, bytes] | None = None) -> tuple[int, dict | bytes, dict]:
        url = self.base + path
        headers = {"Authorization": "Bearer " + self.bearer}
        method = "POST"
        data = None
        if reference is not None:
            url += "?" + urlencode({"service_id": 202, "reference": reference})
            method = "GET"
        elif file is not None:
            boundary = "ze-sim-" + secrets.token_hex(12)
            fields = {**(body or {})}
            parts = []
            for key, val in fields.items():
                parts.append((f"--{boundary}\r\nContent-Disposition: form-data; name=\"{key}\"\r\n\r\n{val}\r\n").encode())
            name, binary = file
            parts.append((f"--{boundary}\r\nContent-Disposition: form-data; name=\"file\"; filename=\"{name}\"\r\nContent-Type: application/octet-stream\r\n\r\n").encode() + binary + b"\r\n")
            parts.append((f"--{boundary}--\r\n").encode())
            data = b"".join(parts)
            headers["Content-Type"] = "multipart/form-data; boundary=" + boundary
        else:
            data = json.dumps(body or {}).encode()
            headers["Content-Type"] = "application/json"
        request = Request(url, data=data, headers=headers, method=method)
        try:
            with urlopen(request, timeout=8) as response:
                code, raw, resp_headers = response.status, response.read(), dict(response.headers)
        except HTTPError as exc:
            code, raw, resp_headers = exc.code, exc.read(), dict(exc.headers)
        try:
            result = json.loads(raw)
        except (ValueError, UnicodeDecodeError):
            result = raw
        return code, result, resp_headers


def main():
    parser = argparse.ArgumentParser(description="Localhost-only independent Shell Protocol v1 fixture")
    parser.add_argument("--port", type=int, default=0)
    parser.add_argument("--test-token", default="local-fixture-token")
    args = parser.parse_args()
    if args.port < 0 or args.port > 65535:
        parser.error("invalid port")
    state = FixtureState(args.test_token)
    server = ThreadingHTTPServer(("127.0.0.1", args.port), make_handler(state))
    print(json.dumps({"fixture": True, "url": f"http://127.0.0.1:{server.server_port}",
                      "external_partner_identity_implemented": False}), flush=True)
    try:
        server.serve_forever()
    except KeyboardInterrupt:
        pass
    finally:
        server.server_close()


if __name__ == "__main__":
    main()
