main.ts

import { accounts } from "./commands/accounts.ts";
import { mailboxes } from "./commands/mailboxes.ts";
import { list } from "./commands/list.ts";
import { show } from "./commands/show.ts";
import { search } from "./commands/search.ts";
import { send } from "./commands/send.ts";
import { draft } from "./commands/draft.ts";
import { mark } from "./commands/mark.ts";
import { move } from "./commands/move.ts";
import { junk } from "./commands/junk.ts";
import { attachments } from "./commands/attachments.ts";
import { unread } from "./commands/unread.ts";
import { today } from "./commands/today.ts";
import { flagged } from "./commands/flagged.ts";
import { reply } from "./commands/reply.ts";
import { forward } from "./commands/forward.ts";

export interface Flags {
  [key: string]: string;
}

export interface ParsedArgs {
  flags: Flags;
  listFlags: Record<string, string[]>;
  positional: string[];
}

const booleanFlags = new Set([
  "json",
  "unread",
  "read",
  "flagged",
  "unflagged",
  "html",
  "help",
  "h",
  "all",
  "send",
]);

export function parseArgs(args: string[]): ParsedArgs {
  const flags: Flags = {};
  const listFlags: Record<string, string[]> = {};
  const positional: string[] = [];
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    if (arg === "--") {
      positional.push(...args.slice(i + 1));
      break;
    }
    if (arg.startsWith("--")) {
      const key = arg.slice(2);
      if (booleanFlags.has(key)) {
        flags[key] = "true";
      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
        const val = args[++i];
        if (key in flags) {
          if (!listFlags[key]) listFlags[key] = [flags[key]];
          listFlags[key].push(val);
        }
        flags[key] = val;
      } else {
        die(`flag --${key} requires a value`);
      }
    } else if (arg.startsWith("-") && arg.length === 2) {
      const key = arg.slice(1);
      if (booleanFlags.has(key)) {
        flags[key] = "true";
      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
        flags[key] = args[++i];
      } else {
        die(`flag -${key} requires a value`);
      }
    } else {
      positional.push(arg);
    }
  }
  return { flags, listFlags, positional };
}

export function die(msg: string): never {
  console.error(`nanomail: ${msg}`);
  Deno.exit(1);
}

export function parseIntFlag(value: string, name: string, fallback: number): number {
  const n = parseInt(value, 10);
  if (isNaN(n)) die(`--${name} must be a number, got: ${value}`);
  return n;
}

export function parseLimit(flags: Flags, fallback: number): number {
  return Math.max(1, parseIntFlag(flags.limit || String(fallback), "limit", fallback));
}

export function parseOffset(flags: Flags): number {
  return Math.max(0, parseIntFlag(flags.offset || "0", "offset", 0));
}

const validCommands = new Set([
  "accounts",
  "mailboxes",
  "list",
  "show",
  "search",
  "send",
  "draft",
  "reply",
  "forward",
  "mark",
  "move",
  "junk",
  "attachments",
  "unread",
  "today",
  "flagged",
]);

function printUsage(): void {
  console.log(`Usage: nanomail <command> [options]

Commands:
  accounts      List email accounts
  mailboxes     List mailboxes for an account
  list          List messages in a mailbox
  show          Show full message details
  search        Search messages by subject/sender
  unread        Unread messages across all accounts
  today         Messages received today
  flagged       Flagged messages
  send          Send an email
  draft         Save a draft email
  reply         Reply to a message
  forward       Forward a message
  mark          Mark messages read/unread/flagged/unflagged
  move          Move a message to another mailbox
  junk          Mark as junk and move to Junk folder
  attachments   List or save message attachments
  help          Show help for a command

Global options:
  --json        Output JSON instead of human-readable text

Run 'nanomail help <command>' for details.`);
}

