import * as path from 'path';
import { red, blue, yellow, green } from 'colorette';
import { performance } from 'perf_hooks';
import {
  SpecVersion,
  BaseResolver,
  formatProblems,
  getTotals,
  detectSpec,
  bundleDocument,
  isRef,
} from '@redocly/openapi-core';
import { dequal } from '@redocly/openapi-core/lib/utils';
import {
  getFallbackApisOrExit,
  printExecutionTime,
  exitWithError,
  sortTopLevelKeysForOas,
  getAndValidateFileExtension,
  writeToFileByExtension,
} from '../utils/miscellaneous';
import { isObject, isString, keysOf } from '../utils/js-utils';
import { COMPONENTS, OPENAPI3_METHOD } from './split/types';
import { crawl, startsWithComponents } from './split';

import type { Document, Referenced } from '@redocly/openapi-core';
import type { BundleResult } from '@redocly/openapi-core/lib/bundle';
import type {
  Oas3Definition,
  Oas3_1Definition,
  Oas3Parameter,
  Oas3PathItem,
  Oas3Server,
  Oas3Tag,
} from '@redocly/openapi-core/lib/typings/openapi';
import type { StrictObject } from '@redocly/openapi-core/lib/utils';
import type { CommandArgs } from '../wrapper';
import type { VerifyConfigOptions } from '../types';

const Tags = 'tags';
const xTagGroups = 'x-tagGroups';
let potentialConflictsTotal = 0;

type JoinDocumentContext = {
  api: string;
  apiFilename: string;
  apiTitle?: string;
  tags: Oas3Tag[];
  potentialConflicts: any;
  tagsPrefix: string;
  componentsPrefix: string | undefined;
};

export type JoinOptions = {
  apis: string[];
  'prefix-tags-with-info-prop'?: string;
  'prefix-tags-with-filename'?: boolean;
  'prefix-components-with-info-prop'?: string;
  'without-x-tag-groups'?: boolean;
  output?: string;
} & VerifyConfigOptions;

