import AstPath from "../common/ast-path.js";
import { cursor } from "../document/builders.js";
import { inheritLabel } from "../document/utils.js";
import { attachComments } from "./comments/attach.js";
import { ensureAllCommentsPrinted, printComments } from "./comments/print.js";
import createPrintPreCheckFunction from "./create-print-pre-check-function.js";
import { printEmbeddedLanguages } from "./multiparser.js";
import printIgnored from "./print-ignored.js";

/**
 * Takes an abstract syntax tree (AST) and recursively converts it to a
 * document (series of printing primitives).
 *
 * This is done by descending down the AST recursively. The recursion
 * involves two functions that call each other:
 *
 * 1. mainPrint(), which is defined as an inner function here.
 *    It basically takes care of node caching.
 * 2. callPluginPrintFunction(), which checks for some options, and
 *    ultimately calls the print() function provided by the plugin.
 *
 * The plugin function will call mainPrint() again for child nodes
 * of the current node. mainPrint() will do its housekeeping, then call
 * the plugin function again, and so on.
 *
 * All the while, these functions pass a "path" variable around, which
 * is a stack-like data structure (AstPath) that maintains the current
 * state of the recursion. It is called "path", because it represents
 * the path to the current node through the Abstract Syntax Tree.
 */
async function printAstToDoc(ast, options) {
  ({ ast } = await prepareToPrint(ast, options));

  const cache = new Map();
  const path = new AstPath(ast);

  const ensurePrintingNode = createPrintPreCheckFunction(options);
  const embeds = new Map();

  await printEmbeddedLanguages(path, mainPrint, options, printAstToDoc, embeds);

  // Only the root call of the print method is awaited.
  // This is done to make things simpler for plugins that don't use recursive printing.
  const doc = await callPluginPrintFunction(
    path,
    options,
    mainPrint,
    undefined,
    embeds,
  );

  ensureAllCommentsPrinted(options);

  return doc;

  function mainPrint(selector, args) {
    if (selector === undefined || selector === path) {
      return mainPrintInternal(args);
    }

    if (Array.isArray(selector)) {
      return path.call(() => mainPrintInternal(args), ...selector);
    }

    return path.call(() => mainPrintInternal(args), selector);
  }

  function mainPrintInternal(args) {
    ensurePrintingNode(path);

    const value = path.node;

    if (value === undefined || value === null) {
      return "";
    }

    const shouldCache =
      value && typeof value === "object" && args === undefined;

    if (shouldCache && cache.has(value)) {
      return cache.get(value);
    }

    const doc = callPluginPrintFunction(path, options, mainPrint, args, embeds);

    if (shouldCache) {
      cache.set(value, doc);
    }

    return doc;
  }
}

function callPluginPrintFunction(path, options, printPath, args, embeds) {
  const { node } = path;
  const { printer } = options;

  let doc;

  // Escape hatch
  if (printer.hasPrettierIgnore?.(path)) {
    doc = printIgnored(path, options);
  } else if (embeds.has(node)) {
    doc = embeds.get(node);
  } else {
    doc = printer.print(path, options, printPath, args);
  }

  if (node === options.cursorNode) {
    doc = inheritLabel(doc, (doc) => [cursor, doc, cursor]);
  }

  // We let JSXElement print its comments itself because it adds () around
  // UnionTypeAnnotation has to align the child without the comments
  if (
    printer.printComment &&
    (!printer.willPrintOwnComments ||
      !printer.willPrintOwnComments(path, options))
  ) {
    // printComments will call the plugin print function and check for
    // comments to print
    doc = printComments(path, doc, options);
  }

  return doc;
}

async function prepareToPrint(ast, options) {
  const comments = ast.comments ?? [];
  options[Symbol.for("comments")] = comments;
  options[Symbol.for("tokens")] = ast.tokens ?? [];
  // For JS printer to ignore attached comments
  options[Symbol.for("printedComments")] = new Set();

  attachComments(ast, options);

  const {
    printer: { preprocess },
  } = options;

  ast = preprocess ? await preprocess(ast, options) : ast;

  return { ast, comments };
}

export { prepareToPrint, printAstToDoc };