/**
 * Copyright IBM Corp. 2024, 2025
 */

import { convertToExecutableFormat } from '../../src/helpers/condition-converter.js';

describe('condition-converter', () => {
  describe('convertToExecutableFormat', () => {
    it('should return empty string for empty input', () => {
      expect(convertToExecutableFormat('')).toBe('');
    });

    it('should return empty string for null/undefined input', () => {
      expect(convertToExecutableFormat(null as any)).toBe('');
      expect(convertToExecutableFormat(undefined as any)).toBe('');
    });

    it('should convert AND/OR operators to lowercase', () => {
      const input = '${var1} equals 100 AND ${var2} equals 200';
      const expected = '${var1} == 100 and ${var2} == 200';
      expect(convertToExecutableFormat(input)).toBe(expected);

      const inputOr = '${var1} equals 100 OR ${var2} equals 200';
      const expectedOr = '${var1} == 100 or ${var2} == 200';
      expect(convertToExecutableFormat(inputOr)).toBe(expectedOr);
    });

    it('should convert NOT operator to lowercase', () => {
      const input = 'NOT ${var1} equals 100';
      const expected = 'not ${var1} == 100';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert equalsIgnoreCase operator', () => {
      const input = '${requestHeaders.abc} equalsIgnoreCase test';
      const expected = '${requestHeaders.abc}_lowercase == test_lowercase';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert notEqualsIgnoreCase operator', () => {
      const input = '${requestHeaders.abc} notEqualsIgnoreCase test';
      const expected = '${requestHeaders.abc}_lowercase != test_lowercase';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert contains operator with array', () => {
      const input = '${response.name} contains ["victor", "sangeeth"]';
      const expected = '${response.name} in ("victor", "sangeeth")';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert notContains operator with array', () => {
      const input = '${response.name} notContains ["victor", "sangeeth"]';
      const expected = '${response.name} not in ("victor", "sangeeth")';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert exists operator', () => {
      const input = '${requestHeaders.abc} exists';
      const expected = 'exists(${requestHeaders.abc})';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert notExists operator', () => {
      const input = '${requestHeaders.abc} notExists';
      const expected = 'not exists(${requestHeaders.abc})';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert empty operator', () => {
      const input = '${requestHeaders.abc} empty';
      const expected = 'empty(${requestHeaders.abc})';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert range operator', () => {
      const input = '${value} range [10, 20]';
      const expected = '(${value} >= 10 and ${value} <= 20)';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert containsKey operator and swap operands', () => {
      const input = '${requestHeaders} containsKey Content-Type';
      const expected = 'Content-Type of ${requestHeaders}';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert containsKey with quoted key', () => {
      const input = '${requestHeaders} containsKey "Content-Type"';
      const expected = '"Content-Type" of ${requestHeaders}';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert containsKey with complex variable path', () => {
      const input = '${response.headers} containsKey x-api-key';
      const expected = 'x-api-key of ${response.headers}';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert containsKey in complex condition', () => {
      const input =
        '(${requestHeaders} containsKey Content-Type and ${response} equals sss)';
      const expected =
        '(Content-Type of ${requestHeaders} and ${response} == sss)';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert multiple containsKey operators', () => {
      const input =
        '${requestHeaders} containsKey Content-Type and ${response.headers} containsKey x-api-key';
      const expected =
        'Content-Type of ${requestHeaders} and x-api-key of ${response.headers}';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should convert comparison operators', () => {
      expect(convertToExecutableFormat('${var} equals 100')).toBe(
        '${var} == 100',
      );
      expect(convertToExecutableFormat('${var} notEquals 100')).toBe(
        '${var} != 100',
      );
      expect(convertToExecutableFormat('${var} greaterThan 100')).toBe(
        '${var} > 100',
      );
      expect(convertToExecutableFormat('${var} lessThan 100')).toBe(
        '${var} < 100',
      );
      expect(convertToExecutableFormat('${var} greaterThanOrEqual 100')).toBe(
        '${var} >= 100',
      );
      expect(convertToExecutableFormat('${var} lessThanOrEqual 100')).toBe(
        '${var} <= 100',
      );
    });

    it('should handle complex conditions with multiple operators', () => {
      const input =
        '${requestHeaders.abc} equals 100 AND ${response.name} contains ["victor", "sangeeth"]';
      const expected =
        '${requestHeaders.abc} == 100 and ${response.name} in ("victor", "sangeeth")';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });

    it('should handle case-insensitive operator keywords', () => {
      const input = '${var1} EQUALS 100 and ${var2} CONTAINS ["test"]';
      const expected = '${var1} == 100 and ${var2} in ("test")';
      expect(convertToExecutableFormat(input)).toBe(expected);
    });
  });
});