#!/usr/bin/env python3
"""Plan-18 Chat turn entrypoint.

Thin harness-owned router for Control Panel: classify once, then delegate to the
mode primitive. NestJS calls this file only; it does not own governance verdicts.
"""
import argparse
import hashlib
import json
import os
import subprocess
import sys
import tempfile
import uuid


def project_root() -> str:
    d = os.path.abspath(os.path.dirname(__file__))
    p = d
    while p != os.path.dirname(p):
        if os.path.isdir(os.path.join(p, ".specify")) or os.path.isdir(os.path.join(p, "packages/casan-harness")):
            return p
        p = os.path.dirname(p)
    return os.path.abspath(os.path.join(d, "..", "..", ".."))


ROOT = project_root()
BIN = os.path.join(ROOT, "packages", "casan-harness", "scripts", "bash")
ROUTER = os.path.join(BIN, "prompt-mode-router.py")
AGENT_RESOLVER = os.path.join(BIN, "chat-agent-resolver.py")
READONLY = os.path.join(BIN, "chat-readonly.py")
OPERATOR = os.path.join(BIN, "chat-operator.py")
LOOP_RUN = os.path.join(BIN, "loop-run.sh")
LOOP_TRACE = os.path.join(BIN, "loop-trace.py")
PREFLIGHT = os.path.join(BIN, "harness-preflight.sh")
CONTEXT_SCAN = os.path.join(BIN, "context-assemble-scan.sh")
TOOL_OUTPUT_SCAN = os.path.join(BIN, "tool-output-scan.sh")


def state_root() -> str:
    return os.environ.get("CASAN_STATE_ROOT") or os.path.join(ROOT, ".specify")


def sha(text: str) -> str:
    return hashlib.sha256(text.encode("utf-8")).hexdigest()


def classify(message: str):
    r = subprocess.run(["python3", ROUTER, "classify", "--message", message], cwd=ROOT, capture_output=True, text=True)
    try:
        return json.loads(r.stdout)
    except Exception:
        return {"mode": "BLOCK", "risk": "high", "reason": "router_invalid_json", "matched_rules": [r.stderr.strip()]}


def scan_tool_output(text: str, label: str):
    with tempfile.TemporaryDirectory() as td:
        path = os.path.join(td, "tool-output.txt")
        with open(path, "w", encoding="utf-8") as fh:
            fh.write(text)
        r = subprocess.run(["bash", TOOL_OUTPUT_SCAN, path, label], cwd=ROOT, capture_output=True, text=True)
        return r.returncode, (r.stdout + r.stderr).strip()


def run_mode(args, binding, loop_run=None, scan_output_label=""):
    env = os.environ.copy()
    if loop_run is not None:
        env["CASAN_CHAT_LOOP_RUN_JSON"] = json.dumps(loop_run, ensure_ascii=False, sort_keys=True)
    r = subprocess.run(args, cwd=ROOT, capture_output=True, text=True, env=env)
    if scan_output_label:
        scan_rc, scan_msg = scan_tool_output(r.stdout + "\n" + r.stderr, scan_output_label)
        if scan_rc != 0:
            print(json.dumps({
                "success": False,
                "mode": binding.get("mode") if binding else "OPERATOR",
                "risk": "high",
                "decision": "DENIED",
                "answer": "Denied by H4 tool-output scan.",
                "sources": [],
                "certified": False,
                "audit": {},
                "router": {"reason": "tool_output_scan_denied", "matched_rules": [scan_msg]},
                "agent_binding": binding,
                "loop_run": loop_run,
            }, ensure_ascii=False))
            return 2
    try:
        payload = json.loads(r.stdout)
        payload["agent_binding"] = binding
        if loop_run is not None:
            payload["loop_run"] = loop_run
        print(json.dumps(payload, ensure_ascii=False))
    except Exception:
        if r.stdout:
            sys.stdout.write(r.stdout)
        if r.stderr:
            sys.stderr.write(r.stderr)
    return r.returncode


def run_and_passthrough(args):
    r = subprocess.run(args, cwd=ROOT, text=True)
    return r.returncode


def default_agent_for_mode(mode: str) -> str:
    if mode == "OPERATOR":
        return "ops-operator"
    if mode == "CODEGEN":
        return "codegen-draft"
    return "evidence-reader"


