// The Drops view (spec §8.4): your drops on each hub you are signed in to,
// and others' drops you open; each drop's files open as documents that save
// back to the hub as a new change. Share as a Drop makes one from a
// selection, an editor or files in the Explorer.

import * as vscode from "vscode";
import type * as api from "./hubapi";
import { HubAuth } from "./auth";
import { DROP_SCHEME, DropRef, commentLine, dedent, dropBaseOf, dropIdOf, dropLabel, dropUriParts, embedSnippet, parseDropUri, shareNames, snippetName, snippetTitle } from "./dropkit";

type Node =
  | { kind: "hub"; base: string }
  | { kind: "drop"; base: string; d: api.Drop; mine: boolean }
  | { kind: "file"; base: string; d: api.Drop; f: api.DropFile; mine: boolean };

export type DropNode = Extract<Node, { kind: "drop" }>;
export type DropFileNode = Extract<Node, { kind: "file" }>;

export function dropUri(r: DropRef): vscode.Uri {
  return vscode.Uri.from({ scheme: DROP_SCHEME, ...dropUriParts(r) });
}

export class DropsProvider implements vscode.TreeDataProvider<Node> {
  private readonly emitter = new vscode.EventEmitter<void>();
  readonly onDidChangeTreeData = this.emitter.event;
  /** Others' drops opened this session, by hub. */
  private readonly opened = new Map<string, Map<string, api.Drop>>();
  private me = new Map<string, string>();

  constructor(private readonly auth: HubAuth) {}

  refresh(): void {
    this.emitter.fire();
  }

  /** Keep a drop in the view after opening, forking or sharing it. */
  remember(base: string, d: api.Drop): void {
    if (this.me.get(base) !== d.owner) {
      const m = this.opened.get(base) ?? new Map<string, api.Drop>();
      m.set(d.id, d);
      this.opened.set(base, m);
    }
    this.refresh();
  }

  forget(base: string, id: string): void {
    this.opened.get(base)?.delete(id);
    this.refresh();
  }

  private hubs(): string[] {
    return this.auth.all().map((s) => s.base);
  }

