text.ts

// MARK: - Sanitization

export function sanitize(text: string): string {
  let result = "";
  for (let i = 0; i < text.length; i++) {
    const ch = text[i];
    const code = text.charCodeAt(i);

    // Strip ANSI escape sequences
    if (ch === "\x1b" && i + 1 < text.length && text[i + 1] === "[") {
      let j = i + 2;
      while (j < text.length) {
        const c = text[j];
        if ((c >= "A" && c <= "Z") || (c >= "a" && c <= "z")) {
          i = j;
          break;
        }
        j++;
      }
      if (j >= text.length) i = j - 1;
      continue;
    }

    // Strip ASCII control chars (except \n and \t)
    if (code < 0x20 && ch !== "\n" && ch !== "\t") continue;

    // Strip C1 controls
    if (code >= 0x7f && code <= 0x9f) continue;

    result += ch;
  }
  return result;
}

// MARK: - Date formatting

export function formatDate(dateStr: string): string {
  const date = new Date(dateStr);
  if (isNaN(date.getTime())) return dateStr;

  const now = new Date();
  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
  const yesterday = new Date(today.getTime() - 86400000);
  const msgDay = new Date(date.getFullYear(), date.getMonth(), date.getDate());

  const time = date.toLocaleTimeString("en-US", {
    hour: "numeric",
    minute: "2-digit",
    hour12: true,
  });

  if (msgDay.getTime() === today.getTime()) return `Today, ${time}`;
  if (msgDay.getTime() === yesterday.getTime()) return `Yesterday, ${time}`;

  const dateStr2 = date.toLocaleDateString("en-US", {
    month: "short",
    day: "numeric",
    year: date.getFullYear() !== now.getFullYear() ? "numeric" : undefined,
  });
  return `${dateStr2}, ${time}`;
}

export function formatDayHeader(): string {
  const now = new Date();
  const options: Intl.DateTimeFormatOptions = {
    weekday: "long",
    month: "short",
    day: "numeric",
    year: "numeric",
  };
  return `Today, ${now.toLocaleDateString("en-US", options)}`;
}

// MARK: - Accounts text

interface AccountInfo {
  name: string;
  email: string;
  enabled: boolean;
}

export function printAccountsText(accounts: AccountInfo[]): void {
  if (accounts.length === 0) {
    console.log("No accounts found.");
    return;
  }
  const nameWidth = Math.max(7, ...accounts.map((a) => a.name.length));
  console.log(
    `${"ACCOUNT".padEnd(nameWidth)}  EMAIL`,
  );
  for (const a of accounts) {
    const enabled = a.enabled ? "" : "  (disabled)";
    console.log(`${sanitize(a.name).padEnd(nameWidth)}  ${a.email}${enabled}`);
  }
}

// MARK: - Mailboxes text

interface MailboxInfo {
  name: string;
  unreadCount: number;
}

export function printMailboxesText(mailboxes: MailboxInfo[]): void {
  if (mailboxes.length === 0) {
    console.log("No mailboxes found.");
    return;
  }
  const nameWidth = Math.max(7, ...mailboxes.map((m) => m.name.length));
  console.log(`${"MAILBOX".padEnd(nameWidth)}  UNREAD`);
  for (const m of mailboxes) {
    console.log(
      `${sanitize(m.name).padEnd(nameWidth)}  ${m.unreadCount}`,
    );
  }
}

// MARK: - Message list text

interface MessageSummary {
  id: number;
  subject: string;
  sender: string;
  dateSent: string;
  read: boolean;
  flagged?: boolean;
  mailbox?: string;
}

export function printMessagesText(
  messages: MessageSummary[],
): void {
  if (messages.length === 0) {
    console.log("No messages found.");
    return;
  }
  for (const m of messages) {
    const subject = sanitize(m.subject || "(no subject)");
    const tags: string[] = [];
    if (!m.read) tags.push("unread");
    if (m.flagged) tags.push("flagged");
    const tagStr = tags.length > 0 ? `  ${tags.join(", ")}` : "";
    console.log(subject);
    let detail = `  ${sanitize(m.sender)}  ${formatDate(m.dateSent)}`;
    if (m.mailbox) detail += `  [${sanitize(m.mailbox)}]`;
    detail += tagStr;
    console.log(detail);
    console.log(`  ID: ${m.id}`);
  }
}

