// Notifications (spec §9.1): a bell in the status bar with the unread

// count across every signed-in hub, and an inbox quick pick that marks an

// entry read and opens it: in the editor when it is a proposal or issue

// of a repository in the workspace, on the hub otherwise.

import * as vscode from "vscode";

import type * as api from "./hubapi";

import { HubAuth } from "./auth";

import { HubTarget, hubTarget } from "./hub";

/** Opens a proposal or issue in the editor; false when it is not in the workspace. */

export type Opener = (target: Extract<HubTarget, { kind: "proposal" | "issue" }>) => Promise<boolean>;

interface Entry {

  base: string;

  n: api.Notification;

}

export class InboxBar implements vscode.Disposable {

  private readonly item = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left, 39);

  private timer: NodeJS.Timeout | undefined;

  /** Unread count last seen, to announce only what is new. */

  private lastUnread: number | undefined;

  constructor(

    private readonly auth: HubAuth,

    private readonly open: Opener,

  ) {

    this.item.command = "oxygenhub.inbox";

    this.item.name = "OxygenHub notifications";

  }

  /** Every hub's inbox; hubs that fail (offline, token without user:read) are skipped. */

  private async fetchAll(): Promise<{ unread: number; entries: Entry[]; failed: string[] }> {

    const out = { unread: 0, entries: [] as Entry[], failed: [] as string[] };

    for (const s of this.auth.all()) {

      try {

        const inbox = await this.auth.clientFor(s.base).notifications();

        out.unread += inbox.unread;

        out.entries.push(...inbox.items.map((n) => ({ base: s.base, n })));

      } catch {

        out.failed.push(s.base);

      }

    }

    out.entries.sort((a, b) => Number(a.n.read) - Number(b.n.read) || b.n.at_ms - a.n.at_ms);

    return out;

  }

  async refresh(): Promise<void> {

    if (!this.auth.all().length) {

      this.item.hide();

      return;

    }

    const { unread, entries, failed } = await this.fetchAll();

    this.item.text = unread ? `$(bell-dot) ${unread}` : "$(bell)";

    this.item.tooltip = unread ? `${unread} unread notification${unread === 1 ? "" : "s"}` : "No unread notifications";

    if (failed.length) {

      this.item.tooltip += `\nCould not read: ${failed.join(", ")} (the token needs user:read)`;

    }

    this.item.show();

    const announce = vscode.workspace.getConfiguration("oxygenhub").get<boolean>("announceNotifications") ?? true;

    if (announce && this.lastUnread !== undefined && unread > this.lastUnread) {

      const newest = entries.find((e) => !e.n.read);

      const more = unread - this.lastUnread;

      const text = more === 1 && newest ? `OxygenHub: ${newest.n.actor ? newest.n.actor + ": " : ""}${newest.n.title}` : `OxygenHub: ${more} new notifications`;

      void vscode.window.showInformationMessage(text, "Open Inbox").then((pick) => pick && vscode.commands.executeCommand("oxygenhub.inbox"));

    }

    this.lastUnread = unread;

  }

  /** The inbox quick pick. */

  async show(): Promise<void> {

    const { entries } = await this.fetchAll();

    type Pick = vscode.QuickPickItem & { entry?: Entry; all?: boolean };

    const items: Pick[] = entries.map((e) => ({

      label: `${e.n.read ? "$(circle-outline)" : "$(circle-filled)"} ${e.n.title}`,

      description: [e.n.actor, e.n.kind].filter(Boolean).join(" · "),

      detail: `${new Date(e.n.at_ms).toLocaleString()} · ${new URL(e.base).host}`,

      entry: e,

    }));

    if (entries.some((e) => !e.n.read)) {

      items.unshift({ label: "$(check-all) Mark all as read", all: true, alwaysShow: true });

    }

    if (!entries.length) {

      void vscode.window.showInformationMessage("OxygenHub: your inbox is empty.");

      return;

    }

    const pick = await vscode.window.showQuickPick(items, { placeHolder: "OxygenHub inbox", matchOnDescription: true, matchOnDetail: true });

    if (!pick) {

      return;

    }

    if (pick.all) {

      for (const s of this.auth.all()) {

        await this.auth.clientFor(s.base).markAllNotificationsRead().catch(() => undefined);

      }

      await this.refresh();

      return;

    }

    const e = pick.entry!;

    if (!e.n.read) {

      await this.auth.clientFor(e.base).markNotificationRead(e.n.id).catch(() => undefined);

    }

    const target = hubTarget(e.n.url);

    const opened = target.kind !== "other" && (await this.open(target).catch(() => false));

    if (!opened) {

      void vscode.env.openExternal(vscode.Uri.parse(e.n.url));

    }

    await this.refresh();

  }

  start(): void {

    const seconds = vscode.workspace.getConfiguration("oxygenhub").get<number>("autoRefresh") ?? 60;

    if (this.timer) {

      clearInterval(this.timer);

    }

    if (seconds > 0) {

      this.timer = setInterval(() => void this.refresh(), seconds * 1000);

    }

    void this.refresh();

  }

  dispose(): void {

    if (this.timer) {

      clearInterval(this.timer);

    }

    this.item.dispose();

  }

}