#!/usr/bin/env python3
"""Send a notification to the originating Telegram or Slack conversation."""

from __future__ import annotations

import json
import os
from pathlib import Path
import subprocess
import sys


sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "lib"))
from env_compat import get_env  # noqa: E402
from notify_prompt import (  # noqa: E402
    MessageInputError,
    read_message_input,
    validate_argv,
)


USAGE = """Usage:
  notify
  notify --telegram CHAT_ID
  notify --slack CHANNEL THREAD_TS

Message text is read from standard input. Use a single-quoted heredoc."""


def fail_usage(message: str) -> int:
    print(f"notify: {message}", file=sys.stderr)
    print(USAGE, file=sys.stderr)
    return 2


def _parse_route(argv: list[str]) -> tuple[list[str], str, str, str, list[str]]:
    adapter = route_id = slack_thread = ""
    if argv and argv[0] in {"-h", "--help"}:
        print(USAGE)
        raise SystemExit(0)
    if argv[:1] == ["--slack"]:
        if len(argv) < 3:
            raise ValueError("--slack requires CHANNEL and THREAD_TS")
        adapter, route_id, slack_thread = "slack", argv[1], argv[2]
        route_argv, remaining = ["notify", *argv[:3]], argv[3:]
    elif argv[:1] == ["--telegram"]:
        if len(argv) < 2:
            raise ValueError("--telegram requires CHAT_ID")
        adapter, route_id = "telegram", argv[1]
        route_argv, remaining = ["notify", *argv[:2]], argv[2:]
    elif argv[:1] == ["--"]:
        route_argv, remaining = ["notify"], argv[1:]
    elif argv and argv[0].startswith("--"):
        raise ValueError(f"unknown option: {argv[0]}")
    else:
        route_argv, remaining = ["notify"], argv
    validate_argv(route_argv)
    return route_argv, adapter, route_id, slack_thread, remaining


def _creature_emoji(session: str, session_reg: Path) -> str:
    if not session:
        return "🦫"
    result = subprocess.run(
        [session_reg, "get-field", session, "creature"],
        capture_output=True,
        text=True,
        check=False,
    )
    return {
        "raccoon": "🦝",
        "beaver": "🦫",
        "otter": "🦦",
        "wolf": "🐺",
    }.get(result.stdout.strip(), "🦫")


def _safe_transport_detail(stderr: str, secrets: tuple[str, ...]) -> str:
    """Keep curl's diagnosis while withholding request credentials/content."""
    detail = " ".join(stderr.split())
    for secret in sorted((value for value in secrets if value), key=len, reverse=True):
        detail = detail.replace(secret, "<redacted>")
    # Curl diagnostics are short. Bound untrusted output from wrappers/proxies.
    return detail[:300] or "no curl diagnostic"


def main(argv: list[str] | None = None) -> int:
    argv = list(sys.argv[1:] if argv is None else argv)
    try:
        route_argv, adapter, route_id, slack_thread, remaining = _parse_route(argv)
    except ValueError as exc:
        return fail_usage(str(exc))

    try:
        message = read_message_input(
            route_argv,
            remaining,
            sys.stdin,
            prefix="WOLTSPACE_NOTIFY",
        )
    except MessageInputError as exc:
        print(str(exc), file=sys.stderr, end="")
        return 2

    session = get_env("WOLTSPACE_WOLT_SESSION", "")
    wolt_name = get_env("WOLTSPACE_WOLT_NAME", "wolt")
    session_reg = Path(__file__).resolve().parent / "session-reg"
    full_message = f"{_creature_emoji(session, session_reg)} {wolt_name}: {message}"
    payload: dict[str, str] = {"session": session, "message": full_message}
    if adapter == "slack":
        payload.update(adapter="slack", channel=route_id, thread_ts=slack_thread)
    elif adapter == "telegram":
        payload.update(adapter="telegram", chat_id=route_id)

    api = os.environ.get("WOLTSPACE_API", "http://localhost:7777")
    request = subprocess.run(
        [
            "curl",
            "-s",
            "-X",
            "POST",
            f"{api}/notify",
            "-H",
            "Content-Type: application/json",
            "-d",
            json.dumps(payload),
        ],
        capture_output=True,
        text=True,
        check=False,
    )
    if request.returncode != 0:
        detail = _safe_transport_detail(
            request.stderr,
            (
                message,
                full_message,
                os.environ.get("SLACK_BOT_TOKEN", ""),
                os.environ.get("SLACK_APP_TOKEN", ""),
                os.environ.get("TELEGRAM_BOT_TOKEN", ""),
            ),
        )
        print(
            f"notify: transport failed (curl exit {request.returncode}): {detail}",
            file=sys.stderr,
        )
        return 1
    response = request.stdout
    try:
        result = json.loads(response)
    except json.JSONDecodeError:
        print("notify: failed: invalid or empty API response", file=sys.stderr)
        return 1
    if result.get("ok"):
        print(f"[notify] → {result.get('adapter', '?')}: {message}")
        return 0
    print(f"notify: failed: {result.get('error', 'unknown error')}", file=sys.stderr)
    return 1


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