import { isMap, isNode } from '../nodes/Node.mjs';
import { Scalar } from '../nodes/Scalar.mjs';
import { resolveBlockMap } from './resolve-block-map.mjs';
import { resolveBlockSeq } from './resolve-block-seq.mjs';
import { resolveFlowCollection } from './resolve-flow-collection.mjs';

function composeCollection(CN, ctx, token, tagToken, onError) {
  let coll;
  switch (token.type) {
    case 'block-map':
      {
        coll = resolveBlockMap(CN, ctx, token, onError);
        break;
      }
    case 'block-seq':
      {
        coll = resolveBlockSeq(CN, ctx, token, onError);
        break;
      }
    case 'flow-collection':
      {
        coll = resolveFlowCollection(CN, ctx, token, onError);
        break;
      }
  }
  if (!tagToken) return coll;
  const tagName = ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
  if (!tagName) return coll;
  // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
  const Coll = coll.constructor;
  if (tagName === '!' || tagName === Coll.tagName) {
    coll.tag = Coll.tagName;
    return coll;
  }
  const expType = isMap(coll) ? 'map' : 'seq';
  let tag = ctx.schema.tags.find(t => t.collection === expType && t.tag === tagName);
  if (!tag) {
    const kt = ctx.schema.knownTags[tagName];
    if (kt && kt.collection === expType) {
      ctx.schema.tags.push(Object.assign({}, kt, {
        default: false
      }));
      tag = kt;
    } else {
      onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
      coll.tag = tagName;
      return coll;
    }
  }
  const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
  const node = isNode(res) ? res : new Scalar(res);
  node.range = coll.range;
  node.tag = tagName;
  if (tag?.format) node.format = tag.format;
  return node;
}

export { composeCollection };