  getTreeItem(node: Node): vscode.TreeItem {
    switch (node.kind) {
      case "hub": {
        const item = new vscode.TreeItem(node.base.replace(/^https?:\/\//, ""), vscode.TreeItemCollapsibleState.Expanded);
        item.iconPath = new vscode.ThemeIcon("server");
        item.contextValue = "dropHub";
        return item;
      }
      case "drop": {
        const { label, description } = dropLabel(node.d);
        const item = new vscode.TreeItem(label, vscode.TreeItemCollapsibleState.Collapsed);
        item.id = `${node.base}/${node.d.id}`;
        item.description = node.mine ? description : `${node.d.owner} · ${description}`;
        item.iconPath = new vscode.ThemeIcon(node.d.visibility === "secret" ? "lock" : node.d.forked_from ? "repo-forked" : "note");
        const md = new vscode.MarkdownString(`**${label}** by ${node.d.owner}${node.d.description ? `\n\n${node.d.description}` : ""}\n\n${node.d.url}`);
        item.tooltip = md;
        // dropMine/dropOther, then whether the caller starred it.
        item.contextValue = `${node.mine ? "dropMine" : "dropOther"}${node.d.starred ? "Starred" : ""}`;
        return item;
      }
      case "file": {
        const item = new vscode.TreeItem(node.f.name, vscode.TreeItemCollapsibleState.None);
        item.resourceUri = dropUri({ base: node.base, id: node.d.id, name: node.f.name });
        item.description = node.f.size >= 1024 ? `${(node.f.size / 1024).toFixed(1)} KiB` : `${node.f.size} B`;
        item.contextValue = node.mine ? "dropFileMine" : "dropFile";
        item.command = { title: "Open", command: "vscode.open", arguments: [item.resourceUri] };
        return item;
      }
    }
  }

  async getChildren(node?: Node): Promise<Node[]> {
    if (!node) {
      const hubs = this.hubs();
      return hubs.length === 1 ? this.dropsOf(hubs[0]) : hubs.map((base) => ({ kind: "hub" as const, base }));
    }
    if (node.kind === "hub") {
      return this.dropsOf(node.base);
    }
    if (node.kind === "drop") {
      return node.d.files.map((f) => ({ kind: "file" as const, base: node.base, d: node.d, f, mine: node.mine }));
    }
    return [];
  }

  private async dropsOf(base: string): Promise<Node[]> {
    const client = this.auth.clientFor(base);
    try {
      if (!this.me.has(base)) {
        this.me.set(base, (await client.me()).username);
      }
      const mine = await client.drops();
      const others = [...(this.opened.get(base)?.values() ?? [])].filter((d) => !mine.some((m) => m.id === d.id));
      return [...mine.map((d) => ({ kind: "drop" as const, base, d, mine: true })), ...others.map((d) => ({ kind: "drop" as const, base, d, mine: false }))];
    } catch (e) {
      void vscode.window.showWarningMessage(`OxygenHub: ${(e as Error).message}`);
      return [];
    }
  }
}

/**
 * Drop files as a file system: reading fetches the drop, writing commits the
 * file to it (PATCH, one change per save), deleting removes it. A drop's own
 * folder lists its files.
 */
export class DropFileSystem implements vscode.FileSystemProvider {
  private readonly emitter = new vscode.EventEmitter<vscode.FileChangeEvent[]>();
  readonly onDidChangeFile = this.emitter.event;
  private readonly cache = new Map<string, { d: api.Drop; at: number }>();

  constructor(
    private readonly auth: HubAuth,
    private readonly changed: (base: string, d: api.Drop) => void,
  ) {}

  private ref(uri: vscode.Uri): DropRef {
    const r = parseDropUri(uri.path, uri.query);
    if (!r) {
      throw vscode.FileSystemError.FileNotFound(uri);
    }
    return r;
  }

  private async load(r: DropRef, fresh = false): Promise<api.Drop> {
    const key = `${r.base}/${r.id}`;
    const hit = this.cache.get(key);
    if (hit && !fresh && Date.now() - hit.at < 2000) {
      return hit.d;
    }
    const d = await this.auth.clientFor(r.base).drop(r.id);
    this.cache.set(key, { d, at: Date.now() });
    return d;
  }

  watch(): vscode.Disposable {
    return new vscode.Disposable(() => undefined);
  }

  async stat(uri: vscode.Uri): Promise<vscode.FileStat> {
    const r = this.ref(uri);
    const d = await this.load(r);
    if (!r.name) {
      return { type: vscode.FileType.Directory, ctime: d.created_ms, mtime: d.updated_ms, size: 0 };
    }
    const f = d.files.find((x) => x.name === r.name);
    if (f) {
      return { type: vscode.FileType.File, ctime: d.created_ms, mtime: d.updated_ms, size: f.size };
    }
    if (d.files.some((x) => x.name.startsWith(r.name + "/"))) {
      return { type: vscode.FileType.Directory, ctime: d.created_ms, mtime: d.updated_ms, size: 0 };
    }
    throw vscode.FileSystemError.FileNotFound(uri);
  }

  async readDirectory(uri: vscode.Uri): Promise<[string, vscode.FileType][]> {
    const r = this.ref(uri);
    const d = await this.load(r);
    const prefix = r.name ? r.name + "/" : "";
    const out = new Map<string, vscode.FileType>();
    for (const f of d.files.filter((x) => x.name.startsWith(prefix))) {
      const rest = f.name.slice(prefix.length);
      const [head, ...tail] = rest.split("/");
      out.set(head, tail.length ? vscode.FileType.Directory : vscode.FileType.File);
    }
    return [...out];
  }

  createDirectory(): void {
    throw vscode.FileSystemError.NoPermissions("A drop's folders come from its files' names.");
  }

  async readFile(uri: vscode.Uri): Promise<Uint8Array> {
    const r = this.ref(uri);
    const d = await this.load(r, true);
    const f = d.files.find((x) => x.name === r.name);
    if (!f) {
      throw vscode.FileSystemError.FileNotFound(uri);
    }
    // Text up to 512 KiB comes with the drop; anything else from its raw address.
    if (f.content !== undefined && f.content !== null) {
      return new TextEncoder().encode(f.content);
    }
    return this.auth.clientFor(r.base).download(f.raw_url);
  }

  async writeFile(uri: vscode.Uri, content: Uint8Array, options: { create: boolean; overwrite: boolean }): Promise<void> {
    const r = this.ref(uri);
    const d = await this.load(r);
    const exists = d.files.some((x) => x.name === r.name);
    if (!exists && !options.create) {
      throw vscode.FileSystemError.FileNotFound(uri);
    }
    if (exists && !options.overwrite) {
      throw vscode.FileSystemError.FileExists(uri);
    }
    const text = new TextDecoder("utf-8", { fatal: true }).decode(content);
    const next = await this.auth.clientFor(r.base).editDrop(r.id, { files: [{ name: r.name, content: text }], message: `${exists ? "Edit" : "Add"} ${r.name}` }).catch((e: Error) => {
      throw vscode.FileSystemError.Unavailable(e.message);
    });
    this.cache.set(`${r.base}/${r.id}`, { d: next, at: Date.now() });
    this.changed(r.base, next);
    this.emitter.fire([{ type: exists ? vscode.FileChangeType.Changed : vscode.FileChangeType.Created, uri }]);
  }

  async delete(uri: vscode.Uri): Promise<void> {
    const r = this.ref(uri);
    if (!r.name) {
      throw vscode.FileSystemError.NoPermissions("Delete the drop from the Drops view.");
    }
    const next = await this.auth.clientFor(r.base).editDrop(r.id, { files: [{ name: r.name, content: null }], message: `Remove ${r.name}` });
    this.cache.set(`${r.base}/${r.id}`, { d: next, at: Date.now() });
    this.changed(r.base, next);
    this.emitter.fire([{ type: vscode.FileChangeType.Deleted, uri }]);
  }

  rename(): void {
    throw vscode.FileSystemError.NoPermissions("Renaming a drop's file is not supported yet; add it under the new name and remove the old.");
  }
}

/** The hub to make a drop on: the only one signed in to, else ask. */
async function pickHub(auth: HubAuth): Promise<string | undefined> {
  const hubs = auth.all().map((s) => s.base);
  if (hubs.length === 0) {
    void vscode.window.showWarningMessage("OxygenHub: sign in to a hub first.", "Sign In").then((p) => p && vscode.commands.executeCommand("oxygenhub.signIn"));
    return undefined;
  }
  return hubs.length === 1 ? hubs[0] : vscode.window.showQuickPick(hubs, { placeHolder: "Make the drop on" });
}

/** Ask for a title (prefilled) and whether the drop is public or secret. */
async function askTitleAndVisibility(value: string): Promise<{ title: string; secret: boolean } | undefined> {
  const title = await vscode.window.showInputBox({ prompt: "Drop title", value, validateInput: (v) => (v.length > 200 ? "At most 200 characters" : undefined) });
  if (title === undefined) {
    return undefined;
  }
  const remembered = vscode.workspace.getConfiguration("oxygenhub").get<string>("dropVisibility", "secret");
  const options = [
    { label: "$(lock) Secret", description: "unlisted: anyone with its address can read it", secret: true },
    { label: "$(globe) Public", description: "listed on your Drops page", secret: false },
  ].sort((a) => ((a.secret ? "secret" : "public") === remembered ? -1 : 1));
  const pick = await vscode.window.showQuickPick(options, { placeHolder: "Who can find it" });
  return pick ? { title, secret: pick.secret } : undefined;
}

/** A new drop is made: say so, copy its address if asked, show it in the view. */
async function announce(drops: DropsProvider, base: string, d: api.Drop): Promise<void> {
  drops.remember(base, d);
  const copy = vscode.workspace.getConfiguration("oxygenhub").get<boolean>("copyDropLink", true);
  if (copy) {
    await vscode.env.clipboard.writeText(d.url);
  }
  const pick = await vscode.window.showInformationMessage(`OxygenHub: dropped "${d.title || d.id}"${copy ? "; its address is copied" : ""}.`, "Open on Hub", ...(copy ? [] : ["Copy Link"]));
  if (pick === "Open on Hub") {
    void vscode.env.openExternal(vscode.Uri.parse(d.url));
  } else if (pick === "Copy Link") {
    await vscode.env.clipboard.writeText(d.url);
  }
}

/** Share as a Drop from the editor: the selection (its lines), or the whole document when nothing is selected. */
export async function shareSelection(auth: HubAuth, drops: DropsProvider, uri?: vscode.Uri): Promise<void> {
  const editor = vscode.window.activeTextEditor;
  const doc = editor && (!uri || editor.document.uri.toString() === uri.toString()) ? editor.document : uri ? await vscode.workspace.openTextDocument(uri) : undefined;
  if (!doc) {
    void vscode.window.showWarningMessage("OxygenHub: open a file, or select some code, to share as a drop.");
    return;
  }
  const sel = editor && editor.document === doc ? editor.selection : undefined;
  const whole = !sel || sel.isEmpty;
  const name = snippetName(doc.isUntitled ? undefined : doc.fileName, doc.languageId);
  let content = doc.getText();
  let start = 1;
  let end = doc.lineCount;
  if (!whole && sel) {
    const last = sel.end.character === 0 && sel.end.line > sel.start.line ? sel.end.line - 1 : sel.end.line;
    content = dedent(doc.getText(new vscode.Range(sel.start.line, 0, last, doc.lineAt(last).text.length))) + "\n";
    [start, end] = [sel.start.line + 1, last + 1];
  }
  const base = await pickHub(auth);
  if (!base) {
    return;
  }
  const asked = await askTitleAndVisibility(snippetTitle(name, start, end, whole));
  if (!asked) {
    return;
  }
  try {
    const d = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "OxygenHub: dropping…" }, () =>
      auth.clientFor(base).createDrop({ title: asked.title, secret: asked.secret, files: [{ name, content }] }),
    );
    await announce(drops, base, d);
  } catch (e) {
    void vscode.window.showErrorMessage(`OxygenHub: ${(e as Error).message}`);
  }
}

