import chalk from "chalk";
import { Command } from "commander";
import { agentCommand } from "../commands/agent.js";
import { sendCommand } from "../commands/send.js";
import { statusCommand } from "../commands/status.js";
import { webhookCommand } from "../commands/webhook.js";
import { loadConfig } from "../config/config.js";
import { ensureTwilioEnv } from "../env.js";
import { danger, info, setVerbose, setYes } from "../globals.js";
import { getResolvedLoggerSettings } from "../logging.js";
import {
  loginWeb,
  logoutWeb,
  monitorWebProvider,
  pickProvider,
  resolveHeartbeatRecipients,
  runWebHeartbeatOnce,
  type WebMonitorTuning,
} from "../provider-web.js";
import { defaultRuntime } from "../runtime.js";
import { runTwilioHeartbeatOnce } from "../twilio/heartbeat.js";
import type { Provider } from "../utils.js";
import { VERSION } from "../version.js";
import {
  resolveHeartbeatSeconds,
  resolveReconnectPolicy,
} from "../web/reconnect.js";
import {
  createDefaultDeps,
  logTwilioFrom,
  logWebSelfId,
  monitorTwilio,
} from "./deps.js";
import { spawnRelayTmux } from "./relay_tmux.js";

export function buildProgram() {
  const program = new Command();
  const PROGRAM_VERSION = VERSION;
  const TAGLINE =
    "Send, receive, and auto-reply on WhatsApp—Twilio-backed or QR-linked.";

  program
    .name("clawdis")
    .description("WhatsApp relay CLI (Twilio or WhatsApp Web session)")
    .version(PROGRAM_VERSION);

  const formatIntroLine = (version: string, rich = true) => {
    const base = `📡 clawdis ${version} — ${TAGLINE}`;
    return rich && chalk.level > 0
      ? `${chalk.bold.cyan("📡 clawdis")} ${chalk.white(version)} ${chalk.gray("—")} ${chalk.green(TAGLINE)}`
      : base;
  };

  program.configureHelp({
    optionTerm: (option) => chalk.yellow(option.flags),
    subcommandTerm: (cmd) => chalk.green(cmd.name()),
  });

  program.configureOutput({
    writeOut: (str) => {
      const colored = str
        .replace(/^Usage:/gm, chalk.bold.cyan("Usage:"))
        .replace(/^Options:/gm, chalk.bold.cyan("Options:"))
        .replace(/^Commands:/gm, chalk.bold.cyan("Commands:"));
      process.stdout.write(colored);
    },
    writeErr: (str) => process.stderr.write(str),
    outputError: (str, write) => write(chalk.red(str)),
  });

  if (process.argv.includes("-V") || process.argv.includes("--version")) {
    console.log(formatIntroLine(PROGRAM_VERSION));
    process.exit(0);
  }

  program.addHelpText("beforeAll", `\n${formatIntroLine(PROGRAM_VERSION)}\n`);
  const examples = [
    [
      "clawdis login --verbose",
      "Link personal WhatsApp Web and show QR + connection logs.",
    ],
    [
      'clawdis send --to +15551234567 --message "Hi" --provider web --json',
      "Send via your web session and print JSON result.",
    ],
    [
      "clawdis relay --provider auto --interval 5 --lookback 15 --verbose",
      "Auto-reply loop: prefer Web when logged in, otherwise Twilio polling.",
    ],
    [
      "clawdis webhook --ingress tailscale --port 42873 --path /webhook/whatsapp --verbose",
      "Start webhook + Tailscale Funnel and update Twilio callbacks.",
    ],
    [
      "clawdis status --limit 10 --lookback 60 --json",
      "Show last 10 messages from the past hour as JSON.",
    ],
    [
      'clawdis agent --to +15551234567 --message "Run summary" --thinking high',
      "Talk directly to the agent using the same session handling, no WhatsApp send.",
    ],
  ] as const;

  const fmtExamples = examples
    .map(([cmd, desc]) => `  ${chalk.green(cmd)}\n    ${chalk.gray(desc)}`)
    .join("\n");

  program.addHelpText(
    "afterAll",
    `\n${chalk.bold.cyan("Examples:")}\n${fmtExamples}\n`,
  );

  program
    .command("login")
    .description("Link your personal WhatsApp via QR (web provider)")
    .option("--verbose", "Verbose connection logs", false)
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      try {
        await loginWeb(Boolean(opts.verbose));
      } catch (err) {
        defaultRuntime.error(danger(`Web login failed: ${String(err)}`));
        defaultRuntime.exit(1);
      }
    });

  program
    .command("logout")
    .description("Clear cached WhatsApp Web credentials")
    .action(async () => {
      try {
        await logoutWeb(defaultRuntime);
      } catch (err) {
        defaultRuntime.error(danger(`Logout failed: ${String(err)}`));
        defaultRuntime.exit(1);
      }
    });

  program
    .command("send")
    .description("Send a WhatsApp message")
    .requiredOption(
      "-t, --to <number>",
      "Recipient number in E.164 (e.g. +15551234567)",
    )
    .requiredOption("-m, --message <text>", "Message body")
    .option(
      "--media <path-or-url>",
      "Attach image (<=5MB). Web: path or URL. Twilio: https URL or local path hosted via webhook/funnel.",
    )
    .option(
      "--serve-media",
      "For Twilio: start a temporary media server if webhook is not running",
      false,
    )
    .option(
      "-w, --wait <seconds>",
      "Wait for delivery status (0 to skip)",
      "20",
    )
    .option("-p, --poll <seconds>", "Polling interval while waiting", "2")
    .option("--provider <provider>", "Provider: twilio | web", "twilio")
    .option("--dry-run", "Print payload and skip sending", false)
    .option("--json", "Output result as JSON", false)
    .option("--verbose", "Verbose logging", false)
    .addHelpText(
      "after",
      `
Examples:
  clawdis send --to +15551234567 --message "Hi"                # wait 20s for delivery (default)
  clawdis send --to +15551234567 --message "Hi" --wait 0       # fire-and-forget
  clawdis send --to +15551234567 --message "Hi" --dry-run      # print payload only
  clawdis send --to +15551234567 --message "Hi" --wait 60 --poll 3`,
    )
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      const deps = createDefaultDeps();
      try {
        await sendCommand(opts, deps, defaultRuntime);
      } catch (err) {
        defaultRuntime.error(String(err));
        defaultRuntime.exit(1);
      }
    });

  program
    .command("agent")
    .description(
      "Talk directly to the configured agent (no WhatsApp send, reuses sessions)",
    )
    .requiredOption("-m, --message <text>", "Message body for the agent")
    .option(
      "-t, --to <number>",
      "Recipient number in E.164 used to derive the session key",
    )
    .option("--session-id <id>", "Use an explicit session id")
    .option(
      "--thinking <level>",
      "Thinking level: off | minimal | low | medium | high",
    )
    .option("--verbose <on|off>", "Persist agent verbose level for the session")
    .option(
      "--deliver",
      "Send the agent's reply back to WhatsApp (requires --to)",
      false,
    )
    .option(
      "--provider <provider>",
      "Provider to deliver via when using --deliver (auto | web | twilio)",
      "auto",
    )
    .option("--json", "Output result as JSON", false)
    .option(
      "--timeout <seconds>",
      "Override agent command timeout (seconds, default 600 or config value)",
    )
    .addHelpText(
      "after",
      `
Examples:
  clawdis agent --to +15551234567 --message "status update"
  clawdis agent --session-id 1234 --message "Summarize inbox" --thinking medium
  clawdis agent --to +15551234567 --message "Trace logs" --verbose on --json
  clawdis agent --to +15551234567 --message "Summon reply" --deliver --provider web
`,
    )
    .action(async (opts) => {
      const verboseLevel =
        typeof opts.verbose === "string" ? opts.verbose.toLowerCase() : "";
      setVerbose(verboseLevel === "on");
      // Build default deps (keeps parity with other commands; future-proofing).
      void createDefaultDeps();
      try {
        await agentCommand(opts, defaultRuntime);
      } catch (err) {
        defaultRuntime.error(String(err));
        defaultRuntime.exit(1);
      }
    });

  program
    .command("heartbeat")
    .description(
      "Trigger a heartbeat or manual send once (web or twilio, no tmux)",
    )
    .option("--provider <provider>", "auto | web | twilio", "auto")
    .option("--to <number>", "Override target E.164; defaults to allowFrom[0]")
    .option(
      "--session-id <id>",
      "Force a session id for this heartbeat (resumes a specific Claude session)",
    )
    .option(
      "--all",
      "Send heartbeat to all active sessions (or allowFrom entries when none)",
      false,
    )
    .option(
      "--message <text>",
      "Send a custom message instead of the heartbeat probe (web or twilio provider)",
    )
    .option("--body <text>", "Alias for --message")
    .option("--dry-run", "Print the resolved payload without sending", false)
    .option("--verbose", "Verbose logging", false)
    .addHelpText(
      "after",
      `
Examples:
  clawdis heartbeat                 # uses web session + first allowFrom contact
  clawdis heartbeat --verbose       # prints detailed heartbeat logs
  clawdis heartbeat --to +1555123   # override destination
  clawdis heartbeat --session-id <uuid> --to +1555123   # resume a specific session
  clawdis heartbeat --message "Ping" --provider twilio
  clawdis heartbeat --all           # send to every active session recipient or allowFrom entry`,
    )
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      const cfg = loadConfig();
      const allowAll = Boolean(opts.all);
      const resolution = resolveHeartbeatRecipients(cfg, {
        to: opts.to,
        all: allowAll,
      });
      if (
        !opts.to &&
        !allowAll &&
        resolution.source === "session-ambiguous" &&
        resolution.recipients.length > 1
      ) {
        defaultRuntime.error(
          danger(
            `Multiple active sessions found (${resolution.recipients.join(", ")}). Pass --to <E.164> or --all to send to all.`,
          ),
        );
        defaultRuntime.exit(1);
      }
      const recipients = resolution.recipients;
      if (!recipients || recipients.length === 0) {
        defaultRuntime.error(
          danger(
            "No destination found. Add inbound.allowFrom numbers or pass --to <E.164>.",
          ),
        );
        defaultRuntime.exit(1);
      }
      const providerPref = String(opts.provider ?? "auto");
      if (!["auto", "web", "twilio"].includes(providerPref)) {
        defaultRuntime.error("--provider must be auto, web, or twilio");
        defaultRuntime.exit(1);
      }

      const overrideBody =
        (opts.message as string | undefined) ||
        (opts.body as string | undefined) ||
        undefined;
      const dryRun = Boolean(opts.dryRun);

      const provider =
        providerPref === "twilio"
          ? "twilio"
          : await pickProvider(providerPref as "auto" | "web");
      if (provider === "twilio") ensureTwilioEnv();

      try {
        for (const to of recipients) {
          if (provider === "web") {
            await runWebHeartbeatOnce({
              to,
              verbose: Boolean(opts.verbose),
              runtime: defaultRuntime,
              sessionId: opts.sessionId,
              overrideBody,
              dryRun,
            });
          } else {
            await runTwilioHeartbeatOnce({
              to,
              verbose: Boolean(opts.verbose),
              runtime: defaultRuntime,
              overrideBody,
              dryRun,
            });
          }
        }
      } catch {
        defaultRuntime.exit(1);
      }
    });

  program
    .command("relay")
    .description("Auto-reply to inbound messages (auto-selects web or twilio)")
    .option("--provider <provider>", "auto | web | twilio", "auto")
    .option("-i, --interval <seconds>", "Polling interval for twilio mode", "5")
    .option(
      "-l, --lookback <minutes>",
      "Initial lookback window for twilio mode",
      "5",
    )
    .option(
      "--web-heartbeat <seconds>",
      "Heartbeat interval for web relay health logs (seconds)",
    )
    .option(
      "--web-retries <count>",
      "Max consecutive web reconnect attempts before exit (0 = unlimited)",
    )
    .option(
      "--web-retry-initial <ms>",
      "Initial reconnect backoff for web relay (ms)",
    )
    .option("--web-retry-max <ms>", "Max reconnect backoff for web relay (ms)")
    .option(
      "--heartbeat-now",
      "Run a heartbeat immediately when relay starts (web provider)",
      false,
    )
    .option("--verbose", "Verbose logging", false)
    .addHelpText(
      "after",
      `
Examples:
  clawdis relay                     # auto: web if logged-in, else twilio poll
  clawdis relay --provider web      # force personal web session
  clawdis relay --provider twilio   # force twilio poll
  clawdis relay --provider twilio --interval 2 --lookback 30
  # Troubleshooting: docs/refactor/web-relay-troubleshooting.md
`,
    )
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      const { file: logFile, level: logLevel } = getResolvedLoggerSettings();
      defaultRuntime.log(info(`logs: ${logFile} (level ${logLevel})`));
      const providerPref = String(opts.provider ?? "auto");
      if (!["auto", "web", "twilio"].includes(providerPref)) {
        defaultRuntime.error("--provider must be auto, web, or twilio");
        defaultRuntime.exit(1);
      }
      const intervalSeconds = Number.parseInt(opts.interval, 10);
      const lookbackMinutes = Number.parseInt(opts.lookback, 10);
      const webHeartbeat =
        opts.webHeartbeat !== undefined
          ? Number.parseInt(String(opts.webHeartbeat), 10)
          : undefined;
      const webRetries =
        opts.webRetries !== undefined
          ? Number.parseInt(String(opts.webRetries), 10)
          : undefined;
      const webRetryInitial =
        opts.webRetryInitial !== undefined
          ? Number.parseInt(String(opts.webRetryInitial), 10)
          : undefined;
      const webRetryMax =
        opts.webRetryMax !== undefined
          ? Number.parseInt(String(opts.webRetryMax), 10)
          : undefined;
      const heartbeatNow = Boolean(opts.heartbeatNow);
      if (Number.isNaN(intervalSeconds) || intervalSeconds <= 0) {
        defaultRuntime.error("Interval must be a positive integer");
        defaultRuntime.exit(1);
      }
      if (Number.isNaN(lookbackMinutes) || lookbackMinutes < 0) {
        defaultRuntime.error("Lookback must be >= 0 minutes");
        defaultRuntime.exit(1);
      }
      if (
        webHeartbeat !== undefined &&
        (Number.isNaN(webHeartbeat) || webHeartbeat <= 0)
      ) {
        defaultRuntime.error("--web-heartbeat must be a positive integer");
        defaultRuntime.exit(1);
      }
      if (
        webRetries !== undefined &&
        (Number.isNaN(webRetries) || webRetries < 0)
      ) {
        defaultRuntime.error("--web-retries must be >= 0");
        defaultRuntime.exit(1);
      }
      if (
        webRetryInitial !== undefined &&
        (Number.isNaN(webRetryInitial) || webRetryInitial <= 0)
      ) {
        defaultRuntime.error("--web-retry-initial must be a positive integer");
        defaultRuntime.exit(1);
      }
      if (
        webRetryMax !== undefined &&
        (Number.isNaN(webRetryMax) || webRetryMax <= 0)
      ) {
        defaultRuntime.error("--web-retry-max must be a positive integer");
        defaultRuntime.exit(1);
      }
      if (
        webRetryMax !== undefined &&
        webRetryInitial !== undefined &&
        webRetryMax < webRetryInitial
      ) {
        defaultRuntime.error("--web-retry-max must be >= --web-retry-initial");
        defaultRuntime.exit(1);
      }

      const webTuning: WebMonitorTuning = {};
      if (webHeartbeat !== undefined) webTuning.heartbeatSeconds = webHeartbeat;
      if (heartbeatNow) webTuning.replyHeartbeatNow = true;
      const reconnect: WebMonitorTuning["reconnect"] = {};
      if (webRetries !== undefined) reconnect.maxAttempts = webRetries;
      if (webRetryInitial !== undefined) reconnect.initialMs = webRetryInitial;
      if (webRetryMax !== undefined) reconnect.maxMs = webRetryMax;
      if (Object.keys(reconnect).length > 0) {
        webTuning.reconnect = reconnect;
      }

      const provider = await pickProvider(providerPref as Provider | "auto");

      if (provider === "web") {
        logWebSelfId(defaultRuntime, true);
        const cfg = loadConfig();
        const effectiveHeartbeat = resolveHeartbeatSeconds(
          cfg,
          webTuning.heartbeatSeconds,
        );
        const effectivePolicy = resolveReconnectPolicy(
          cfg,
          webTuning.reconnect,
        );
        defaultRuntime.log(
          info(
            `Web relay health: heartbeat ${effectiveHeartbeat}s, retries ${effectivePolicy.maxAttempts || "∞"}, backoff ${effectivePolicy.initialMs}→${effectivePolicy.maxMs}ms x${effectivePolicy.factor} (jitter ${Math.round(effectivePolicy.jitter * 100)}%)`,
          ),
        );
        try {
          await monitorWebProvider(
            Boolean(opts.verbose),
            undefined,
            true,
            undefined,
            defaultRuntime,
            undefined,
            webTuning,
          );
          return;
        } catch (err) {
          defaultRuntime.error(
            danger(
              `Web relay failed: ${String(err)}. Not falling back; re-link with 'clawdis login --provider web'.`,
            ),
          );
          defaultRuntime.exit(1);
        }
      }

      ensureTwilioEnv();
      logTwilioFrom();
      await monitorTwilio(intervalSeconds, lookbackMinutes);
    });

  program
    .command("relay:heartbeat")
    .description(
      "Run relay with an immediate heartbeat (no tmux); requires web provider",
    )
    .option("--provider <provider>", "auto | web", "auto")
    .option("--verbose", "Verbose logging", false)
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      const { file: logFile, level: logLevel } = getResolvedLoggerSettings();
      defaultRuntime.log(info(`logs: ${logFile} (level ${logLevel})`));
      const providerPref = String(opts.provider ?? "auto");
      if (!["auto", "web"].includes(providerPref)) {
        defaultRuntime.error("--provider must be auto or web");
        defaultRuntime.exit(1);
        return;
      }
      const provider = await pickProvider(providerPref as "auto" | "web");
      if (provider !== "web") {
        defaultRuntime.error(
          danger(
            "Heartbeat relay is only supported for the web provider. Link with `clawdis login --verbose`.",
          ),
        );
        defaultRuntime.exit(1);
        return;
      }

      logWebSelfId(defaultRuntime, true);
      const cfg = loadConfig();
      const effectiveHeartbeat = resolveHeartbeatSeconds(cfg, undefined);
      const effectivePolicy = resolveReconnectPolicy(cfg, undefined);
      defaultRuntime.log(
        info(
          `Web relay health: heartbeat ${effectiveHeartbeat}s, retries ${effectivePolicy.maxAttempts || "∞"}, backoff ${effectivePolicy.initialMs}→${effectivePolicy.maxMs}ms x${effectivePolicy.factor} (jitter ${Math.round(effectivePolicy.jitter * 100)}%)`,
        ),
      );

      try {
        await monitorWebProvider(
          Boolean(opts.verbose),
          undefined,
          true,
          undefined,
          defaultRuntime,
          undefined,
          { replyHeartbeatNow: true },
        );
      } catch (err) {
        defaultRuntime.error(
          danger(
            `Web relay failed: ${String(err)}. Re-link with 'clawdis login --provider web'.`,
          ),
        );
        defaultRuntime.exit(1);
      }
    });

  program
    .command("status")
    .description("Show recent WhatsApp messages (sent and received)")
    .option("-l, --limit <count>", "Number of messages to show", "20")
    .option("-b, --lookback <minutes>", "How far back to fetch messages", "240")
    .option("--json", "Output JSON instead of text", false)
    .option("--verbose", "Verbose logging", false)
    .addHelpText(
      "after",
      `
Examples:
  clawdis status                            # last 20 msgs in past 4h
  clawdis status --limit 5 --lookback 30    # last 5 msgs in past 30m
  clawdis status --json --limit 50          # machine-readable output`,
    )
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      const deps = createDefaultDeps();
      try {
        await statusCommand(opts, deps, defaultRuntime);
      } catch (err) {
        defaultRuntime.error(String(err));
        defaultRuntime.exit(1);
      }
    });

  program
    .command("webhook")
    .description(
      "Run inbound webhook. ingress=tailscale updates Twilio; ingress=none stays local-only.",
    )
    .option("-p, --port <port>", "Port to listen on", "42873")
    .option("-r, --reply <text>", "Optional auto-reply text")
    .option("--path <path>", "Webhook path", "/webhook/whatsapp")
    .option(
      "--ingress <mode>",
      "Ingress: tailscale (funnel + Twilio update) | none (local only)",
      "tailscale",
    )
    .option("--verbose", "Log inbound and auto-replies", false)
    .option("-y, --yes", "Auto-confirm prompts when possible", false)
    .option("--dry-run", "Print planned actions without starting server", false)
    .addHelpText(
      "after",
      `
Examples:
  clawdis webhook                       # ingress=tailscale (funnel + Twilio update)
  clawdis webhook --ingress none        # local-only server (no funnel / no Twilio update)
  clawdis webhook --port 45000          # pick a high, less-colliding port
  clawdis webhook --reply "Got it!"     # static auto-reply; otherwise use config file`,
    )
    // istanbul ignore next
    .action(async (opts) => {
      setVerbose(Boolean(opts.verbose));
      setYes(Boolean(opts.yes));
      const deps = createDefaultDeps();
      try {
        const server = await webhookCommand(opts, deps, defaultRuntime);
        if (!server) {
          defaultRuntime.log(
            info("Webhook dry-run complete; no server started."),
          );
          return;
        }
        process.on("SIGINT", () => {
          server.close(() => {
            console.log("\n👋 Webhook stopped");
            defaultRuntime.exit(0);
          });
        });
        await deps.waitForever();
      } catch (err) {
        defaultRuntime.error(String(err));
        defaultRuntime.exit(1);
      }
    });

  program
    .command("relay:tmux")
    .description(
      "Run relay --verbose inside tmux (session clawdis-relay), restarting if already running, then attach",
    )
    .action(async () => {
      try {
        const shouldAttach = Boolean(process.stdout.isTTY);
        const session = await spawnRelayTmux(
          "pnpm clawdis relay --verbose",
          shouldAttach,
        );
        defaultRuntime.log(
          info(
            shouldAttach
              ? `tmux session started and attached: ${session} (pane running "pnpm clawdis relay --verbose")`
              : `tmux session started: ${session} (pane running "pnpm clawdis relay --verbose"); attach manually with "tmux attach -t ${session}"`,
          ),
        );
      } catch (err) {
        defaultRuntime.error(
          danger(`Failed to start relay tmux session: ${String(err)}`),
        );
        defaultRuntime.exit(1);
      }
    });

  program
    .command("relay:tmux:attach")
    .description(
      "Attach to the existing clawdis-relay tmux session (no restart)",
    )
    .action(async () => {
      try {
        if (!process.stdout.isTTY) {
          defaultRuntime.error(
            danger(
              "Cannot attach: stdout is not a TTY. Run this in a terminal or use 'tmux attach -t clawdis-relay' manually.",
            ),
          );
          defaultRuntime.exit(1);
          return;
        }
        await spawnRelayTmux("pnpm clawdis relay --verbose", true, false);
        defaultRuntime.log(info("Attached to clawdis-relay session."));
      } catch (err) {
        defaultRuntime.error(
          danger(`Failed to attach to clawdis-relay: ${String(err)}`),
        );
        defaultRuntime.exit(1);
      }
    });

  program
    .command("relay:heartbeat:tmux")
    .description(
      "Run relay --verbose with an immediate heartbeat inside tmux (session clawdis-relay), then attach",
    )
    .action(async () => {
      try {
        const shouldAttach = Boolean(process.stdout.isTTY);
        const session = await spawnRelayTmux(
          "pnpm clawdis relay --verbose --heartbeat-now",
          shouldAttach,
        );
        defaultRuntime.log(
          info(
            shouldAttach
              ? `tmux session started and attached: ${session} (pane running "pnpm clawdis relay --verbose --heartbeat-now")`
              : `tmux session started: ${session} (pane running "pnpm clawdis relay --verbose --heartbeat-now"); attach manually with "tmux attach -t ${session}"`,
          ),
        );
      } catch (err) {
        defaultRuntime.error(
          danger(
            `Failed to start relay tmux session with heartbeat: ${String(err)}`,
          ),
        );
        defaultRuntime.exit(1);
      }
    });

  return program;
}