export async function handleJoin({
  argv,
  config,
  version: packageVersion,
  collectSpecData,
}: CommandArgs<JoinOptions>) {
  const startedAt = performance.now();

  const {
    'prefix-components-with-info-prop': prefixComponentsWithInfoProp,
    'prefix-tags-with-filename': prefixTagsWithFilename,
    'prefix-tags-with-info-prop': prefixTagsWithInfoProp,
    'without-x-tag-groups': withoutXTagGroups,
    output,
  } = argv;

  const usedTagsOptions = [
    prefixTagsWithFilename && 'prefix-tags-with-filename',
    prefixTagsWithInfoProp && 'prefix-tags-with-info-prop',
    withoutXTagGroups && 'without-x-tag-groups',
  ].filter(Boolean);

  if (usedTagsOptions.length > 1) {
    return exitWithError(
      `You use ${yellow(usedTagsOptions.join(', '))} together.\nPlease choose only one!`
    );
  }

  const apis = await getFallbackApisOrExit(argv.apis, config);
  if (apis.length < 2) {
    return exitWithError(`At least 2 APIs should be provided.`);
  }

  const fileExtension = getAndValidateFileExtension(output || apis[0].path);
  const specFilename = output || `openapi.${fileExtension}`;

  const externalRefResolver = new BaseResolver(config.resolve);
  const documents = await Promise.all(
    apis.map(
      ({ path }) => externalRefResolver.resolveDocument(null, path, true) as Promise<Document>
    )
  );

  const decorators = new Set([
    ...Object.keys(config.styleguide.decorators.oas3_0),
    ...Object.keys(config.styleguide.decorators.oas3_1),
    ...Object.keys(config.styleguide.decorators.oas2),
  ]);
  config.styleguide.skipDecorators(Array.from(decorators));

  const preprocessors = new Set([
    ...Object.keys(config.styleguide.preprocessors.oas3_0),
    ...Object.keys(config.styleguide.preprocessors.oas3_1),
    ...Object.keys(config.styleguide.preprocessors.oas2),
  ]);
  config.styleguide.skipPreprocessors(Array.from(preprocessors));

  const bundleResults = await Promise.all(
    documents.map((document) =>
      bundleDocument({
        document,
        config: config.styleguide,
        externalRefResolver: new BaseResolver(config.resolve),
      }).catch((e) => {
        exitWithError(`${e.message}: ${blue(document.source.absoluteRef)}`);
      })
    )
  );

  for (const { problems, bundle: document } of bundleResults as BundleResult[]) {
    const fileTotals = getTotals(problems);
    if (fileTotals.errors) {
      formatProblems(problems, {
        totals: fileTotals,
        version: packageVersion,
      });
      exitWithError(
        `❌ Errors encountered while bundling ${blue(
          document.source.absoluteRef
        )}: join will not proceed.`
      );
    }
  }

  let oasVersion: SpecVersion | null = null;
  for (const document of documents) {
    try {
      const version = detectSpec(document.parsed);
      collectSpecData?.(document.parsed);
      if (version !== SpecVersion.OAS3_0 && version !== SpecVersion.OAS3_1) {
        return exitWithError(
          `Only OpenAPI 3.0 and OpenAPI 3.1 are supported: ${blue(document.source.absoluteRef)}.`
        );
      }

      oasVersion = oasVersion ?? version;
      if (oasVersion !== version) {
        return exitWithError(
          `All APIs must use the same OpenAPI version: ${blue(document.source.absoluteRef)}.`
        );
      }
    } catch (e) {
      return exitWithError(`${e.message}: ${blue(document.source.absoluteRef)}.`);
    }
  }

  const joinedDef: any = {};
  const potentialConflicts = {
    tags: {},
    paths: {},
    components: {},
    webhooks: {},
  };

  addInfoSectionAndSpecVersion(documents, prefixComponentsWithInfoProp);

  for (const document of documents) {
    const openapi = document.parsed;
    const { tags, info } = openapi;
    const api = path.relative(process.cwd(), document.source.absoluteRef);
    const apiFilename = getApiFilename(api);
    const tagsPrefix = prefixTagsWithFilename
      ? apiFilename
      : getInfoPrefix(info, prefixTagsWithInfoProp, 'tags');
    const componentsPrefix = getInfoPrefix(info, prefixComponentsWithInfoProp, COMPONENTS);

    if (openapi.hasOwnProperty('x-tagGroups')) {
      process.stderr.write(yellow(`warning: x-tagGroups at ${blue(api)} will be skipped \n`));
    }

    const context = {
      api,
      apiFilename,
      apiTitle: info?.title,
      tags,
      potentialConflicts,
      tagsPrefix,
      componentsPrefix,
    };
    if (tags) {
      populateTags(context);
    }
    collectServers(openapi);
    collectExternalDocs(openapi, context);
    collectPaths(openapi, context);
    collectComponents(openapi, context);
    collectWebhooks(oasVersion!, openapi, context);
    if (componentsPrefix) {
      replace$Refs(openapi, componentsPrefix);
    }
  }

  iteratePotentialConflicts(potentialConflicts, withoutXTagGroups);
  const noRefs = true;

  if (potentialConflictsTotal) {
    return exitWithError(`Please fix conflicts before running ${yellow('join')}.`);
  }

  writeToFileByExtension(sortTopLevelKeysForOas(joinedDef), specFilename, noRefs);

  printExecutionTime('join', startedAt, specFilename);

  function populateTags({
    api,
    apiFilename,
    apiTitle,
    tags,
    potentialConflicts,
    tagsPrefix,
    componentsPrefix,
  }: JoinDocumentContext) {
    if (!joinedDef.hasOwnProperty(Tags)) {
      joinedDef[Tags] = [];
    }
    if (!potentialConflicts.tags.hasOwnProperty('all')) {
      potentialConflicts.tags['all'] = {};
    }
    if (withoutXTagGroups && !potentialConflicts.tags.hasOwnProperty('description')) {
      potentialConflicts.tags['description'] = {};
    }
    for (const tag of tags) {
      const entrypointTagName = addPrefix(tag.name, tagsPrefix);
      if (tag.description) {
        tag.description = addComponentsPrefix(tag.description, componentsPrefix!);
      }

      const tagDuplicate = joinedDef.tags.find((t: Oas3Tag) => t.name === entrypointTagName);

      if (tagDuplicate && withoutXTagGroups) {
        // If tag already exist and `without-x-tag-groups` option,
        // check if description are different for potential conflicts warning.
        const isTagDescriptionNotEqual =
          tag.hasOwnProperty('description') && tagDuplicate.description !== tag.description;

        potentialConflicts.tags.description[entrypointTagName].push(
          ...(isTagDescriptionNotEqual ? [api] : [])
        );
      } else if (!tagDuplicate) {
        // Instead add tag to joinedDef if there no duplicate;
        tag['x-displayName'] = tag['x-displayName'] || tag.name;
        tag.name = entrypointTagName;
        joinedDef.tags.push(tag);

        if (withoutXTagGroups) {
          potentialConflicts.tags.description[entrypointTagName] = [api];
        }
      }

      if (!withoutXTagGroups) {
        const groupName = apiTitle || apiFilename;
        createXTagGroups(groupName);
        if (!tagDuplicate) {
          populateXTagGroups(entrypointTagName, getIndexGroup(groupName));
        }
      }

      const doesEntrypointExist =
        !potentialConflicts.tags.all[entrypointTagName] ||
        (potentialConflicts.tags.all[entrypointTagName] &&
          !potentialConflicts.tags.all[entrypointTagName].includes(api));
      potentialConflicts.tags.all[entrypointTagName] = [
        ...(potentialConflicts.tags.all[entrypointTagName] || []),
        ...(!withoutXTagGroups && doesEntrypointExist ? [api] : []),
      ];
    }
  }

  function getIndexGroup(name: string): number {
    return joinedDef[xTagGroups].findIndex((item: any) => item.name === name);
  }

  function createXTagGroups(name: string) {
    if (!joinedDef.hasOwnProperty(xTagGroups)) {
      joinedDef[xTagGroups] = [];
    }

    if (!joinedDef[xTagGroups].some((g: any) => g.name === name)) {
      joinedDef[xTagGroups].push({ name, tags: [] });
    }

    const indexGroup = getIndexGroup(name);

    if (!joinedDef[xTagGroups][indexGroup].hasOwnProperty(Tags)) {
      joinedDef[xTagGroups][indexGroup][Tags] = [];
    }
  }

  function populateXTagGroups(entrypointTagName: string, indexGroup: number) {
    if (
      !joinedDef[xTagGroups][indexGroup][Tags].find((t: Oas3Tag) => t.name === entrypointTagName)
    ) {
      joinedDef[xTagGroups][indexGroup][Tags].push(entrypointTagName);
    }
  }

  function collectServers(openapi: Oas3Definition | Oas3_1Definition) {
    const { servers } = openapi;
    if (servers) {
      if (!joinedDef.hasOwnProperty('servers')) {
        joinedDef['servers'] = [];
      }
      for (const server of servers) {
        if (!joinedDef.servers.some((s: any) => s.url === server.url)) {
          joinedDef.servers.push(server);
        }
      }
    }
  }

  function collectExternalDocs(
    openapi: Oas3Definition | Oas3_1Definition,
    { api }: JoinDocumentContext
  ) {
    const { externalDocs } = openapi;
    if (externalDocs) {
      if (joinedDef.hasOwnProperty('externalDocs')) {
        process.stderr.write(
          yellow(`warning: skip externalDocs from ${blue(path.basename(api))} \n`)
        );
        return;
      }
      joinedDef['externalDocs'] = externalDocs;
    }
  }

  function collectPaths(
    openapi: Oas3Definition | Oas3_1Definition,
    {
      apiFilename,
      apiTitle,
      api,
      potentialConflicts,
      tagsPrefix,
      componentsPrefix,
    }: JoinDocumentContext
  ) {
    const { paths } = openapi;
    const operationsSet = new Set(keysOf<typeof OPENAPI3_METHOD>(OPENAPI3_METHOD));
    if (paths) {
      if (!joinedDef.hasOwnProperty('paths')) {
        joinedDef['paths'] = {};
      }

      for (const path of keysOf(paths)) {
        if (!joinedDef.paths.hasOwnProperty(path)) {
          joinedDef.paths[path] = {};
        }
        if (!potentialConflicts.paths.hasOwnProperty(path)) {
          potentialConflicts.paths[path] = {};
        }

        const pathItem = paths[path] as Oas3PathItem;

        for (const field of keysOf(pathItem)) {
          if (operationsSet.has(field as OPENAPI3_METHOD)) {
            collectPathOperation(pathItem, path, field as OPENAPI3_METHOD);
          }
          if (field === 'servers') {
            collectPathServers(pathItem, path);
          }
          if (field === 'parameters') {
            collectPathParameters(pathItem, path);
          }
          if (typeof pathItem[field] === 'string') {
            collectPathStringFields(pathItem, path, field);
          }
        }
      }
    }

    function collectPathStringFields(
      pathItem: Oas3PathItem,
      path: string | number,
      field: keyof Oas3PathItem
    ) {
      const fieldValue = pathItem[field];
      if (
        joinedDef.paths[path].hasOwnProperty(field) &&
        joinedDef.paths[path][field] !== fieldValue
      ) {
        process.stderr.write(yellow(`warning: different ${field} values in ${path}\n`));
        return;
      }
      joinedDef.paths[path][field] = fieldValue;
    }

    function collectPathServers(pathItem: Oas3PathItem, path: string | number) {
      if (!pathItem.servers) {
        return;
      }

      if (!joinedDef.paths[path].hasOwnProperty('servers')) {
        joinedDef.paths[path].servers = [];
      }

      for (const server of pathItem.servers) {
        let isFoundServer = false;
        for (const pathServer of joinedDef.paths[path].servers) {
          if (pathServer.url === server.url) {
            if (!isServersEqual(pathServer, server)) {
              exitWithError(`Different server values for (${server.url}) in ${path}.`);
            }
            isFoundServer = true;
          }
        }

        if (!isFoundServer) {
          joinedDef.paths[path].servers.push(server);
        }
      }
    }

    function collectPathParameters(pathItem: Oas3PathItem, path: string | number) {
      if (!pathItem.parameters) {
        return;
      }
      if (!joinedDef.paths[path].hasOwnProperty('parameters')) {
        joinedDef.paths[path].parameters = [];
      }

      for (const parameter of pathItem.parameters as Referenced<Oas3Parameter>[]) {
        let isFoundParameter = false;

        for (const pathParameter of joinedDef.paths[path]
          .parameters as Referenced<Oas3Parameter>[]) {
          // Compare $ref only if both are reference objects
          if (isRef(pathParameter) && isRef(parameter)) {
            if (pathParameter['$ref'] === parameter['$ref']) {
              isFoundParameter = true;
            }
          }
          // Compare properties only if both are reference objects
          if (!isRef(pathParameter) && !isRef(parameter)) {
            if (pathParameter.name === parameter.name && pathParameter.in === parameter.in) {
              if (!dequal(pathParameter.schema, parameter.schema)) {
                exitWithError(`Different parameter schemas for (${parameter.name}) in ${path}.`);
              }
              isFoundParameter = true;
            }
          }
        }

        if (!isFoundParameter) {
          joinedDef.paths[path].parameters.push(parameter);
        }
      }
    }

    function collectPathOperation(
      pathItem: Oas3PathItem,
      path: string | number,
      operation: OPENAPI3_METHOD
    ) {
      const pathOperation = pathItem[operation];

      if (!pathOperation) {
        return;
      }

      joinedDef.paths[path][operation] = pathOperation;
      potentialConflicts.paths[path][operation] = [
        ...(potentialConflicts.paths[path][operation] || []),
        api,
      ];

      const { operationId } = pathOperation;

      if (operationId) {
        if (!potentialConflicts.paths.hasOwnProperty('operationIds')) {
          potentialConflicts.paths['operationIds'] = {};
        }
        potentialConflicts.paths.operationIds[operationId] = [
          ...(potentialConflicts.paths.operationIds[operationId] || []),
          api,
        ];
      }

      const { tags, security } = joinedDef.paths[path][operation];

      if (tags) {
        joinedDef.paths[path][operation].tags = tags.map((tag: string) =>
          addPrefix(tag, tagsPrefix)
        );
        populateTags({
          api,
          apiFilename,
          apiTitle,
          tags: formatTags(tags),
          potentialConflicts,
          tagsPrefix,
          componentsPrefix,
        });
      } else {
        joinedDef.paths[path][operation]['tags'] = [addPrefix('other', tagsPrefix || apiFilename)];
        populateTags({
          api,
          apiFilename,
          apiTitle,
          tags: formatTags(['other']),
          potentialConflicts,
          tagsPrefix: tagsPrefix || apiFilename,
          componentsPrefix,
        });
      }
      if (!security && openapi.hasOwnProperty('security')) {
        joinedDef.paths[path][operation]['security'] = addSecurityPrefix(
          openapi.security,
          componentsPrefix!
        );
      } else if (pathOperation.security) {
        joinedDef.paths[path][operation].security = addSecurityPrefix(
          pathOperation.security,
          componentsPrefix!
        );
      }
    }
  }

  function isServersEqual(serverOne: Oas3Server, serverTwo: Oas3Server) {
    if (serverOne.description === serverTwo.description) {
      return dequal(serverOne.variables, serverTwo.variables);
    }

    return false;
  }

  function collectComponents(
    openapi: Oas3Definition,
    { api, potentialConflicts, componentsPrefix }: JoinDocumentContext
  ) {
    const { components } = openapi;
    if (components) {
      if (!joinedDef.hasOwnProperty(COMPONENTS)) {
        joinedDef[COMPONENTS] = {};
      }
      for (const [component, componentObj] of Object.entries(components)) {
        if (!potentialConflicts[COMPONENTS].hasOwnProperty(component)) {
          potentialConflicts[COMPONENTS][component] = {};
          joinedDef[COMPONENTS][component] = {};
        }
        for (const item of Object.keys(componentObj)) {
          const componentPrefix = addPrefix(item, componentsPrefix!);
          potentialConflicts.components[component][componentPrefix] = [
            ...(potentialConflicts.components[component][item] || []),
            { [api]: componentObj[item] },
          ];
          joinedDef.components[component][componentPrefix] = componentObj[item];
        }
      }
    }
  }

  function collectWebhooks(
    oasVersion: SpecVersion,
    openapi: StrictObject<Oas3Definition | Oas3_1Definition>,
    {
      apiFilename,
      apiTitle,
      api,
      potentialConflicts,
      tagsPrefix,
      componentsPrefix,
    }: JoinDocumentContext
  ) {
    const webhooks = oasVersion === SpecVersion.OAS3_1 ? 'webhooks' : 'x-webhooks';
    const openapiWebhooks = openapi[webhooks];
    if (openapiWebhooks) {
      if (!joinedDef.hasOwnProperty(webhooks)) {
        joinedDef[webhooks] = {};
      }
      for (const webhook of Object.keys(openapiWebhooks)) {
        joinedDef[webhooks][webhook] = openapiWebhooks[webhook];

        if (!potentialConflicts.webhooks.hasOwnProperty(webhook)) {
          potentialConflicts.webhooks[webhook] = {};
        }
        for (const operation of Object.keys(openapiWebhooks[webhook])) {
          potentialConflicts.webhooks[webhook][operation] = [
            ...(potentialConflicts.webhooks[webhook][operation] || []),
            api,
          ];
        }
        for (const operationKey of Object.keys(joinedDef[webhooks][webhook])) {
          const { tags } = joinedDef[webhooks][webhook][operationKey];
          if (tags) {
            joinedDef[webhooks][webhook][operationKey].tags = tags.map((tag: string) =>
              addPrefix(tag, tagsPrefix)
            );
            populateTags({
              api,
              apiFilename,
              apiTitle,
              tags: formatTags(tags),
              potentialConflicts,
              tagsPrefix,
              componentsPrefix,
            });
          }
        }
      }
    }
  }

  function addInfoSectionAndSpecVersion(
    documents: any,
    prefixComponentsWithInfoProp: string | undefined
  ) {
    const firstApi = documents[0];
    const openapi = firstApi.parsed;
    const componentsPrefix = getInfoPrefix(openapi.info, prefixComponentsWithInfoProp, COMPONENTS);
    if (!openapi.openapi) exitWithError('Version of specification is not found.');
    if (!openapi.info) exitWithError('Info section is not found in specification.');
    if (openapi.info?.description) {
      openapi.info.description = addComponentsPrefix(openapi.info.description, componentsPrefix);
    }
    joinedDef.openapi = openapi.openapi;
    joinedDef.info = openapi.info;
  }
}

