import {
  CompassBooleanField,
  CompassEnumField,
  CompassFieldType,
} from '@atlassian/forge-graphql-types';
import {
  transformEnumGqlFields,
  transformFieldsToGql,
} from '../../helpers/transformFields';
import { TIER_MISSING_VALUE } from '../../helpers/constants';

const MOCK_TIER_FIELD_DEFINITION = {
  id: 'compass:tier',
  name: 'Tier',
  description: 'Component tier',
  type: CompassFieldType.Enum,
  options: {
    values: ['1', '2', '3', '4'],
    default: ['1'],
  },
};

const MOCK_MONOREPO_FIELD_DEFINITION = {
  id: 'compass:isMonorepoProject',
  name: 'Is Monorepo Project',
  description: 'Whether this is a monorepo project',
  type: CompassFieldType.Boolean,
  options: {},
};

const MOCK_ENUM_FIELD: CompassEnumField = {
  definition: MOCK_TIER_FIELD_DEFINITION,
  value: ['4'],
};

const MOCK_BOOLEAN_FIELD: CompassBooleanField = {
  definition: MOCK_MONOREPO_FIELD_DEFINITION,
  booleanValue: true,
};

describe('transformFields', () => {
  describe('transformEnumGqlFields', () => {
    it('should handle enum fields correctly', () => {
      const fields: Array<CompassEnumField | CompassBooleanField> = [
        MOCK_ENUM_FIELD,
      ];

      const result = transformEnumGqlFields(fields);
      expect(result).toEqual({
        'compass:tier': ['4'],
      });
    });

    it('should handle boolean fields correctly', () => {
      const fields: Array<CompassEnumField | CompassBooleanField> = [
        MOCK_BOOLEAN_FIELD,
      ];

      const result = transformEnumGqlFields(fields);
      expect(result).toEqual({
        'compass:isMonorepoProject': true,
      });
    });

    it('should handle mixed field types correctly', () => {
      const fields: Array<CompassEnumField | CompassBooleanField> = [
        MOCK_ENUM_FIELD,
        MOCK_BOOLEAN_FIELD,
      ];

      const result = transformEnumGqlFields(fields);
      expect(result).toEqual({
        'compass:tier': ['4'],
        'compass:isMonorepoProject': true,
      });
    });

    it('should skip fields with missing definition id', () => {
      const fields: Array<CompassEnumField | CompassBooleanField> = [
        {
          value: ['4'],
        } as CompassEnumField,
        MOCK_BOOLEAN_FIELD,
      ];

      const result = transformEnumGqlFields(fields);
      expect(result).toEqual({
        'compass:isMonorepoProject': true,
      });
    });

    it('should handle empty fields array', () => {
      const result = transformEnumGqlFields([]);
      expect(result).toEqual({});
    });

    it('should handle null fields', () => {
      const result = transformEnumGqlFields(null as any);
      expect(result).toEqual({});
    });
  });

  describe('transformFieldsToGql', () => {
    it('should transform tier field correctly', () => {
      const fields = {
        tier: ['4'],
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:tier',
          value: {
            enum: {
              value: ['4'],
            },
          },
        },
      ]);
    });

    it('should transform lifecycle field correctly', () => {
      const fields = {
        lifecycle: ['development'],
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:lifecycle',
          value: {
            enum: {
              value: ['Development'],
            },
          },
        },
      ]);
    });

    it('should transform true boolean field correctly', () => {
      const fields = {
        isMonorepoProject: true,
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:isMonorepoProject',
          value: {
            boolean: {
              booleanValue: true,
            },
          },
        },
      ]);
    });

    it('should transform false boolean field correctly', () => {
      const fields = {
        isMonorepoProject: false,
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:isMonorepoProject',
          value: {
            boolean: {
              booleanValue: false,
            },
          },
        },
      ]);
    });

    it('should transform false boolean field correctly if cast to string[]', () => {
      const fields = {
        isMonorepoProject: ['false'],
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:isMonorepoProject',
          value: {
            boolean: {
              booleanValue: false,
            },
          },
        },
      ]);
    });

    it('should transform true boolean field correctly if cast to string[]', () => {
      const fields = {
        isMonorepoProject: ['true'],
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:isMonorepoProject',
          value: {
            boolean: {
              booleanValue: true,
            },
          },
        },
      ]);
    });

    it('should handle mixed field types correctly', () => {
      const fields = {
        tier: ['4'],
        isMonorepoProject: true,
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([
        {
          definition: 'compass:tier',
          value: {
            enum: {
              value: ['4'],
            },
          },
        },
        {
          definition: 'compass:isMonorepoProject',
          value: {
            boolean: {
              booleanValue: true,
            },
          },
        },
      ]);
    });

    it('should throw error when tier value is missing', () => {
      const fields: Record<string, Array<string>> = {
        tier: [],
      };

      expect(() => transformFieldsToGql(fields)).toThrow(TIER_MISSING_VALUE);
    });

    it('should handle empty fields object', () => {
      const result = transformFieldsToGql({});
      expect(result).toEqual([]);
    });

    it('should ignore unknown field keys', () => {
      const fields = {
        unknownField: ['value'],
      };

      const result = transformFieldsToGql(fields);
      expect(result).toEqual([]);
    });
  });
});