function printCommandHelp(command: string): void {
  switch (command) {
    case "accounts":
      console.log(`Usage: nanomail accounts [--json]

List all configured email accounts.`);
      break;
    case "mailboxes":
      console.log(`Usage: nanomail mailboxes -a <account> [--json]

List mailboxes for an account with unread counts.`);
      break;
    case "list":
      console.log(`Usage: nanomail list -a <account> -m <mailbox> [options]

List messages in a mailbox. Shows most recent first.

Options:
  -a <account>      Account name (required)
  -m <mailbox>      Mailbox name (required)
  --unread          Show only unread messages
  --flagged         Show only flagged messages
  --since <date>    Show messages since date (ISO 8601)
  --limit <n>       Max messages to return (default: 20)
  --offset <n>      Skip first N messages
  --json            Output JSON`);
      break;
    case "show":
      console.log(`Usage: nanomail show -a <account> -m <mailbox> --id <id> [--json]

Show full message details including body.

Options:
  --html            Include raw HTML source`);
      break;
    case "search":
      console.log(`Usage: nanomail search <query> -a <account> [options]

Search messages by subject. Optionally filter by sender or mailbox.

Options:
  -a <account>      Account name (required)
  -m <mailbox>      Search within specific mailbox (default: all)
  --from <sender>   Filter by sender address/name
  --limit <n>       Max results (default: 20)
  --offset <n>      Skip first N results
  --json            Output JSON`);
      break;
    case "unread":
      console.log(`Usage: nanomail unread [-a <account>] [--json]

Without -a: show unread messages from all accounts' INBOXes.
With -a: show unread messages from that account's INBOX.

Options:
  -a <account>      Filter to one account
  --limit <n>       Max messages (default: 50)
  --json            Output JSON`);
      break;
    case "today":
      console.log(`Usage: nanomail today [-a <account>] [--json]

Messages received today across all accounts (or one with -a).
Scans INBOX only.

Options:
  -a <account>      Filter to one account
  --limit <n>       Max messages (default: 50)
  --offset <n>      Skip first N messages
  --json            Output JSON`);
      break;
    case "flagged":
      console.log(`Usage: nanomail flagged [-a <account>] [-m <mailbox>] [--json]

Flagged messages across all accounts (or filtered).
Scans INBOX by default.

Options:
  -a <account>      Filter to one account
  -m <mailbox>      Specific mailbox (default: INBOX)
  --limit <n>       Max messages (default: 50)
  --offset <n>      Skip first N messages
  --json            Output JSON`);
      break;
    case "send":
      console.log(`Usage: nanomail send -a <account> --to <addr> --subject <subj> --body <text>

Send an email immediately.

Options:
  -a <account>      Account to send from (required)
  --to <address>    Recipient (required)
  --cc <address>    CC recipient
  --bcc <address>   BCC recipient
  --subject <text>  Subject line (required)
  --body <text>     Email body (required)
  --attachment <f>  Attach file (repeatable)
  --json            Output JSON`);
      break;
    case "draft":
      console.log(`Usage: nanomail draft -a <account> --to <addr> --subject <subj> --body <text>
       nanomail draft reply -a <account> -m <mailbox> --id <id> --body <text>
       nanomail draft forward -a <account> -m <mailbox> --id <id> --to <addr>

Create a draft in Mail.app's Drafts folder for review before sending.
Sub-commands 'reply' and 'forward' create reply/forward drafts.

Options (compose):
  -a <account>      Account to draft from (required)
  --to <address>    Recipient (required)
  --cc <address>    CC recipient
  --bcc <address>   BCC recipient
  --subject <text>  Subject line (required)
  --body <text>     Email body (required)
  --attachment <f>  Attach file (repeatable)
  --json            Output JSON

See 'nanomail help reply' and 'nanomail help forward' for sub-command options.`);
      break;
    case "mark":
      console.log(`Usage: nanomail mark -a <account> -m <mailbox> --id <id> [flags]

Mark a message. At least one flag required.

Options:
  --read            Mark as read
  --unread          Mark as unread
  --flagged         Mark as flagged
  --unflagged       Remove flag
  --json            Output JSON`);
      break;
    case "move":
      console.log(`Usage: nanomail move -a <account> -m <mailbox> --id <id> --to <target>

Move a message. Target can be "trash", "archive", or a mailbox name.

Options:
  --json            Output JSON`);
      break;
    case "junk":
      console.log(`Usage: nanomail junk -a <account> -m <mailbox> --id <id>

Mark a message as junk and move to Junk/Spam folder.

Options:
  --json            Output JSON`);
      break;
    case "reply":
      console.log(`Usage: nanomail reply -a <account> -m <mailbox> --id <id> --body <text> [options]

Reply to a message. Quotes the original message body.
Saves as draft by default. Use --send to send immediately.

Options:
  -a <account>      Account name (required)
  -m <mailbox>      Mailbox name (required)
  --id <id>         Message ID to reply to (required)
  --body <text>     Reply body text (required)
  --all             Reply to all recipients
  --send            Send immediately instead of saving as draft
  --json            Output JSON

Also available as: nanomail draft reply ...`);
      break;
    case "forward":
      console.log(`Usage: nanomail forward -a <account> -m <mailbox> --id <id> --to <addr> [options]

Forward a message. Includes original message headers and body.
Saves as draft by default. Use --send to send immediately.
Attachments are NOT forwarded.

Options:
  -a <account>      Account name (required)
  -m <mailbox>      Mailbox name (required)
  --id <id>         Message ID to forward (required)
  --to <address>    Recipient address (required)
  --body <text>     Optional message above forwarded content
  --send            Send immediately instead of saving as draft
  --json            Output JSON

Also available as: nanomail draft forward ...`);
      break;
    case "attachments":
      console.log(`Usage: nanomail attachments -a <account> -m <mailbox> --id <id> [--save <dir>]

List attachments, or save them to a directory.

Options:
  --save <dir>      Save attachments to directory
  --json            Output JSON`);
      break;
    default:
      die(`unknown command: ${command}`);
  }
}

async function main() {
  const [command, ...rest] = Deno.args;

  if (!command || command === "--help" || command === "-h") {
    printUsage();
    Deno.exit(0);
  }

  if (command === "help") {
    const sub = rest[0];
    if (sub) {
      printCommandHelp(sub);
    } else {
      printUsage();
    }
    Deno.exit(0);
  }

  if (!validCommands.has(command)) {
    die(`unknown command: ${command}`);
  }

  const { flags, listFlags, positional } = parseArgs(rest);
  const json = flags.json === "true";

  try {
    switch (command) {
      case "accounts":
        await accounts(json);
        break;
      case "mailboxes":
        await mailboxes(flags, json);
        break;
      case "list":
        await list(flags, json);
        break;
      case "show":
        await show(flags, json);
        break;
      case "search":
        await search(flags, positional, json);
        break;
      case "send":
        await send(flags, listFlags, json);
        break;
      case "draft":
        await draft(flags, listFlags, positional, json);
        break;
      case "reply":
        await reply(flags, json);
        break;
      case "forward":
        await forward(flags, json);
        break;
      case "mark":
        await mark(flags, json);
        break;
      case "move":
        await move(flags, json);
        break;
      case "junk":
        await junk(flags, json);
        break;
      case "attachments":
        await attachments(flags, json);
        break;
      case "unread":
        await unread(flags, json);
        break;
      case "today":
        await today(flags, json);
        break;
      case "flagged":
        await flagged(flags, json);
        break;
    }
  } catch (err: unknown) {
    const msg = err instanceof Error ? err.message : String(err);
    die(msg);
  }
}

main();