/** Share files (the Explorer's selection, folders' files included) as one drop. */
export async function shareFiles(auth: HubAuth, drops: DropsProvider, uri?: vscode.Uri, uris?: vscode.Uri[]): Promise<void> {
  let picked = uris && uris.length ? uris : uri ? [uri] : vscode.window.activeTextEditor ? [vscode.window.activeTextEditor.document.uri] : [];
  if (!picked.length) {
    picked = (await vscode.window.showOpenDialog({ canSelectMany: true, openLabel: "Share as a Drop" })) ?? [];
  }
  const files: vscode.Uri[] = [];
  for (const u of picked) {
    const stat = await vscode.workspace.fs.stat(u);
    if (stat.type & vscode.FileType.Directory) {
      files.push(...(await vscode.workspace.findFiles(new vscode.RelativePattern(u, "**/*"), "**/{.oxy,.git,node_modules,target}/**", 51)));
    } else {
      files.push(u);
    }
  }
  if (!files.length) {
    return;
  }
  if (files.length > 50) {
    void vscode.window.showWarningMessage("OxygenHub: a drop takes at most 50 files; push larger sets with oxy.");
    return;
  }
  const names = shareNames(files.map((f) => f.path));
  const contents: api.NewDropFile[] = [];
  for (const [i, f] of files.entries()) {
    const bytes = await vscode.workspace.fs.readFile(f);
    if (bytes.length > 1 << 20) {
      void vscode.window.showWarningMessage(`OxygenHub: ${names[i]} is larger than 1 MiB; a drop's files are at most that.`);
      return;
    }
    try {
      contents.push({ name: names[i], content: new TextDecoder("utf-8", { fatal: true }).decode(bytes) });
    } catch {
      void vscode.window.showWarningMessage(`OxygenHub: ${names[i]} is not text; a drop shares text files.`);
      return;
    }
  }
  const base = await pickHub(auth);
  if (!base) {
    return;
  }
  const asked = await askTitleAndVisibility(names.length === 1 ? names[0] : `${names[0]} and ${names.length - 1} more`);
  if (!asked) {
    return;
  }
  try {
    const d = await vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "OxygenHub: dropping…" }, () =>
      auth.clientFor(base).createDrop({ title: asked.title, secret: asked.secret, files: contents }),
    );
    await announce(drops, base, d);
  } catch (e) {
    void vscode.window.showErrorMessage(`OxygenHub: ${(e as Error).message}`);
  }
}

