/* eslint-disable @typescript-eslint/ban-ts-comment */
import { handleFeatureFlags } from '../../../core/featureFlags/featureFlagHandler';
import FeatureFlagManager from '../../../core/featureFlags/featureFlagManager';
import { getSupportedFeatureFlags } from '../../../core/featureFlags/helpers';
import { manageFeatureToggles } from '../../../core/featureFlags/manageFeatureToggles';

jest.mock('../../../core/featureFlags/featureFlagManager', () => ({
  setFeatureFlag: jest.fn(),
  featureFlags: {},
}));

jest.mock('../../../core/featureFlags/helpers', () => ({
  getSupportedFeatureFlags: jest.fn(),
}));

jest.mock('../../../core/featureFlags/manageFeatureToggles', () => ({
  manageFeatureToggles: jest.fn(),
}));

describe('handleFeatureFlags', () => {
  const mockBridgeConfig = {
    feature_flags: [
      { name: 'featureA', enabled: true },
      { name: 'featureB', enabled: false },
    ],
  };
  const mockBridgeConfigString = JSON.stringify(mockBridgeConfig);
  let originalDev: boolean;

  beforeEach(() => {
    jest.clearAllMocks();
  });

  describe('in development mode', () => {
    beforeEach(() => {
      // @ts-ignore - __DEV__ is a global variable
      global.__DEV__ = true;
    });

    afterEach(() => {
      // @ts-ignore - __DEV__ is a global variable
      global.__DEV__ = originalDev;
    });

    it('should call manageFeatureToggles and exit early', () => {
      handleFeatureFlags('{}');

      expect(manageFeatureToggles).toHaveBeenCalled();
      expect(getSupportedFeatureFlags).not.toHaveBeenCalled();
      expect(FeatureFlagManager.setFeatureFlag).not.toHaveBeenCalled();
    });
  });

  describe('in production mode', () => {
    beforeEach(() => {
      // @ts-ignore - __DEV__ is a global variable
      global.__DEV__ = false;
    });

    afterEach(() => {
      // @ts-ignore - __DEV__ is a global variable
      global.__DEV__ = originalDev;
    });

    it('should do nothing if featureFlags is undefined', () => {
      handleFeatureFlags('{}');

      expect(getSupportedFeatureFlags).not.toHaveBeenCalled;
    });

    it('should do nothing if getSupportedFeatureFlags returns null or undefined', () => {
      (getSupportedFeatureFlags as jest.Mock).mockReturnValue(null);

      handleFeatureFlags(mockBridgeConfigString);

      expect(getSupportedFeatureFlags).toHaveBeenCalled();
      expect(FeatureFlagManager.setFeatureFlag).not.toHaveBeenCalled();
      expect(manageFeatureToggles).not.toHaveBeenCalled();
    });

    it('should apply supported feature flags and call manageFeatureToggles', () => {
      const mockFeatureFlags = [
        { name: 'featureA', enabled: true },
        { name: 'featureB', enabled: false },
      ];
      (getSupportedFeatureFlags as jest.Mock).mockReturnValue(mockFeatureFlags);

      // @ts-ignore - We are testing the behavior of the function
      FeatureFlagManager.featureFlags = { featureA: false, featureB: true };

      handleFeatureFlags(mockBridgeConfigString);

      expect(getSupportedFeatureFlags).toHaveBeenCalledWith(mockFeatureFlags);
      expect(FeatureFlagManager.setFeatureFlag).toHaveBeenCalledTimes(2);
      expect(FeatureFlagManager.setFeatureFlag).toHaveBeenCalledWith(
        'featureA',
        true
      );
      expect(FeatureFlagManager.setFeatureFlag).toHaveBeenCalledWith(
        'featureB',
        false
      );
      expect(manageFeatureToggles).toHaveBeenCalled();
    });

    it('should skip setting feature flags that are not in FeatureFlagManager', () => {
      const mockFeatureFlags = [
        { name: 'featureA', enabled: true },
        { name: 'unknownFeature', enabled: true },
      ];
      (getSupportedFeatureFlags as jest.Mock).mockReturnValue(mockFeatureFlags);

      // @ts-ignore - We are testing the behavior of the function
      FeatureFlagManager.featureFlags = { featureA: false };

      handleFeatureFlags(mockBridgeConfigString);

      expect(FeatureFlagManager.setFeatureFlag).toHaveBeenCalledTimes(1);
      expect(FeatureFlagManager.setFeatureFlag).toHaveBeenCalledWith(
        'featureA',
        true
      );
      expect(FeatureFlagManager.setFeatureFlag).not.toHaveBeenCalledWith(
        'unknownFeature',
        true
      );
      expect(manageFeatureToggles).toHaveBeenCalled();
    });
  });
});