import { Validator } from '../../src/validation/Validator';
import { ValidationArguments } from '../../src/validation/ValidationArguments';
import { registerDecorator } from '../../src/register-decorator';
import { ValidationOptions } from '../../src/decorator/ValidationOptions';
import { ValidatorConstraint } from '../../src/decorator/decorators';
import { ValidatorConstraintInterface } from '../../src/validation/ValidatorConstraintInterface';

const validator = new Validator();

describe('decorator with inline validation', () => {
  function IsLongerThan(property: string, validationOptions?: ValidationOptions) {
    return function (object: object, propertyName: string): void {
      registerDecorator({
        target: object.constructor,
        propertyName: propertyName,
        options: validationOptions,
        constraints: [property],
        name: 'isLongerThan',
        validator: {
          validate(value: any, args: ValidationArguments): Promise<boolean> | boolean {
            const [relatedPropertyName] = args.constraints;
            const relatedValue = (args.object as any)[relatedPropertyName];
            if (relatedValue === undefined || relatedValue === null) {
              return true;
            }

            const result =
              typeof value === 'string' && typeof relatedValue === 'string' && value.length > relatedValue.length;

            const asPromise = validationOptions && validationOptions.context && validationOptions.context.promise;

            return asPromise ? Promise.resolve(result) : result;
          },
        },
      });
    };
  }

  class MyClass {
    @IsLongerThan('lastName', {
      context: { foo: 'bar' },
      message: '$property must be longer then $constraint1. Given value: $value',
    })
    firstName: string;
    lastName: string;
  }

  class MyClassWithAsyncValidator {
    @IsLongerThan('lastName', {
      context: { foo: 'bar', promise: true },
      message: '$property must be longer then $constraint1. Given value: $value',
    })
    firstName: string;
    lastName: string;
  }

  it('if firstName is not empty and lastLame is empty then it should succeed', () => {
    expect.assertions(1);
    const model = new MyClass();
    model.firstName = 'hell no world';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(0);
    });
  });

  it('if firstName is empty and lastLame is not empty then it should fail', () => {
    expect.assertions(2);
    const model = new MyClass();
    model.firstName = '';
    model.lastName = 'Kim';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].constraints).toEqual({ isLongerThan: 'firstName must be longer then lastName. Given value: ' });
    });
  });

  it('if firstName is shorter then lastLame then it should fail', () => {
    expect.assertions(2);
    const model = new MyClass();
    model.firstName = 'Li';
    model.lastName = 'Kim';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].constraints).toEqual({
        isLongerThan: 'firstName must be longer then lastName. Given value: Li',
      });
    });
  });

  it('should include context', () => {
    expect.assertions(4);
    const model = new MyClass();
    const asyncModel = new MyClassWithAsyncValidator();
    model.firstName = asyncModel.firstName = 'Paul';
    model.lastName = asyncModel.lastName = 'Walker';

    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].contexts).toEqual({ isLongerThan: { foo: 'bar' } });
      return validator.validate(asyncModel).then(errors => {
        expect(errors.length).toEqual(1);
        expect(errors[0].contexts).toHaveProperty('isLongerThan.foo', 'bar');
      });
    });
  });
});

describe('decorator with default message', () => {
  function IsLonger(property: string, validationOptions?: ValidationOptions) {
    return function (object: object, propertyName: string): void {
      registerDecorator({
        target: object.constructor,
        propertyName: propertyName,
        options: validationOptions,
        constraints: [property],
        name: 'isLonger',
        validator: {
          validate(value: any, args: ValidationArguments): boolean {
            const [relatedPropertyName] = args.constraints;
            const relatedValue = (args.object as any)[relatedPropertyName];
            if (relatedValue === undefined || relatedValue === null) return true;

            return typeof value === 'string' && typeof relatedValue === 'string' && value.length > relatedValue.length;
          },
          defaultMessage(args: ValidationArguments): string {
            return args.property + ' must be longer then ' + args.constraints[0];
          },
        },
      });
    };
  }

  class SecondClass {
    @IsLonger('lastName')
    firstName: string;
    lastName: string;
  }

  it('if firstName is not empty and lastLame is empty then it should succeed', () => {
    expect.assertions(1);
    const model = new SecondClass();
    model.firstName = 'hell no world';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(0);
    });
  });

  it('if firstName is empty and lastLame is not empty then it should fail', () => {
    expect.assertions(2);
    const model = new SecondClass();
    model.firstName = '';
    model.lastName = 'Kim';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].constraints).toEqual({ isLonger: 'firstName must be longer then lastName' });
    });
  });

  it('if firstName is shorter then lastLame then it should fail', () => {
    expect.assertions(2);
    const model = new SecondClass();
    model.firstName = 'Li';
    model.lastName = 'Kim';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].constraints).toEqual({ isLonger: 'firstName must be longer then lastName' });
    });
  });
});

describe('decorator with separate validation constraint class', () => {
  @ValidatorConstraint({ name: 'isShortenThan' })
  class IsShortenThanConstraint implements ValidatorConstraintInterface {
    validate(value: any, args: ValidationArguments): boolean {
      const [relatedPropertyName] = args.constraints;
      const relatedValue = (args.object as any)[relatedPropertyName];
      if (value === null || value === undefined) return true;

      return typeof value === 'string' && typeof relatedValue === 'string' && value.length < relatedValue.length;
    }
  }

  function IsShorterThan(property: string, validationOptions?: ValidationOptions) {
    return function (object: object, propertyName: string): void {
      registerDecorator({
        target: object.constructor,
        propertyName: propertyName,
        options: validationOptions,
        constraints: [property],
        validator: IsShortenThanConstraint,
      });
    };
  }

  class MyClass {
    firstName: string;

    @IsShorterThan('firstName', {
      message: '$property must be shorter then $constraint1. Given value: $value',
    })
    lastName: string;
  }

  it('if firstName is not empty and lastLame is empty then it should succeed', () => {
    expect.assertions(1);
    const model = new MyClass();
    model.firstName = 'hell no world';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(0);
    });
  });

  it('if firstName is empty and lastLame is not empty then it should fail', () => {
    expect.assertions(2);
    const model = new MyClass();
    model.firstName = '';
    model.lastName = 'Kim';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].constraints).toEqual({
        isShortenThan: 'lastName must be shorter then firstName. Given value: Kim',
      });
    });
  });

  it('if firstName is shorter then lastLame then it should fail', () => {
    expect.assertions(2);
    const model = new MyClass();
    model.firstName = 'Li';
    model.lastName = 'Kim';
    return validator.validate(model).then(errors => {
      expect(errors.length).toEqual(1);
      expect(errors[0].constraints).toEqual({
        isShortenThan: 'lastName must be shorter then firstName. Given value: Kim',
      });
    });
  });
});