"""Shared helpers for the two-host dispatch channel.

Path resolution: set DISPATCH_ROOT to the shared filesystem path that both

nodes can read and write. On Linux this is typically a mounted NFS or SMB

share; on Windows it is the mapped drive letter for the same share.

Task envelope v2:

  { "id": "<uuid>", "from": "<node-id>", "to": "<node-id>",

    "created": "<ISO-8601 UTC>", "priority": "low|normal|high",

    "request": "<free text>",

    "require_ack": bool,

    "require_dangerous": bool,

    "timeout_s": int,

    "max_output_bytes": int,

    "schema": 2,

    "hmac": "<hex sha256 hmac>" }

"""

from __future__ import annotations

import hashlib

import hmac

import json

import os

import pathlib

import sys

import time

import uuid

from datetime import datetime, timezone

NODE_A = os.environ.get("DISPATCH_NODE_A", "a")

NODE_B = os.environ.get("DISPATCH_NODE_B", "b")

def _resolve_root() -> pathlib.Path:

    env = os.environ.get("DISPATCH_ROOT")

    if env:

        return pathlib.Path(env)

    raise RuntimeError(

        "DISPATCH_ROOT environment variable is required. "

        "Point it at a filesystem path that both nodes can read and write."

    )

ROOT = _resolve_root()

KEY_PATH = ROOT / "keys" / "hmac.key"

LOG_PATH = ROOT / "session-log.jsonl"

KILLSWITCH = ROOT / "KILLSWITCH"

SCHEMA_VERSION = 2

DEFAULTS = {

    "require_ack": False,

    "require_dangerous": False,

    "timeout_s": 600,

    "max_output_bytes": 2_000_000,

}

def _key() -> bytes:

    return KEY_PATH.read_text().strip().encode()

def _digest(task: dict) -> str:

    payload = "|".join([

        task["id"], task["from"], task["to"], task["created"],

        task["priority"], task["request"],

    ]).encode()

    return hmac.new(_key(), payload, hashlib.sha256).hexdigest()

def sign(task: dict) -> dict:

    task["hmac"] = _digest(task)

    return task

def verify(task: dict) -> bool:

    provided = task.get("hmac", "")

    if not provided:

        return False

    try:

        return hmac.compare_digest(provided, _digest(task))

    except KeyError:

        return False

def new_task(sender: str, recipient: str, request: str,

             priority: str = "normal", callback: str = "file",

             require_ack: bool = False,

             require_dangerous: bool = False,

             timeout_s: int = 600,

             max_output_bytes: int = 2_000_000) -> dict:

    task = {

        "id": str(uuid.uuid4()),

        "from": sender,

        "to": recipient,

        "created": datetime.now(timezone.utc).isoformat(),

        "priority": priority,

        "request": request,

        "callback": callback,

        "require_ack": require_ack,

        "require_dangerous": require_dangerous,

        "timeout_s": timeout_s,

        "max_output_bytes": max_output_bytes,

        "schema": SCHEMA_VERSION,

    }

    return sign(task)

def fill_defaults(task: dict) -> dict:

    for k, v in DEFAULTS.items():

        task.setdefault(k, v)

    return task

def killswitch_tripped() -> tuple[bool, str]:

    if KILLSWITCH.exists():

        try:

            return True, KILLSWITCH.read_text().strip()

        except Exception:

            return True, "unreadable"

    return False, ""

def _lane_dir_name(recipient: str) -> str:

    if recipient == NODE_A:

        return f"{NODE_B}-to-{NODE_A}"

    return f"{NODE_A}-to-{NODE_B}"

def inbox_for(recipient: str) -> pathlib.Path:

    return ROOT / _lane_dir_name(recipient) / "inbox"

def lane(recipient: str, stage: str) -> pathlib.Path:

    lane_dir = ROOT / _lane_dir_name(recipient) / stage

    lane_dir.mkdir(parents=True, exist_ok=True)

    return lane_dir

def enqueue(task: dict) -> pathlib.Path:

    lane_dir = inbox_for(task["to"])

    lane_dir.mkdir(parents=True, exist_ok=True)

    path = lane_dir / f"{task['id']}.json"

    tmp = path.with_suffix(".json.tmp")

    tmp.write_text(json.dumps(task, indent=2))

    os.replace(tmp, path)

    return path

def log_event(session: str, event: str, summary: str,

              task_id: str | None = None, **extra) -> None:

    entry = {

        "ts": datetime.now(timezone.utc).isoformat(),

        "session": session,

        "event": event,

        "summary": summary[:140],

        "task_id": task_id,

    }

    if extra:

        entry.update(extra)

    with LOG_PATH.open("a") as f:

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

def heartbeat(session: str, extra: dict | None = None) -> pathlib.Path:

    hb = ROOT / "heartbeats" / f"{session}.json"

    hb.parent.mkdir(parents=True, exist_ok=True)

    payload = {

        "host": session,

        "ts": datetime.now(timezone.utc).isoformat(),

        "unix": int(time.time()),

        "pid": os.getpid(),

    }

    if extra:

        payload.update(extra)

    tmp = hb.with_suffix(".json.tmp")

    tmp.write_text(json.dumps(payload, indent=2))

    os.replace(tmp, hb)

    return hb