import { IHtmlValue, IOverridableValue, MapOf } from '../../shared';
import { IRegionSetting, IUrlSettings } from '../../shared/models';
import { normalizeSummary } from './mappers';
import { TranslationEnum, TextType, ITranslation } from '../../locales/Messages'

const isEmpty = (value: MapOf<IHtmlValue>) => {
  return value && !value.get('text');
};

const isMaxLength = (value: MapOf<IHtmlValue>, maxLength: number) => {
  return value && (value.get('text') as string).length > maxLength;
};

export const MAX_LENGTH_TITLE = 150;

const generateTextType = (): ITranslation => {
  return {
  key: TranslationEnum.validation_maxLength_du,
  values: {
      field: {
        key: TranslationEnum.title,
        values: {
          maxLength: MAX_LENGTH_TITLE
        }
      }
    }
  };
}

export const TITLE_MAX_LENGTH_ERROR:ITranslation = generateTextType();

export const titleValidation = (title: MapOf<IHtmlValue>): TextType => {
  let error:TextType = '';
  if (isEmpty(title)) {
    error = {key: TranslationEnum.validation_required_le, values:{field:TranslationEnum.title}};
  } else if (isMaxLength(title, MAX_LENGTH_TITLE)) {
    error = TITLE_MAX_LENGTH_ERROR;
  }
  return error;
};

export const MAX_LENGTH_ALERT = 150;

export const alertTextValidation = (
  alertText: MapOf<IOverridableValue<IHtmlValue>>
): TextType => {
  let error: TextType = '';
  const alertTextValue = alertText.get('value') as MapOf<IHtmlValue>;
  if (alertText.get('isOverriden') && isEmpty(alertTextValue)) {
    error = {key: TranslationEnum.validation_required_l, values:{field: TranslationEnum.alertText}}
  } else if (isMaxLength(alertTextValue, MAX_LENGTH_ALERT)) {
    error = {key: TranslationEnum.validation_maxLength_du, values:{field: TranslationEnum.alertText, maxLength: MAX_LENGTH_ALERT}}
  }
  return error;
};

export const MAX_SUMMARY_ALERT_WARNING = 1024;

export const summaryWarningValidation = (
  summary: MapOf<IOverridableValue<IHtmlValue>>
): TextType | undefined => {
  let warning: TextType | undefined;
  const normalizedSummary = normalizeSummary(summary.getIn(['value', 'html']) as string);

  if (normalizedSummary.length > MAX_SUMMARY_ALERT_WARNING) {
    warning = {key: TranslationEnum.summary_warning, values:{field: TranslationEnum.summary, maxLength: MAX_SUMMARY_ALERT_WARNING}}
  }

  return warning;
};

export const MAX_SUMMARY_ALERT = 1000;

export const summaryValidation = (
  summary: MapOf<IOverridableValue<IHtmlValue>>
): TextType => {
  let error: TextType = '';
  const summaryValue = summary.get('value') as MapOf<IHtmlValue>;

  if (summary.get('isOverriden') && isEmpty(summaryValue)) {
    error = {key: TranslationEnum.validation_required_l, values: {field: TranslationEnum.summary}}
  } else if (isMaxLength(summaryValue, MAX_SUMMARY_ALERT)) {
    error = {key: TranslationEnum.validation_maxLength_de_l, values: {field: TranslationEnum.validation_maxLength_de_l, maxLength: MAX_SUMMARY_ALERT}};
  }
  return error;
};

export const regionalSettingsValidation = (
  settings: MapOf<IOverridableValue<IRegionSetting>>
): TextType => {
  let error:TextType = '';
  const regionIds = settings.getIn(['value', 'regionIds']);
  const noSelectedRegions = regionIds === undefined || regionIds.size === 0;
  if (
    settings.getIn(['value', 'isOfRegionalInterestOnly']) &&
    noSelectedRegions
  ) {
    error = {key: TranslationEnum.validation_region_required};
  }
  return error;
};

export const slugRegex = /^[-a-z0-9]*$/;

const isValidSlug = (slugValue: string) =>
  slugValue !== '' && slugRegex.test(slugValue);

export const urlSettingsValidation = (
  urlSettings: MapOf<IUrlSettings>
): TextType => {
  let error: TextType = '';
  const overridden = urlSettings.getIn(['slug', 'isOverriden']);
  if (overridden) {
    const slugValue = urlSettings.getIn(['slug', 'value']);
    if (!slugValue || slugValue === '') {
      error = {key: TranslationEnum.validation_required_le, values: {field: TranslationEnum.slug}}
    } else if (!isValidSlug(slugValue)) {
      error = {key: TranslationEnum.validation_slug_format}
    }
  }
  return error;
};