/**
 * ============LICENSE_START========================================================================
 * ONAP : ccsdk feature sdnr wt odlux
 * =================================================================================================
 * Copyright (C) 2019 highstreet technologies GmbH Intellectual Property. All rights reserved.
 * =================================================================================================
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 * ============LICENSE_END==========================================================================
 */

import { YangRange, Operator, ViewElementNumber, ViewElementString, isViewElementNumber, isViewElementString } from '../models/uiModels';

export type validated = { isValid: boolean; error?: string };

export type validatedRange = { isValid: boolean; error?: string };

const rangeErrorStartNumber = 'The entered number must be';
const rangeErrorInnerMinTextNumber = 'greater or equals than';
const rangeErrorInnerMaxTextNumber = 'less or equals than';
const rangeErrorEndTextNumber = '.';

const rangeErrorStartString = 'The entered text must have';
const rangeErrorInnerMinTextString = 'no more than';
const rangeErrorInnerMaxTextString = 'less than';
const rangeErrorEndTextString = ' characters.';

let errorMessageStart = '';
let errorMessageMiddleMinPart = '';
let errorMessageMiddleMaxPart = '';
let errorMessageEnd = '';

const isYangRange = (val: YangRange | Operator<YangRange>): val is YangRange => (val as YangRange).min !== undefined;
  
const isYangOperator = (val: YangRange | Operator<YangRange>): val is Operator<YangRange> => (val as Operator<YangRange>).operation !== undefined;

const isRegExp = (val: RegExp | Operator<RegExp>): val is RegExp => (val as RegExp).source !== undefined;

const isRegExpOperator = (val: RegExp | Operator<RegExp>): val is Operator<RegExp> => (val as Operator<RegExp>).operation !== undefined;

const getRangeErrorMessagesRecursively = (value: Operator<YangRange>, data: number): string[] => {
  let currentIteration: string[] = [];
  
  // iterate over all elements
  for (let i = 0; i < value.arguments.length; i++) {
    const element = value.arguments[i];
  
    let min = undefined;
    let max = undefined;
  
    let isNumberCorrect = false;
  
    if (isYangRange(element)) {
  
      //check found min values
      if (!isNaN(element.min)) {
        if (data < element.min) {
          min = element.min;
        } else {
          isNumberCorrect = true;
        }
      }
  
      // check found max values
      if (!isNaN(element.max)) {
        if (data > element.max) {
          max = element.max;
        } else {
          isNumberCorrect = true;
        }
      }
  
      // construct error messages
      if (min != undefined) {
        currentIteration.push(`${value.operation.toLocaleLowerCase()} ${errorMessageMiddleMinPart} ${min}`);
      } else if (max != undefined) {
        currentIteration.push(`${value.operation.toLocaleLowerCase()} ${errorMessageMiddleMaxPart} ${max}`);
  
      }
  
    } else if (isYangOperator(element)) {
  
      //get error_message from expression
      const result = getRangeErrorMessagesRecursively(element, data);
      if (result.length === 0) {
        isNumberCorrect = true;
      }
      currentIteration = currentIteration.concat(result);
    }
  
    // if its an OR operation, the number has been checked and min/max are empty (thus not violated)
    // delete everything found (because at least one found is correct, therefore all are correct) and break from loop
    if (min === undefined && max === undefined && isNumberCorrect && value.operation === 'OR') {
  
      currentIteration.splice(0, currentIteration.length);
      break;
    }
  }
  
  return currentIteration;
};

const createStartMessage = (element: string) => {
  //remove leading or or and from text
  if (element.startsWith('and')) {
    element = element.replace('and', '');
  } else if (element.startsWith('or')) {
    element = element.replace('or', '');
  }
  return `${errorMessageStart} ${element}`;
};
  
const getRangeErrorMessages = (value: Operator<YangRange>, data: number): string => {

  const currentIteration = getRangeErrorMessagesRecursively(value, data);
  
  // build complete error message from found parts
  let errorMessage = '';
  if (currentIteration.length > 1) {
  
    currentIteration.forEach((element, index) => {
      if (index === 0) {
        errorMessage = createStartMessage(element);
      } else if (index === currentIteration.length - 1) {
        errorMessage += ` ${element}${errorMessageEnd}`;
      } else {
        errorMessage += `, ${element}`;
      }
    });
  } else if (currentIteration.length == 1) {
    errorMessage = `${createStartMessage(currentIteration[0])}${errorMessageEnd}`;
  }
  
  return errorMessage;
};

export const checkRange = (element: ViewElementNumber | ViewElementString, data: number): string => {
  const number = data;

  let expression = undefined;

  if (isViewElementString(element)) {
    expression = element.length;

    errorMessageStart = rangeErrorStartString;
    errorMessageMiddleMaxPart = rangeErrorInnerMaxTextString;
    errorMessageMiddleMinPart = rangeErrorInnerMinTextString;
    errorMessageEnd = rangeErrorEndTextString;

  } else if (isViewElementNumber(element)) {
    expression = element.range;

    errorMessageStart = rangeErrorStartNumber;
    errorMessageMiddleMaxPart = rangeErrorInnerMaxTextNumber;
    errorMessageMiddleMinPart = rangeErrorInnerMinTextNumber;
    errorMessageEnd = rangeErrorEndTextNumber;
  }

  if (expression) {
    if (isYangOperator(expression)) {

      const errorMessage = getRangeErrorMessages(expression, data);
      return errorMessage;

    } else
    if (isYangRange(expression)) {

      if (!isNaN(expression.min)) {
        if (number < expression.min) {
          return `${errorMessageStart} ${errorMessageMiddleMinPart} ${expression.min}${errorMessageEnd}`;
        }
      }

      if (!isNaN(expression.max)) {
        if (number > expression.max) {
          return `${errorMessageStart} ${errorMessageMiddleMaxPart} ${expression.max}${errorMessageEnd}`;
        }
      }
    }
  }

  return '';
};

const getRegexRecursively = (value: Operator<RegExp>, data: string): boolean[] => {
  let currentItteration: boolean[] = [];
  for (let i = 0; i < value.arguments.length; i++) {
    const element = value.arguments[i];
    if (isRegExp(element)) {
      // if regex is found, add it to list
      currentItteration.push(element.test(data));
    } else if (isRegExpOperator(element)) {
      //if RegexExpression is found, try to get regex from it
      currentItteration = currentItteration.concat(getRegexRecursively(element, data));
    }
  }
  
  if (value.operation === 'OR') {
    // if one is true, all are true, all found items can be discarded
    let result = currentItteration.find(element => element);
    if (result) {
      return [];
    }
  }
  return currentItteration;
};
  
const isPatternValid = (value: Operator<RegExp>, data: string): boolean => {
  // get all regex
  const result = getRegexRecursively(value, data);
  
  if (value.operation === 'AND') {
    // if AND operation is executed...
    // no element can be false
    const check = result.find(element => element !== true);
    if (check)
      return false;
    else
      return true;
  } else {
    // if OR operation is executed...
    // ... just one element must be true
    const check = result.find(element => element === true);
    if (check)
      return true;
    else
      return false;
  
  }
};

export const checkPattern = (expression: RegExp | Operator<RegExp> | undefined, data: string): validated => {

  if (expression) {
    if (isRegExp(expression)) {
      const isValid = expression.test(data);
      if (!isValid)
        return { isValid: isValid, error: 'The input is in a wrong format.' };

    } else if (isRegExpOperator(expression)) {
      const result = isPatternValid(expression, data);

      if (!result) {
        return { isValid: false, error: 'The input is in a wrong format.' };
      }
    }
  }

  return { isValid: true };
};