// MARK: - Message detail text

interface MessageDetail {
  id: number;
  subject: string;
  sender: string;
  to: string[];
  cc: string[];
  dateSent: string;
  dateReceived: string;
  read: boolean;
  flagged: boolean;
  body: string;
  html?: string;
}

export function printMessageDetailText(msg: MessageDetail): void {
  console.log(`Subject:   ${sanitize(msg.subject || "(no subject)")}`);
  console.log(`From:      ${sanitize(msg.sender)}`);
  if (msg.to.length > 0) console.log(`To:        ${msg.to.join(", ")}`);
  if (msg.cc.length > 0) console.log(`CC:        ${msg.cc.join(", ")}`);
  console.log(`Date:      ${formatDate(msg.dateSent)}`);
  const tags: string[] = [];
  if (!msg.read) tags.push("unread");
  if (msg.flagged) tags.push("flagged");
  if (tags.length > 0) console.log(`Status:    ${tags.join(", ")}`);
  console.log(`ID:        ${msg.id}`);
  if (msg.body) {
    console.log("");
    console.log(sanitize(msg.body));
  }
}

// MARK: - Unread messages text

interface UnreadMessages {
  account: string;
  mailbox: string;
  unreadCount: number;
  messages: MessageSummary[];
}

export function printUnreadMessagesText(
  data: UnreadMessages,
): void {
  console.log(
    `${sanitize(data.account)} — ${data.unreadCount} unread in ${data.mailbox}`,
  );
  console.log("");
  printMessagesText(data.messages);
}

// MARK: - Attachment list text

interface AttachmentInfo {
  name: string;
  mimeType: string | null;
  fileSize: number | null;
  downloaded: boolean | null;
}

export function printAttachmentsText(attachments: AttachmentInfo[]): void {
  if (attachments.length === 0) {
    console.log("No attachments.");
    return;
  }
  for (const a of attachments) {
    let line = sanitize(a.name);
    if (a.mimeType) line += `  ${a.mimeType}`;
    if (a.fileSize != null) line += `  ${formatSize(a.fileSize)}`;
    if (a.downloaded === false) line += "  (not downloaded)";
    console.log(line);
  }
}

function formatSize(bytes: number): string {
  if (bytes < 1024) return `${bytes} B`;
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
}

interface SavedAttachment {
  name: string;
  path: string;
}

export function printSavedAttachmentsText(saved: SavedAttachment[]): void {
  if (saved.length === 0) {
    console.log("No attachments saved.");
    return;
  }
  for (const s of saved) {
    console.log(`Saved: ${sanitize(s.name)} → ${s.path}`);
  }
}

// MARK: - Confirmation text

export function printSentText(
  result: { sent: boolean; to: string; subject: string },
): void {
  console.log(`Sent: ${sanitize(result.subject)}`);
  console.log(`  To: ${result.to}`);
}

export function printDraftText(
  result: { drafted: boolean; to: string; subject: string },
): void {
  console.log(`Draft saved: ${sanitize(result.subject)}`);
  console.log(`  To: ${result.to}`);
}

export function printMarkedText(
  result: { marked: boolean; id: number; read: boolean; flagged: boolean },
): void {
  const tags: string[] = [];
  if (result.read) tags.push("read");
  else tags.push("unread");
  if (result.flagged) tags.push("flagged");
  console.log(`Marked: message ${result.id}  ${tags.join(", ")}`);
}

export function printMovedText(
  result: { moved: boolean; id: number; to: string },
): void {
  console.log(`Moved: message ${result.id} → ${sanitize(result.to)}`);
}

export function printJunkedText(result: { junked: boolean; id: number }): void {
  console.log(`Junked: message ${result.id}`);
}

export function printRepliedText(
  result: { replied: boolean; to: string; subject: string },
): void {
  console.log(`Replied: ${sanitize(result.subject)}`);
  console.log(`  To: ${result.to}`);
}

export function printForwardedText(
  result: { forwarded: boolean; to: string; subject: string },
): void {
  console.log(`Forwarded: ${sanitize(result.subject)}`);
  console.log(`  To: ${result.to}`);
}