function doesComponentsDiffer(curr: object, next: object) {
  return !dequal(Object.values(curr)[0], Object.values(next)[0]);
}

function validateComponentsDifference(files: any) {
  let isDiffer = false;
  for (let i = 0, len = files.length; i < len; i++) {
    const next = files[i + 1];
    if (next && doesComponentsDiffer(files[i], next)) {
      isDiffer = true;
    }
  }
  return isDiffer;
}

function iteratePotentialConflicts(potentialConflicts: any, withoutXTagGroups?: boolean) {
  for (const group of Object.keys(potentialConflicts)) {
    for (const [key, value] of Object.entries(potentialConflicts[group])) {
      const conflicts = filterConflicts(value as object);
      if (conflicts.length) {
        if (group === COMPONENTS) {
          for (const [_, conflict] of Object.entries(conflicts)) {
            if (validateComponentsDifference(conflict[1])) {
              conflict[1] = conflict[1].map((c: string) => Object.keys(c)[0]);
              showConflicts(green(group) + ' => ' + key, [conflict]);
              potentialConflictsTotal += 1;
            }
          }
        } else {
          if (withoutXTagGroups && group === 'tags') {
            duplicateTagDescriptionWarning(conflicts);
          } else {
            potentialConflictsTotal += conflicts.length;
            showConflicts(green(group) + ' => ' + key, conflicts);
          }
        }

        if (group === 'tags' && !withoutXTagGroups) {
          prefixTagSuggestion(conflicts.length);
        }
      }
    }
  }
}

