import { ValidationParam, ValidationRule } from '@allianz/taly-core';
import {
  BuildingBlockConfiguration,
  DynamicFormBBConfiguration,
  Frame
} from '@allianz/taly-core/schemas';
import { PagesJsonSchema } from '../../../../model';
import {
  ApplicationJsonSchema,
  PageJsonSchema
} from '../../../../model/split-journey-configuration.schema';
import { copyComments } from '../shared/jsonc-comments';
import { cloneDeepWithJsonComments } from '../shared/utils';

export function migrateBBPluginValidationsInPagesJson(pagesConfiguration: PagesJsonSchema) {
  // The originalPagesConfiguration is required to copy the comments onto the new configuration
  const originalPagesConfiguration = cloneDeepWithJsonComments(pagesConfiguration);

  pagesConfiguration.pages = pagesConfiguration.pages.map((page) =>
    migrateBBPluginValidationsInPage(page)
  );

  // This copies the comments that are locate in between the elements in the pages array.
  // The comments that are inside the elements inside the array are copied preserved by the
  // migrateBBPluginValidationConfiguration()
  pagesConfiguration.pages = copyComments(
    pagesConfiguration.pages,
    originalPagesConfiguration.pages
  );

  if (pagesConfiguration.frame) {
    migrateBBPluginValidationConfigurationsInFrame(pagesConfiguration.frame);
  }
  return pagesConfiguration;
}

export function migrateBBPluginValidationsInApplicationJson(
  applicationJson: ApplicationJsonSchema
) {
  if (applicationJson.frame) {
    migrateBBPluginValidationConfigurationsInFrame(applicationJson.frame);
  }
  return applicationJson;
}

export function migrateBBPluginValidationsInPage(
  pageConfiguration: PageJsonSchema
): PageJsonSchema {
  if (pageConfiguration.bannerBlock?.validators) {
    pageConfiguration.bannerBlock.validators = migrateBBPluginValidationConfiguration(
      pageConfiguration.bannerBlock.validators
    );
  }

  if (pageConfiguration.overarchingDetailsBlock?.validators) {
    pageConfiguration.overarchingDetailsBlock.validators = migrateBBPluginValidationConfiguration(
      pageConfiguration.overarchingDetailsBlock.validators
    );
  }

  pageConfiguration.blocks?.forEach((block) => {
    if (isBuildingBlockConfigurationWithValidators(block) && block.validators) {
      block.validators = migrateBBPluginValidationConfiguration(block.validators);
    }
  });

  return pageConfiguration;
}

/**
 * Migrates the validation configuration for actions in the frame.
 * The configuration is mutated directly.
 */
function migrateBBPluginValidationConfigurationsInFrame(frame: Frame): void {
  frame?.header?.actions?.forEach((action) => {
    if (action.validators) {
      action.validators = migrateBBPluginValidationConfiguration(action.validators);
    }
  });
}

function migrateBBPluginValidationConfiguration(
  validators: (ValidationRule | LegacyCustomValidationRule)[]
): ValidationRule[] {
  const migratedValidators = validators.map((rule) => {
    if (isBuiltInValidationRule(rule)) {
      return rule;
    }
    console.log(
      `Migrating rule of type ${rule.type} to new validation PLUGIN configuration format...`
    );

    const migratedValidationRule: ValidationRule = { ...rule, type: 'PLUGIN', name: rule.type };

    // This copyComments call copies the comment for the elements within the array.
    return copyComments(migratedValidationRule, rule, new Map([['name', 'type']]));
  });

  // This copyComment call copies the comments in between the elements of the array and the array itself.
  // This is necessary because the map call above creates a new array.
  return copyComments(migratedValidators, validators);
}

function isBuildingBlockConfigurationWithValidators(
  block: BuildingBlockConfiguration | DynamicFormBBConfiguration
): block is BuildingBlockConfiguration {
  return (block as BuildingBlockConfiguration).validators !== undefined;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
function isBuiltInValidationRule(validationRule: any): validationRule is ValidationRule {
  const validationTypes = [
    'REQUIRED',
    'REQUIRED_TRUE',
    'EMAIL',
    'MIN',
    'DYNAMIC_MIN',
    'MAX',
    'DYNAMIC_MAX',
    'MIN_DATE',
    'MAX_DATE',
    'MIN_LENGTH',
    'MAX_LENGTH',
    'PATTERN',
    'PLUGIN'
  ];

  return validationRule && validationTypes.includes(validationRule?.type);
}

/**
 * This is how old/outdated custom validation rules look like
 */
interface LegacyCustomValidationRule {
  id: string;
  type: string;
  errorMessage?: string;
  validationParam?: ValidationParam;
}