#!/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 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")
    response = 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,
    ).stdout
    try:
        result = json.loads(response)
    except json.JSONDecodeError:
        print(f"notify: failed: {response or 'unknown error'}", 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())
