import { FeatureFlag } from '@globalpayments/vega';
import { waitForVega } from '@globalpayments/vega';
import type { RenderResult } from '@testing-library/angular';

type Nullable<T> = T | undefined | null;

/**
 * @deprecated This utility is deprecated. Use `waitForVega` from `@heartlandone/vega-testing-library` directly.
 * The `vega-testing-library` package supports Jest fake timers and does not require a `RenderResult` argument.
 * Install it separately: `npm install @heartlandone/vega-testing-library`
 */
export async function waitForVegaReady(
  renderResult: RenderResult<unknown, unknown>,
  delay: number = 300,
): Promise<RenderResult<unknown, unknown>> {
  await waitForVega();

  /*
     * The following code is added to load the vega component, and the attribute value is set after each component is loaded.
     * To determine whether there is a hydrated style that cannot meet the requirements after the component is loaded,
     * It need to set the sleep time to ensure that each attribute of the vega component is fully loaded
     *
     code link: ./node_modules/vega-react/dist/react-component-lib/utils/attachProps.js(line 28-33)}
    */
  await sleep(delay);
  return renderResult;
}

/**
 * @deprecated This type is deprecated. Use `MockedResizeObserverController` from `@heartlandone/vega-testing-library` directly.
 * Install it separately: `npm install @heartlandone/vega-testing-library`
 */
export type MockedResizeObserverController = {
  hide: (selector: string, container?: HTMLElement) => void;
  show: (selector: string, container?: HTMLElement) => void;
};

/**
 * @deprecated This function is deprecated. Use `mockResizeObserver` from `@heartlandone/vega-testing-library` directly.
 * Install it separately: `npm install @heartlandone/vega-testing-library`
 */
export function mockResizeObserver(): MockedResizeObserverController {
  type MockedResizeObserver = ResizeObserver & {
    show: () => void;
    hide: () => void;
  };
  FeatureFlag.disable('VEGA_ANGULAR.USE_JUGGLE_RESIZE_OBSERVER');
  const resizeObserverElementMap: Map<HTMLElement, MockedResizeObserver> = new Map();
  const VegaResizeObserver: unknown = class {
    private readonly callback: ResizeObserverCallback;
    private observedElements: HTMLElement[] = [];
    constructor(callback: ResizeObserverCallback) {
      this.callback = callback;
    }

    observe(element: HTMLElement): void {
      if (!this.isObserved(element)) {
        resizeObserverElementMap.set(element, this);
        this.observedElements.push(element);
      }
    }

    unobserve(element: HTMLElement): void {
      if (this.isObserved(element)) {
        resizeObserverElementMap.delete(element);
        this.observedElements = this.observedElements.filter(
          (observedElement: HTMLElement) => observedElement !== element,
        );
      }
    }

    disconnect(): void {
      for (const element of this.observedElements) {
        resizeObserverElementMap.delete(element);
      }
      this.observedElements = [];
    }

    show(): void {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      this.callback([{ contentRect: { height: 100 } }] as any, this);
    }

    hide(): void {
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      this.callback([{ contentRect: { height: 0 } }] as any, this);
    }

    private isObserved(element: HTMLElement): boolean {
      return this.observedElements.includes(element);
    }
  };
  Object.assign(window, { VegaResizeObserver });
  return {
    show: (selector: string, container?: HTMLElement): void => {
      (container || document)
        .querySelectorAll(selector)
        // eslint-disable-next-line unicorn/no-array-for-each
        .forEach((el: Element) => {
          const resizeObserver: Nullable<MockedResizeObserver> = resizeObserverElementMap.get(
            el as HTMLElement,
          );
          if (resizeObserver) {
            resizeObserver.show();
          }
        });
    },
    hide: (selector: string, container?: HTMLElement): void => {
      (container || document)
        .querySelectorAll(selector)
        // eslint-disable-next-line unicorn/no-array-for-each
        .forEach((el: Element) => {
          const resizeObserver: Nullable<MockedResizeObserver> = resizeObserverElementMap.get(
            el as HTMLElement,
          );
          if (resizeObserver) {
            resizeObserver.hide();
          }
        });
    },
  };
}

function sleep(ms: number): Promise<void> {
  return new Promise((resolve: () => void) => {
    setTimeout(resolve, ms);
  });
}