/** The drop commands that act on the view's items. */
export function registerDropCommands(auth: HubAuth, drops: DropsProvider): vscode.Disposable[] {
  const client = (base: string) => auth.clientFor(base);
  const guard =
    <A extends unknown[]>(f: (...a: A) => Promise<unknown>) =>
    async (...a: A) => {
      try {
        await f(...a);
      } catch (e) {
        void vscode.window.showErrorMessage(`OxygenHub: ${(e as Error).message}`);
      }
    };
  const open = async (base: string, d: api.Drop) => {
    drops.remember(base, d);
    if (d.files.length) {
      await vscode.window.showTextDocument(dropUri({ base, id: d.id, name: d.files[0].name }), { preview: false });
    }
  };
  return [
    vscode.commands.registerCommand("oxygenhub.dropsRefresh", () => drops.refresh()),
    vscode.commands.registerCommand(
      "oxygenhub.newDrop",
      guard(async () => {
        const base = await pickHub(auth);
        if (!base) {
          return;
        }
        const name = await vscode.window.showInputBox({ prompt: "First file's name", value: "notes.md", validateInput: (v) => (v.trim() ? undefined : "Every file needs a name") });
        if (!name) {
          return;
        }
        const asked = await askTitleAndVisibility("");
        if (!asked) {
          return;
        }
        const d = await client(base).createDrop({ title: asked.title, secret: asked.secret, files: [{ name: name.trim(), content: "" }] });
        drops.refresh();
        await open(base, d);
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.openDrop",
      guard(async () => {
        const text = await vscode.window.showInputBox({ prompt: "A drop's address or id", placeHolder: "https://hub/OWNER/drops/ID", validateInput: (v) => (dropIdOf(v) ? undefined : "A drop's page or its 24-digit id") });
        if (!text) {
          return;
        }
        const id = dropIdOf(text)!;
        const pasted = dropBaseOf(text);
        const base = pasted && auth.bases().includes(pasted) ? pasted : pasted ?? (await pickHub(auth));
        if (!base) {
          return;
        }
        await open(base, await client(base).drop(id));
      }),
    ),
    vscode.commands.registerCommand("oxygenhub.openDropOnHub", (n: DropNode) => vscode.env.openExternal(vscode.Uri.parse(n.d.url))),
    vscode.commands.registerCommand("oxygenhub.copyDropLink", async (n: DropNode) => {
      await vscode.env.clipboard.writeText(n.d.url);
      vscode.window.setStatusBarMessage("$(link) Drop address copied", 3000);
    }),
    vscode.commands.registerCommand("oxygenhub.copyDropClone", async (n: DropNode) => {
      await vscode.env.clipboard.writeText(`oxy clone ${n.d.clone_url}`);
      vscode.window.setStatusBarMessage("$(terminal) oxy clone command copied", 3000);
    }),
    vscode.commands.registerCommand("oxygenhub.copyDropEmbed", async (n: DropNode) => {
      await vscode.env.clipboard.writeText(embedSnippet(n.d));
      vscode.window.setStatusBarMessage("$(code) Embed HTML copied", 3000);
    }),
    vscode.commands.registerCommand(
      "oxygenhub.cloneDrop",
      guard(async (n: DropNode) => {
        const parent = await vscode.window.showOpenDialog({ canSelectFolders: true, canSelectFiles: false, openLabel: "Clone Here" });
        if (!parent?.[0]) {
          return;
        }
        const t = vscode.window.createTerminal({ name: "OxygenHub", cwd: parent[0].fsPath });
        t.show();
        t.sendText(`oxy clone ${n.d.clone_url} drop-${n.d.id.slice(0, 8)}`);
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.editDrop",
      guard(async (n: DropNode) => {
        const title = await vscode.window.showInputBox({ prompt: "Title", value: n.d.title });
        if (title === undefined) {
          return;
        }
        const description = await vscode.window.showInputBox({ prompt: "Description", value: n.d.description });
        if (description === undefined) {
          return;
        }
        await client(n.base).editDrop(n.d.id, { title, description });
        drops.refresh();
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.toggleDropVisibility",
      guard(async (n: DropNode) => {
        const secret = n.d.visibility !== "secret";
        await client(n.base).editDrop(n.d.id, { secret });
        drops.refresh();
        vscode.window.setStatusBarMessage(secret ? "$(lock) The drop is secret now" : "$(globe) The drop is public now", 3000);
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.addDropFile",
      guard(async (n: DropNode) => {
        const name = await vscode.window.showInputBox({ prompt: `New file in "${n.d.title || n.d.id}"`, validateInput: (v) => (!v.trim() ? "Every file needs a name" : n.d.files.some((f) => f.name === v.trim()) ? "The drop has a file by that name" : undefined) });
        if (!name) {
          return;
        }
        await client(n.base).editDrop(n.d.id, { files: [{ name: name.trim(), content: "" }], message: `Add ${name.trim()}` });
        drops.refresh();
        await vscode.window.showTextDocument(dropUri({ base: n.base, id: n.d.id, name: name.trim() }), { preview: false });
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.deleteDropFile",
      guard(async (n: DropFileNode) => {
        if (n.d.files.length === 1) {
          void vscode.window.showWarningMessage("OxygenHub: a drop keeps at least one file; delete the drop instead.");
          return;
        }
        const ok = await vscode.window.showWarningMessage(`Remove ${n.f.name} from the drop?`, { modal: true, detail: "Its history keeps it." }, "Remove");
        if (ok) {
          await client(n.base).editDrop(n.d.id, { files: [{ name: n.f.name, content: null }], message: `Remove ${n.f.name}` });
          drops.refresh();
        }
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.deleteDrop",
      guard(async (n: DropNode) => {
        const ok = await vscode.window.showWarningMessage(`Delete the drop "${n.d.title || n.d.id}"?`, { modal: true, detail: "It and its history are gone for good, and its address stops working." }, "Delete");
        if (ok) {
          await client(n.base).deleteDrop(n.d.id);
          drops.forget(n.base, n.d.id);
        }
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.forkDrop",
      guard(async (n: DropNode) => {
        const d = await client(n.base).forkDrop(n.d.id);
        drops.refresh();
        await open(n.base, d);
        vscode.window.setStatusBarMessage(`$(repo-forked) Forked "${n.d.title || n.d.id}"`, 3000);
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.starDrop",
      guard(async (n: DropNode) => {
        const s = await client(n.base).starDrop(n.d.id, true);
        drops.remember(n.base, { ...n.d, ...s });
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.unstarDrop",
      guard(async (n: DropNode) => {
        const s = await client(n.base).starDrop(n.d.id, false);
        drops.remember(n.base, { ...n.d, ...s });
      }),
    ),
    vscode.commands.registerCommand(
      "oxygenhub.dropComments",
      guard(async (n: DropNode) => {
        const c = client(n.base);
        const me = (await c.me()).username;
        const comments = await c.dropComments(n.d.id);
        type Item = vscode.QuickPickItem & { add?: boolean; comment?: api.DropComment };
        const items: Item[] = [{ label: "$(comment) Add a comment…", add: true }, ...comments.map((x) => ({ ...commentLine(x), comment: x }))];
        const pick = await vscode.window.showQuickPick(items, { placeHolder: `${comments.length} comment${comments.length === 1 ? "" : "s"} on "${n.d.title || n.d.id}"`, matchOnDetail: true });
        if (pick?.add) {
          const body = await vscode.window.showInputBox({ prompt: "Comment (Markdown)" });
          if (body?.trim()) {
            await c.commentDrop(n.d.id, body);
            vscode.window.setStatusBarMessage("$(comment) Commented", 3000);
          }
        } else if (pick?.comment) {
          const mayDelete = pick.comment.author === me || n.d.owner === me;
          const act = await vscode.window.showInformationMessage(`${pick.comment.author}: ${pick.comment.body}`, ...(mayDelete ? ["Delete Comment"] : []));
          if (act === "Delete Comment") {
            await c.deleteDropComment(n.d.id, pick.comment.id);
          }
        }
      }),
    ),
  ];
}