def write_json(path: str, payload):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w", encoding="utf-8") as fh:
        json.dump(payload, fh, ensure_ascii=False, indent=2, sort_keys=True)


def write_text(path: str, text: str):
    os.makedirs(os.path.dirname(path), exist_ok=True)
    with open(path, "w", encoding="utf-8") as fh:
        fh.write(text)


def loop_dir(run_id: str) -> str:
    return os.path.join(state_root(), "logs", "chat", "loop-runs", run_id)


def run_preflight_and_context(run_id: str, draft_path: str):
    preflight_out = os.path.join(loop_dir(run_id), "preflight.json")
    r = subprocess.run(["bash", PREFLIGHT, draft_path, preflight_out, "--model", "local:chat-turn"], cwd=ROOT, capture_output=True, text=True)
    if r.returncode != 0:
        return False, "harness_preflight_failed", (r.stdout + r.stderr).strip()
    r = subprocess.run(["bash", CONTEXT_SCAN, draft_path], cwd=ROOT, capture_output=True, text=True)
    if r.returncode != 0:
        return False, "context_assemble_scan_failed", (r.stdout + r.stderr).strip()
    return True, "preflight_pass", (r.stdout + r.stderr).strip()


def certify_operator_draft(args, router, binding):
    run_id = f"chat-{sha('|'.join([args.chat_id or 'chat-default', args.turn_id or '', args.message]))[:16]}"
    d = loop_dir(run_id)
    draft_path = os.path.join(d, "draft.txt")
    criteria_path = os.path.join(d, "success-criteria.json")
    draft = "\n".join([
        "CHAT_TURN",
        "ACTION_HELD",
        f"chat_id={args.chat_id or 'chat-default'}",
        f"turn_id={args.turn_id or 'auto'}",
        f"mode={router.get('mode')}",
        f"agent={binding.get('agent_selected')}",
        f"skill={binding.get('skill_selected')}",
        f"delegation_level={binding.get('delegation_level')}",
        f"user_msg_ref={sha(args.message)}",
        f"user_message_preview={args.message[:160]}",
        "",
    ])
    write_text(draft_path, draft)
    write_json(criteria_path, {
        "must_contain": ["CHAT_TURN", "ACTION_HELD", f"agent={binding.get('agent_selected')}"],
        "must_not_contain": ["BYPASS_LOOP_GATE"],
    })

    ok, preflight_reason, preflight_detail = run_preflight_and_context(run_id, draft_path)
    if not ok:
        return {
            "success": False,
            "decision": "DENIED",
            "reason": preflight_reason,
            "detail": preflight_detail,
            "run_id": run_id,
            "draft_ref": sha(draft),
            "draft_certified": False,
            "side_effect_released": False,
            "artifact": draft_path,
            "success_criteria": criteria_path,
        }, 2

    loop_env = {
        **os.environ,
        "CASAN_LOOP_STATE_ROOT": os.environ.get("CASAN_LOOP_STATE_ROOT") or os.path.join(state_root(), "logs", "chat", "loop-state"),
        "CASAN_TENANT_ID": args.tenant,
    }
    dlevel = f"L{binding.get('delegation_level', 0)}"
    r = subprocess.run([
        "bash", LOOP_RUN,
        "--run-id", run_id,
        "--artifact", draft_path,
        "--success-criteria", criteria_path,
        "--profile", os.environ.get("CASAN_PROFILE", "dev"),
        "--delegation-level", dlevel,
        "--project", args.project,
        "--max-steps", "2",
        "--tokens-per-step", "128",
        "--cost-per-step", "0",
        "--context", draft_path,
    ], cwd=ROOT, capture_output=True, text=True, env=loop_env)
    trace_rc = subprocess.run(["python3", LOOP_TRACE, "verify-chain", "--run-id", run_id], cwd=ROOT, capture_output=True, text=True, env=loop_env)
    replay_rc = subprocess.run(["python3", LOOP_TRACE, "replay", "--run-id", run_id, "--profile", os.environ.get("CASAN_PROFILE", "dev")], cwd=ROOT, capture_output=True, text=True, env=loop_env)
    certified = r.returncode == 0 and "final=DONE" in r.stdout and trace_rc.returncode == 0 and replay_rc.returncode == 0
    return {
        "success": certified,
        "decision": "CERTIFIED" if certified else "HALTED",
        "reason": "loop_run_pass" if certified else "loop_run_failed",
        "run_id": run_id,
        "draft_ref": sha(draft),
        "draft_certified": certified,
        "side_effect_released": certified,
        "artifact": draft_path,
        "success_criteria": criteria_path,
        "output": (r.stdout + r.stderr).strip(),
        "trace_verify": {"ok": trace_rc.returncode == 0, "output": (trace_rc.stdout + trace_rc.stderr).strip()},
        "replay": {"ok": replay_rc.returncode == 0, "output": (replay_rc.stdout + replay_rc.stderr).strip()},
    }, (0 if certified else 3)


