import { Editor } from "editor/editor";
import { marks } from "editor/types/marks";
import { blocks, li, EditorBlock } from "editor/types/blocks";
import { parentBlocks } from "editor/types/parentBlocks";
import { multimedia } from "editor/types/multimedia";
import {
  blockNames,
  parentBlockNames,
  safeGetRangeAt,
  safeGetSelection,
} from "editor/utils";

export interface EditorNode {
  selector: string;
  // la string es el nombre en la gran lista de types O 'text'
  // XXX: esto es un hack para no poner EditorNode dentro de EditorNode,
  // quizás podemos hacer que esto sea una función que retorna bool
  allowedChildren: string[] | "ignore-children";

  // * si es 'do-nothing', no hace nada si está vacío (esto es para cuando
  //   permitís 'text' entonces se puede tipear adentro, ej: párrafo vacío)
  // * si es 'remove', sacamos el coso si está vacío.
  //   ej: strong: { handleNothing: 'remove' }
  // * si es un block, insertamos el bloque y movemos la selección ahí
  //   ej: ul: { handleNothing: li }
  handleEmpty: "do-nothing" | "remove" | EditorBlock;

  // esta función puede ser llamada para cosas que no necesariamente sea la
  // creación del nodo con el botón; por ejemplo, al intentar recuperar
  // el formato. esto es importante por que, por ejemplo, no deberíamos
  // cambiar la selección acá.
  create: (editor: Editor) => HTMLElement;

  onClick?: (editor: Editor, target: Element) => void;
}

export const types: { [propName: string]: EditorNode } = {
  ...marks,
  ...blocks,
  li,
  ...parentBlocks,
  contentEl: {
    selector: ".editor-content",
    allowedChildren: [...blockNames, ...parentBlockNames, "multimedia"],
    handleEmpty: blocks.paragraph,
    create: () => {
      throw new Error("se intentó crear contentEl");
    },
  },
  br: {
    selector: "br",
    allowedChildren: [],
    handleEmpty: "do-nothing",
    create: () => {
      throw new Error("se intentó crear br");
    },
  },
  multimedia,
};

export function getType(
  node: Element
): { typeName: string; type: EditorNode } | null {
  for (let [typeName, type] of Object.entries(types)) {
    if (node.matches(type.selector)) {
      return { typeName, type };
    }
  }

  return null;
}

// encuentra el primer pariente que pueda tener al type, y retorna un array
// donde
//   array[0] = elemento que matchea el type
//   array[array.len - 1] = primer elemento seleccionado
export function getValidParentInSelection(args: {
  editor: Editor;
  type: string;
}): Element[] {
  const sel = safeGetSelection(args.editor);
  if (!sel) throw new Error("No se donde insertar esto");
  const range = safeGetRangeAt(sel);
  if (!range) throw new Error("No se donde insertar esto");

  let list: Element[] = [];

  if (!sel.anchorNode) {
    throw new Error("No se donde insertar esto");
  } else if (sel.anchorNode instanceof Element) {
    list = [sel.anchorNode];
  } else if (sel.anchorNode.parentElement) {
    list = [sel.anchorNode.parentElement];
  } else {
    throw new Error("No se donde insertar esto");
  }

  while (true) {
    const el = list[0];
    if (!args.editor.contentEl.contains(el) && el != args.editor.contentEl)
      throw new Error("No se donde insertar esto");
    const type = getType(el);

    if (type) {
      //if (type.typeName === 'contentEl') break
      //if (parentBlockNames.includes(type.typeName)) break
      if (
        type.type.allowedChildren instanceof Array &&
        type.type.allowedChildren.includes(args.type)
      )
        break;
    }
    if (el.parentElement) {
      list = [el.parentElement, ...list];
    } else {
      throw new Error("No se donde insertar esto");
    }
  }

  return list;
}

export function getValidChildren(node: Element, type: EditorNode): Node[] {
  if (type.allowedChildren === "ignore-children")
    throw new Error(
      "se llamó a getValidChildren con un type que no lo permite!"
    );
  return [...node.childNodes].filter((n) => {
    // si permite texto y esto es un texto, es válido
    if (n.nodeType === Node.TEXT_NODE)
      return type.allowedChildren.includes("text") && n.textContent?.length;

    // si no es un elemento, no es válido
    if (!(n instanceof Element)) return false;

    const t = getType(n);
    if (!t) return false;
    return type.allowedChildren.includes(t.typeName);
  });
}