function duplicateTagDescriptionWarning(conflicts: [string, any][]) {
  const tagsKeys = conflicts.map(([tagName]) => `\`${tagName}\``);
  const joinString = yellow(', ');
  process.stderr.write(
    yellow(
      `\nwarning: ${tagsKeys.length} conflict(s) on the ${red(
        tagsKeys.join(joinString)
      )} tags description.\n`
    )
  );
}

function prefixTagSuggestion(conflictsLength: number) {
  process.stderr.write(
    green(
      `\n${conflictsLength} conflict(s) on tags.\nSuggestion: please use ${blue(
        'prefix-tags-with-filename'
      )}, ${blue('prefix-tags-with-info-prop')} or ${blue(
        'without-x-tag-groups'
      )} to prevent naming conflicts.\n\n`
    )
  );
}

function showConflicts(key: string, conflicts: any) {
  for (const [path, files] of conflicts) {
    process.stderr.write(yellow(`Conflict on ${key} : ${red(path)} in files: ${blue(files)} \n`));
  }
}

function filterConflicts(entities: object) {
  return Object.entries(entities).filter(([_, files]) => files.length > 1);
}

function getApiFilename(filePath: string) {
  return path.basename(filePath, path.extname(filePath));
}

function addPrefix(tag: string, tagsPrefix: string) {
  return tagsPrefix ? tagsPrefix + '_' + tag : tag;
}