def denied_from_loop(router, binding, loop_run):
    print(json.dumps({
        "success": False,
        "mode": router.get("mode", "OPERATOR"),
        "risk": router.get("risk", "medium"),
        "decision": "DENIED" if loop_run.get("decision") == "DENIED" else "HALTED",
        "answer": f"Operator side-effect held: {loop_run.get('reason')}",
        "sources": [{
            "path": os.path.relpath(loop_run.get("artifact", ""), ROOT) if loop_run.get("artifact") else "",
            "line": 1,
            "excerpt": "UNCERTIFIED draft held before side-effect.",
            "score": 1,
        }],
        "certified": False,
        "audit": {},
        "router": router,
        "agent_binding": binding,
        "loop_run": loop_run,
    }, ensure_ascii=False))


def bind_agent(args, router):
    agent = args.agent or default_agent_for_mode(router.get("mode", "READ_ONLY"))
    tools = []
    if router.get("mode") == "OPERATOR":
        # The operator primitive resolves the exact registered action later; the
        # agent bind still proves this turn is allowed to use the operator class.
        tools.append("run-chat-tests")
    cmd = [
        "python3", AGENT_RESOLVER, "bind",
        "--agent", agent,
        "--actor", args.actor,
        "--role", args.role,
        "--project", args.project,
        "--tenant", args.tenant,
        "--delegation-level", str(args.delegation_level),
    ]
    if args.skill:
        cmd += ["--skill", args.skill]
    for tool in tools:
        cmd += ["--tool", tool]
    r = subprocess.run(cmd, cwd=ROOT, capture_output=True, text=True)
    if r.returncode != 0:
        sys.stdout.write((r.stdout or r.stderr).strip() + "\n")
        return r.returncode, None
    try:
        return 0, json.loads(r.stdout)
    except Exception:
        print(json.dumps({"success": False, "decision": "DENIED", "reason": "agent_resolver_invalid_json"}, ensure_ascii=False))
        return 2, None


def ask(args) -> int:
    router = classify(args.message)
    bind_rc, binding = bind_agent(args, router)
    if bind_rc != 0:
        return bind_rc
    common = [
        "--message", args.message,
        "--actor", args.actor,
        "--chat-id", args.chat_id,
        "--turn-id", args.turn_id,
        "--tenant", args.tenant,
    ]
    if router.get("mode") == "OPERATOR":
        loop_run, loop_rc = certify_operator_draft(args, router, binding)
        if loop_rc != 0:
            denied_from_loop(router, binding, loop_run)
            return loop_rc
        return run_mode(["python3", OPERATOR, "run", *common], binding, loop_run, "chat-operator")
    return run_mode(["python3", READONLY, "ask", *common], binding)


def verify_audit() -> int:
    return run_and_passthrough(["python3", READONLY, "verify-audit"])


def main() -> int:
    ap = argparse.ArgumentParser()
    sub = ap.add_subparsers(dest="cmd", required=True)
    askp = sub.add_parser("ask")
    askp.add_argument("--message", required=True)
    askp.add_argument("--actor", default="anonymous")
    askp.add_argument("--role", default="viewer")
    askp.add_argument("--project", default="default")
    askp.add_argument("--chat-id", default="")
    askp.add_argument("--turn-id", default="")
    askp.add_argument("--tenant", default="default")
    askp.add_argument("--agent", default="")
    askp.add_argument("--skill", default="")
    askp.add_argument("--delegation-level", type=int, default=0)
    askp.set_defaults(func=ask)
    sub.add_parser("verify-audit").set_defaults(func=lambda _args: verify_audit())
    args = ap.parse_args()
    return args.func(args)


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