import JSONQuery from '@sagold/json-query';
import { JSONSchema } from '@squiz/json-schema-library';
import { ComponentInputSchema } from '../..';
import {
  BaseFormattedNodes,
  ComponentNode,
  FormattedText,
  FormattedTextFragment,
  FormattedTextTag,
  HigherOrderFormattedNodes,
  TextNode,
} from './formattedText';
import { FORMATTED_TEXT_SCHEMA_ID } from './formattedTextConstants';

export { FORMATTED_TEXT_SCHEMA_ID };

export interface FormattedNodeWithChildren {
  children: FormattedNode[];
}

type FormattedNode = { type: string };
type ResolutionOutput<T extends FormattedNode> = string | T;
type Resolver<Nodes extends FormattedNode, Output extends ResolutionOutput<FormattedNode>> = (
  node: Nodes,
  blockIndex?: number,
) => Promise<Output>;
export type ResolverConfig<Nodes extends FormattedNode, Output extends ResolutionOutput<FormattedNode>> = {
  [N in Nodes as N['type']]: Resolver<N, Output>;
} & { default?: Resolver<FormattedNode, Output> };

export type ResolvedChildNode<
  DEFAULT_NODES extends FormattedNode,
  CHILD_NODE extends ResolutionOutput<FormattedNode>,
> = DEFAULT_NODES extends {
  children: any[];
}
  ? Omit<DEFAULT_NODES, 'children'> & { children: CHILD_NODE[] }
  : DEFAULT_NODES;

export type FullyResolvedNodes = ResolvedChildNode<
  TextNode | FormattedTextTag | FormattedTextFragment | ComponentNode,
  string
>;
export type BaseResolvedNodes = ResolvedChildNode<BaseFormattedNodes, BaseFormattedNodes>;
export type HigherOrderResolvedNodes = ResolvedChildNode<HigherOrderFormattedNodes, BaseResolvedNodes>;

export type HigherOrderFormattedNodesMap = ResolverConfig<HigherOrderResolvedNodes, BaseResolvedNodes>;
export type FullyResolvedNodesMap = ResolverConfig<FullyResolvedNodes, string>;

interface ResolveOptions<O extends ResolutionOutput<FormattedNode>> {
  withJoin?: string;
  handleError?: (error: unknown, pointer: string) => O | never;
}

export async function resolveFormattedTextNodes<O extends ResolutionOutput<FormattedNode>>(
  contentItem: any,
  contentSchema: JSONSchema,
  resolvers: Partial<ResolverConfig<any, O>>,
  { withJoin, handleError }: ResolveOptions<O> = {},
) {
  const resolvedDataSetters: Promise<(newItem: typeof contentItem) => typeof contentItem>[] = [];
  ComponentInputSchema.each(
    contentItem,
    (schema, data, pointer) => {
      if (schema.type === 'FormattedText' || schema.$id === FORMATTED_TEXT_SCHEMA_ID) {
        if (!Array.isArray(data)) {
          return;
        }
        const formattedText = data as FormattedText;
        const textResolvers = formattedText.map((t) => resolveFormattedText(t, resolvers));

        const resolvedItem = Promise.all(textResolvers)
          .catch((error) => {
            if (handleError) {
              return [handleError(error, pointer)];
            }
            return [{ type: 'text', value: 'Error resolving formatted text at ' + pointer + ': ' + error?.message }];
          })
          .then((resolvedData: unknown[]) => (newItem: typeof contentItem) => {
            let joinedData: string | null = null;
            if (resolvedData.every((d): d is string => typeof d === 'string') && typeof withJoin === 'string') {
              joinedData = resolvedData.join(withJoin);
            }
            return JSONQuery.set(newItem, pointer, joinedData ?? resolvedData);
          });

        resolvedDataSetters.push(resolvedItem);
      }
    },
    ComponentInputSchema.compileSchema(contentSchema),
  );

  for (const setResolvedData of await Promise.all(resolvedDataSetters)) {
    contentItem = setResolvedData(contentItem);
  }
  return contentItem;
}

export async function resolveFormattedText<I extends FormattedNode, RC extends Partial<ResolverConfig<any, any>>>(
  node: I,
  resolvers: RC,
  blockIndex?: number,
): Promise<RC extends Partial<ResolverConfig<any, infer O>> ? O : unknown> {
  if (shouldResolveChildren(node)) {
    const updatedChildren = await Promise.all(
      node.children.map((child) =>
        typeof child === 'string' ? child : resolveFormattedText(child, resolvers, blockIndex),
      ),
    );

    node = { ...node, children: updatedChildren };
  }

  const resolver = resolvers[node.type as keyof typeof resolvers] || resolvers['default'];
  if (resolver) {
    return await resolver(node, blockIndex);
  }

  return node as any;
}

function shouldResolveChildren<I extends FormattedNode>(node: I): node is I & { children: Array<ResolutionOutput<I>> } {
  return !!node && typeof node == 'object' && 'children' in node && Array.isArray(node.children);
}