import { existsSync } from "@std/fs";

export function print(s: string = "", nl = true) {
  const out = nl ? s + "\n" : s;
  Deno.stdout.writeSync(new TextEncoder().encode(out));
}

export function moveFile(
  origin: string,
  destination: string,
  clobber: boolean = false,
) {
  if (existsSync(destination)) {
    if (clobber) {
      Deno.removeSync(destination, { recursive: true });
    } else {
      throw new Error(`file ${destination} already exists`);
    }
  }
  Deno.renameSync(origin, destination);
}

let terminalMarked: import("marked").Marked | null = null;
let htmlMarked: import("marked").Marked | null = null;
let wrapWidth: number | null = null;

async function getTerminalMarked() {
  if (terminalMarked == null) {
    const { Marked } = await import("marked");
    const { markedTerminal } = await import("marked-terminal");
    terminalMarked = new Marked();
    terminalMarked.use(markedTerminal());
  }
  return terminalMarked;
}

async function getHtmlMarked() {
  if (htmlMarked == null) {
    const { Marked } = await import("marked");
    htmlMarked = new Marked();
    htmlMarked.use({ gfm: false });
  }
  return htmlMarked;
}

function getWrapWidth() {
  if (wrapWidth == null) {
    wrapWidth = Math.min(Deno.consoleSize().columns, 80);
  }
  return wrapWidth;
}

export async function renderMarkdown(
  s: string,
  format: "terminal" | "html",
): Promise<string> {
  switch (format) {
    case "terminal": {
      const marked = await getTerminalMarked();
      const wrapAnsi = (await import("wrap-ansi")).default;
      return wrapAnsi(marked.parse(s) as string, getWrapWidth());
    }
    case "html": {
      const marked = await getHtmlMarked();
      return marked.parse(s) as string;
    }
  }
}

export function truncateString(
  s: string,
  length: number,
  placeholder: string = "...",
): string {
  if (s.length < length) return s;
  const idx = s.slice(0, length - placeholder.length - 1).trimEnd().lastIndexOf(
    " ",
  );
  if (idx > 0) {
    return s.slice(0, idx) + placeholder;
  } else {
    return s.slice(0, length - placeholder.length) + placeholder;
  }
}

export function ensureSuffix(s: string, suffix: string): string {
  return s.endsWith(suffix) ? s : s + suffix;
}