/* eslint-env mocha */
/* eslint-disable class-method-use-this, no-underscore-dangle, no-unused-expressions */
import { expect } from '@open-wc/testing';

import {
  isString,
  equalsLength,
  minLength,
  maxLength,
  minMaxLength,
  isEmail,
  isStringValidator,
  equalsLengthValidator,
  minLengthValidator,
  maxLengthValidator,
  minMaxLengthValidator,
  isEmailValidator,
  isNumber,
  minNumber,
  maxNumber,
  minMaxNumber,
  isNumberValidator,
  minNumberValidator,
  maxNumberValidator,
  minMaxNumberValidator,
  isDate,
  minDate,
  maxDate,
  minMaxDate,
  isDateValidator,
  minDateValidator,
  maxDateValidator,
  minMaxDateValidator,
  randomOk,
  defaultOk,
  randomOkValidator,
  defaultOkValidator,
} from '../src/validators.js';

export const smokeTestValidator = (name, validator, value, params = undefined) => {
  const generated = validator(params);
  expect(generated[0](value, params)[name]).to.be.true;
  if (params) {
    expect(generated[1]).to.equals(params);
  }
};

describe('LionValidate', () => {
  describe('String Validation', () => {
    it('provides isString() to allow only strings', () => {
      expect(isString('foo')).to.be.true;
      expect(isString(NaN)).to.be.false;
      expect(isString(4)).to.be.false;
    });

    it('provides equalsLength() to allow only a specific string length', () => {
      expect(equalsLength('foo', 3)).to.be.true;
      expect(equalsLength('fo', 3)).to.be.false;
      expect(equalsLength('foobar', 3)).to.be.false;
    });

    it('provides minLength() to allow only strings longer then min', () => {
      expect(minLength('foo', 3)).to.be.true;
      expect(minLength('fo', 3)).to.be.false;
    });

    it('provides maxLength() to allow only strings shorter then max', () => {
      expect(maxLength('foo', 3)).to.be.true;
      expect(maxLength('foobar', 3)).to.be.false;
    });

    it('provides minMaxLength() to allow only strings between min and max', () => {
      expect(minMaxLength('foo', { min: 2, max: 4 })).to.be.true;
      expect(minMaxLength('f', { min: 2, max: 4 })).to.be.false;
      expect(minMaxLength('foobar', { min: 2, max: 4 })).to.be.false;
    });

    it('provides isEmail() to allow only valid email formats', () => {
      expect(isEmail('foo@bar.com')).to.be.true;
      expect(isEmail('name!#$%*@bar.com')).to.be.true;
      expect(isEmail('foo')).to.be.false;
      expect(isEmail('foo@')).to.be.false;
      expect(isEmail('@bar')).to.be.false;
      expect(isEmail('bar.com')).to.be.false;
      expect(isEmail('@bar.com')).to.be.false;
      expect(isEmail('foo@bar@example.com')).to.be.false;
      expect(isEmail('foo@bar')).to.be.false;
      expect(isEmail('foo@120.120.120.93')).to.be.false;
    });

    it('provides {isString, equalsLength, minLength, maxLength, minMaxLength, isEmail}Validator factory function for all types', () => {
      // do a smoke test for each type
      smokeTestValidator('isString', isStringValidator, 'foo');
      smokeTestValidator('equalsLength', equalsLengthValidator, 'foo', 3);
      smokeTestValidator('minLength', minLengthValidator, 'foo', 3);
      smokeTestValidator('maxLength', maxLengthValidator, 'foo', 3);
      smokeTestValidator('minMaxLength', minMaxLengthValidator, 'foo', { min: 2, max: 4 });
      smokeTestValidator('isEmail', isEmailValidator, 'foo@bar.com');
    });
  });

  describe('Number Validation', () => {
    it('provides isNumber() to allow only numbers', () => {
      expect(isNumber(4)).to.be.true;
      expect(isNumber(NaN)).to.be.false;
      expect(isNumber('4')).to.be.false;
    });

    it('provides minNumber() to allow only numbers longer then min', () => {
      expect(minNumber(3, 3)).to.be.true;
      expect(minNumber(2, 3)).to.be.false;
    });

    it('provides maxNumber() to allow only number shorter then max', () => {
      expect(maxNumber(3, 3)).to.be.true;
      expect(maxNumber(4, 3)).to.be.false;
    });

    it('provides minMaxNumber() to allow only numbers between min and max', () => {
      expect(minMaxNumber(3, { min: 2, max: 4 })).to.be.true;
      expect(minMaxNumber(1, { min: 2, max: 4 })).to.be.false;
      expect(minMaxNumber(5, { min: 2, max: 4 })).to.be.false;
    });

    it('provides {isNumber, minNumber, maxNumber, minMaxNumber}Validator factory function for all types', () => {
      // do a smoke test for each type
      smokeTestValidator('isNumber', isNumberValidator, 4);
      smokeTestValidator('minNumber', minNumberValidator, 3, 3);
      smokeTestValidator('maxNumber', maxNumberValidator, 3, 3);
      smokeTestValidator('minMaxNumber', minMaxNumberValidator, 3, { min: 2, max: 4 });
    });
  });

  describe('Date Validation', () => {
    it('provides isDate() to allow only dates', () => {
      expect(isDate(new Date())).to.be.true;
      expect(isDate('foo')).to.be.false;
      expect(isDate(4)).to.be.false;
    });

    it('provides minDate() to allow only dates earlier then min', () => {
      expect(minDate(new Date('2018-02-03'), new Date('2018-02-02'))).to.be.true;
      expect(minDate(new Date('2018-02-01'), new Date('2018-02-02'))).to.be.false;
    });

    it('provides maxDate() to allow only dates before max', () => {
      expect(maxDate(new Date('2018-02-01'), new Date('2018-02-02'))).to.be.true;
      expect(maxDate(new Date('2018-02-03'), new Date('2018-02-02'))).to.be.false;
    });

    it('provides minMaxDate() to allow only dates between min and max', () => {
      const minMaxSetting = {
        min: new Date('2018-02-02'),
        max: new Date('2018-02-04'),
      };
      expect(minMaxDate(new Date('2018-02-03'), minMaxSetting)).to.be.true;
      expect(minMaxDate(new Date('2018-02-01'), minMaxSetting)).to.be.false;
      expect(minMaxDate(new Date('2018-02-05'), minMaxSetting)).to.be.false;
    });

    it('provides {isDate, minDate, maxDate, minMaxDate}Validator factory function for all types', () => {
      // do a smoke test for each type
      smokeTestValidator('isDate', isDateValidator, new Date());
      smokeTestValidator(
        'minDate',
        minDateValidator,
        new Date('2018-02-03'),
        new Date('2018-02-02'),
      );
      smokeTestValidator(
        'maxDate',
        maxDateValidator,
        new Date('2018-02-01'),
        new Date('2018-02-02'),
      );
      const minMaxSetting = {
        min: new Date('2018-02-02'),
        max: new Date('2018-02-04'),
      };
      smokeTestValidator('minMaxDate', minMaxDateValidator, new Date('2018-02-03'), minMaxSetting);
    });
  });

  describe('Success Validation', () => {
    it('provides randomOk() which fails always, so it can show the succeeds message', () => {
      expect(randomOk('foo')).to.be.false;
      expect(randomOkValidator()[0]('foo').randomOk).to.be.false;
    });
    it('provides defaultOk() which fails always, so it can show the succeeds message', () => {
      expect(defaultOk('foo')).to.be.false;
      expect(defaultOkValidator()[0]('foo').defaultOk).to.be.false;
    });
  });
});