'use strict';

var utils = require('./utils.js');
var stringResources = require('./stringResources.js');
var enums = require('./enums.js');
var RCV = require('@progress/telerik-common-report-viewer');

var ParameterValidators = function() {
  var validators = {};
  function validateParameter(parameter, value, validatorFunc, compareFunc) {
    var values = [].concat(value).map((value1) => {
      return checkAvailableValues(parameter, validatorFunc(value1), compareFunc);
    });
    if (parameter.multivalue) {
      if (value == null || value.length == 0) {
        if (parameter.allowNull) {
          return value;
        }
        throw stringResources.stringResources.invalidParameter;
      }
      return values;
    }
    return values[0];
  }
  function isNull(parameter, value) {
    return parameter.allowNull && -1 != [null, "", void 0].indexOf(value);
  }
  function checkAvailableValues(parameter, value, compareFunc) {
    if (parameter.availableValues) {
      var found = Array.from(parameter.availableValues).some((av) => {
        return compareFunc(value, av.value);
      });
      if (!found) {
        if (parameter.allowNull && !value) {
          return value;
        }
        throw stringResources.stringResources.invalidParameter;
      }
    }
    return value;
  }
  validators[enums.ParameterTypes.STRING] = {
    validate: (parameter, value) => {
      return validateParameter(
        parameter,
        value,
        (value2) => {
          if (!value2) {
            if (parameter.allowNull) {
              return null;
            }
            if (parameter.allowBlank) {
              return "";
            }
            throw stringResources.stringResources.parameterIsEmpty;
          }
          return value2;
        },
        (s1, s2) => {
          return s1 == s2;
        }
      );
    }
  };
  validators[enums.ParameterTypes.FLOAT] = {
    validate: (parameter, value) => {
      return validateParameter(
        parameter,
        value,
        (value2) => {
          var num = RCV.tryParseFloat(value2);
          if (isNaN(num)) {
            if (isNull(parameter, value2)) {
              return null;
            }
            throw stringResources.stringResources.parameterIsEmpty;
          }
          return num;
        },
        (f1, f2) => {
          return RCV.tryParseFloat(f1) == RCV.tryParseFloat(f2);
        }
      );
    }
  };
  validators[enums.ParameterTypes.INTEGER] = {
    validate: (parameter, value) => {
      return validateParameter(
        parameter,
        value,
        (value2) => {
          var num = RCV.tryParseInt(value2);
          if (isNaN(num)) {
            if (isNull(parameter, value2)) {
              return null;
            }
            throw stringResources.stringResources.parameterIsEmpty;
          }
          return num;
        },
        (n1, n2) => {
          return RCV.tryParseInt(n1) == RCV.tryParseFloat(n2);
        }
      );
    }
  };
  validators[enums.ParameterTypes.DATETIME] = {
    validate: (parameter, value) => {
      return validateParameter(
        parameter,
        value,
        (value2) => {
          if (parameter.allowNull && (value2 === null || value2 === "" || value2 === void 0)) {
            return null;
          }
          if (!isNaN(Date.parse(value2))) {
            if (parameter.availableValues) {
              return value2;
            }
            return RCV.parseToLocalDate(value2);
          }
          throw stringResources.stringResources.invalidDateTimeValue;
        },
        (d1, d2) => {
          d1 = RCV.parseToLocalDate(d1);
          d2 = RCV.parseToLocalDate(d2);
          return d1.getTime() == d2.getTime();
        }
      );
    }
  };
  validators[enums.ParameterTypes.BOOLEAN] = {
    validate: (parameter, value) => {
      return validateParameter(
        parameter,
        value,
        (value2) => {
          if (-1 != ["true", "false"].indexOf(String(value2).toLowerCase())) {
            return Boolean(value2);
          }
          if (isNull(parameter, value2)) {
            return null;
          }
          throw stringResources.stringResources.parameterIsEmpty;
        },
        (b1, b2) => {
          return Boolean(b1) == Boolean(b2);
        }
      );
    }
  };
  return {
    validate: (parameter, value) => {
      var v = validators[parameter.type];
      if (!v) {
        throw utils.stringFormat(stringResources.stringResources.cannotValidateType, parameter);
      }
      return v.validate(parameter, value);
    }
  };
}();

exports.ParameterValidators = ParameterValidators;
