import { Criteria } from '../../src/utils/CriteriaModel';
import { CriteriaParameter, CriteriaType } from '../../src/utils/CriteriaParameter';

describe('StringUtils', function () {


  // => CRITERIA
  // ----------------------------------------------------------------------------------------

  it('it should return the undefined and [] to Criteria Props through new class with empty constructor', async () => {
    const ct: Criteria = new Criteria();

    const parameters: Array<CriteriaParameter> = ct.parameters;
    const expression: string | undefined = ct.expression;

    expect(parameters).toEqual([]);
    expect(expression).toEqual(undefined);

  });

  it('it should modify "expressions" and "parameters" properties through Setters methods', async () => {
    const ct: Criteria = new Criteria();

    const parameters: Array<CriteriaParameter> = [new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE')];
    const expression: string = 'Expression';

    ct.parameters = parameters;
    ct.expression = expression;

    expect(ct.parameters).toEqual(parameters);
    expect(ct.expression).toEqual(expression);

  });


  it('it should return "expression" and "parameters" setted through constructor method', async () => {

    const parameters: Array<CriteriaParameter> = [new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE')];
    const expression: string = 'Expression';

    const ct: Criteria = new Criteria(expression, parameters);

    expect(ct.parameters).toEqual(parameters);
    expect(ct.expression).toEqual(expression);

  });

  it('it should return a Criteria class with "expression" and "parameters" as needed setted through "append" method', async () => {

    const parameters: Array<CriteriaParameter> = [new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE')];
    const expression: string = 'Expression';

    const ct: Criteria = new Criteria();

    ct.append(expression, parameters);

    expect(ct.parameters).toEqual(parameters);
    expect(ct.expression).toEqual(expression);
    expect(ct).toBeInstanceOf(Criteria);

  });


  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "append" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria();

    ct1.append(expression, parameters);

    const ct2: Criteria = ct1.append(ct1, parameters);

    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct2.expression).toEqual(`${expression}(${expression})`);
    expect(ct2).toBeInstanceOf(Criteria);

  });

  it('it should return undefined as "expression" and "[]" as parameters as we use an empty criteria as first entry in the constructor', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria();

    const ct2: Criteria = ct1.append(ct1, parameters);

    expect(ct2.parameters).toEqual([]);
    expect(ct2.expression).toEqual(undefined);
    expect(ct2).toBeInstanceOf(Criteria);

  });

  it('it should return a Criteria class with "Expression" and "parameters" concatenaded as needed setted through "OR" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);

    const ct2: Criteria = ct1.or(expression, parameters);

    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct2.expression).toEqual(`${expression} OR ${expression}`);
    expect(ct2).toBeInstanceOf(Criteria);

  });


  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "OR" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);

    const ct2: Criteria = ct1.or(ct1, parameters);

    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct2.expression).toEqual(`${expression} OR (${expression} OR )`);
    expect(ct2).toBeInstanceOf(Criteria);

  });

  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "OR" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);
    const ct2: Criteria = new Criteria(expression, parameters);

    const ct3: Criteria = ct1.or(ct2, parameters);

    expect(ct3.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct3.expression).toEqual(`${expression} OR (${expression})`);
    expect(ct3).toBeInstanceOf(Criteria);

  });

  it('it should return a Criteria class with "Expression" and "parameters" concatenaded as needed setted through "AND" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);

    const ct2: Criteria = ct1.and(expression, parameters);

    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct2.expression).toEqual(`${expression} AND ${expression}`);
    expect(ct2).toBeInstanceOf(Criteria);

  });


  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "AND" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);

    const ct2: Criteria = ct1.and(ct1, parameters);

    expect(ct2.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct2.expression).toEqual(`${expression} AND (${expression} AND )`);
    expect(ct2).toBeInstanceOf(Criteria);

  });

  it('it should return a Criteria class with "Criteria class" and "parameters" concatenaded as needed setted through "AND" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);
    const ct2: Criteria = new Criteria(expression, parameters);

    const ct3: Criteria = ct1.and(ct2, parameters);

    expect(ct3.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct3.expression).toEqual(`${expression} AND (${expression})`);
    expect(ct3).toBeInstanceOf(Criteria);

  });

  it('it should return a toJSON object with "Criteria class" and "parameters" concatenaded as needed setted through "AND" method', async () => {

    const criteriaParam: CriteriaParameter = new CriteriaParameter(CriteriaType.TYPE_DATE, 'PARAM VALUE');
    const parameters: Array<CriteriaParameter> = [criteriaParam];
    const expression: string = 'Expression';

    const ct1: Criteria = new Criteria(expression, parameters);
    const ct2: Criteria = new Criteria(expression, parameters);

    const ct3: Criteria = ct1.and(ct2, parameters);

    expect(ct3.parameters).toEqual([criteriaParam, criteriaParam]);
    expect(ct3.expression).toEqual(`${expression} AND (${expression})`);
    expect(ct3.toJSON()).toEqual(
      {
        expression: "Expression AND (Expression)",
        parameters: [
          { type: "D", value: "PARAM VALUE" },
          { type: "D", value: "PARAM VALUE" }
        ]
      }
    );

  });

  it('it should return a toJSON object with through empty constructor', async () => {

    const ct1: Criteria = new Criteria();

    expect(ct1.toJSON()).toEqual(undefined);

  });


});