/* eslint-disable max-statements */
/* eslint-disable complexity */
/* eslint-disable default-case */
import { toArray } from 'exotic'
import { Primitive } from '@skava/typings'
import isValidTelephone, { isEmptyOrValidTelephone } from './isValidTelephone'
import isValidEmail from './isValidEmail'
import isValidPassword from './isValidPassword'
import { isValidName, isEmptyOrValidName } from './isValidName'
import isValidZipCode from './isValidZipCode'
import isValidLength from './isValidLength'
import isValidExpiryDate from './isValidExpiryDate'
import { isValidCoupon } from './isValidCoupon'
import { isValidOrderId } from './isValidOrderId'
import { isValidCreditCard, isValidSecurityCode } from './isValidCreditCard'
import {
  isAlphaNumeric,
  isNumeric,
  isEmptyOrValidNumber,
  isAlphabet,
  isValidCity,
  isAlphaNumericSpecialCharacters,
  isAddress,
} from './isAlphaNumeric'
import { expiryDate, isValidMonth, isValidYear } from './isValidDates'

// @todo reuse
type ValidationTypes =
  | 'length'
  | 'email'
  | 'length,email'
  | string
  | Array<string | Function>

/**
 * @todo multipliers, may  need length on any values,
 *       so type should be an array always
 *
 * @todo ^ might want to have settings for these, so would be an array of strings or objects...
 */
function isValid(
  value: Primitive,
  types: ValidationTypes = 'length,email'
): boolean {
  // @todo add options
  const doesSatisfySpecification = (type, options) => {
    switch (type) {
      // may be used for other types
      case 'number':
        return isNumeric(value)
      case 'email':
        return isValidEmail(value)
      case 'emailOrPhone':
        return isValidEmail(value) || isValidTelephone(value)

      case 'zipCode':
      case 'zip':
        return isValidZipCode(value)

      // @todo - month, year, ccv
      // case 'date': return isValidDate(value)
      case 'creditCard':
        return isValidCreditCard(value)
      case 'securityCode':
        return isValidSecurityCode(value)
      case 'coupon':
        return isValidCoupon(value)

      case 'tel':
      case 'phone':
      case 'telephone':
        return isValidTelephone(value)
      case 'emptyOrTelephone':
        return isEmptyOrValidTelephone(value)
      case 'address':
        return isAddress(value)
      case 'alphanumeric':
      case 'letterNumber':
        return isAlphaNumeric(value)

      case 'alphabet':
        return isAlphabet(value)
      case 'city':
        return isValidCity(value)

      case 'isAlphaNumericSpecialCharacters':
        return isAlphaNumericSpecialCharacters(value)

      case 'password':
        return isValidPassword(value)

      case 'country':
      case 'state':
      case 'name':
        return isValidName(value)
      case 'emptyOrName':
        return isEmptyOrValidName(value)
      case 'emptyOrNumber':
        return isEmptyOrValidNumber(value)

      case 'month':
        return expiryDate.isValidMonth(value)
      case 'year':
        return expiryDate.isValidYear(value)

      case 'expiryDate':
        return isValidExpiryDate(value)
      // may not work this way since we need lengths per type
      case 'length':
        return isValidLength(value)

      // case 'month': return isValidMonth(value)
      case 'required':
        return value !== ''
      case 'orderId':
        return isValidOrderId(value)
      case 'none':
        return true
      default:
        return false
    }
  }

  // @todo will use isMatcher & isObject here
  const doesSatisfy = type => {
    return doesSatisfySpecification(type)
  }

  /**
   * @Ganesh: @James exotic method 'all' is not working here
   *
   *
   * @james: @ganesh
   *  1. ^ .every & .some works
   *  2. exotic has no method named .all, `chain` does
   */
  const result = types.split(',').map(doesSatisfy)

  // Multiple validations has been done and the results will be an array. If anyone of the validations is passed, then the value should be called as 'valid'
  return result.indexOf(true) >= 0
}

/**
 * @param {Array<enum> | enum | Function | RegExp} types
 * @return {isValid}
 */
const validatorFor = types => value => isValid(value, types)

export { isValid }
export default isValid