function formatTags(tags: string[]) {
  return tags.map((tag: string) => ({ name: tag }));
}

function addComponentsPrefix(description: string, componentsPrefix: string) {
  return description.replace(/"(#\/components\/.*?)"/g, (match) => {
    const componentName = path.basename(match);
    return match.replace(componentName, addPrefix(componentName, componentsPrefix));
  });
}

function addSecurityPrefix(security: any, componentsPrefix: string) {
  return componentsPrefix
    ? security?.map((s: any) => {
        const joinedSecuritySchema = {};
        for (const [key, value] of Object.entries(s)) {
          Object.assign(joinedSecuritySchema, { [componentsPrefix + '_' + key]: value });
        }
        return joinedSecuritySchema;
      })
    : security;
}

function getInfoPrefix(info: any, prefixArg: string | undefined, type: string) {
  if (!prefixArg) return '';
  if (!info) exitWithError('Info section is not found in specification.');
  if (!info[prefixArg])
    exitWithError(
      `${yellow(`prefix-${type}-with-info-prop`)} argument value is not found in info section.`
    );
  if (!isString(info[prefixArg]))
    exitWithError(`${yellow(`prefix-${type}-with-info-prop`)} argument value should be string.`);
  if (info[prefixArg].length > 50)
    exitWithError(
      `${yellow(
        `prefix-${type}-with-info-prop`
      )} argument value length should not exceed 50 characters.`
    );
  return info[prefixArg].replaceAll(/\s/g, '_');
}

function replace$Refs(obj: unknown, componentsPrefix: string) {
  crawl(obj, (node: Record<string, unknown>) => {
    if (node.$ref && typeof node.$ref === 'string' && startsWithComponents(node.$ref)) {
      const name = path.basename(node.$ref);
      node.$ref = node.$ref.replace(name, componentsPrefix + '_' + name);
    } else if (isObject(node.discriminator) && isObject(node.discriminator.mapping)) {
      const { mapping } = node.discriminator;
      for (const name of Object.keys(mapping)) {
        const mappingPointer = mapping[name];
        if (typeof mappingPointer === 'string' && startsWithComponents(mappingPointer)) {
          mapping[name] = mappingPointer
            .split('/')
            .map((name, i, arr) => {
              return arr.length - 1 === i && !name.includes(componentsPrefix)
                ? componentsPrefix + '_' + name
                : name;
            })
            .join('/');
        }
      }
    }
  });
}