import {
  lazy,
  type ComponentType,
  type FocusEventHandler,
  type LazyExoticComponent,
  type PointerEventHandler,
  type TouchEventHandler,
} from 'react';

export interface ComponentModule<TProps = Record<string, never>> {
  default: ComponentType<TProps>;
}

export type PreloadableComponent<TProps = Record<string, never>> = LazyExoticComponent<
  ComponentType<TProps>
> & {
  preload: () => Promise<ComponentModule<TProps>>;
  read: () => ComponentModule<TProps> | undefined;
  clearPreload: () => void;
};

export interface PreloadableLike {
  preload: () => Promise<unknown>;
}

export interface PreloadAllOptions {
  settle?: boolean;
}

export interface IntentPreloadOptions {
  once?: boolean;
}

export interface IntentPreloadHandlers<TElement extends HTMLElement = HTMLElement> {
  onPointerEnter: PointerEventHandler<TElement>;
  onFocus: FocusEventHandler<TElement>;
  onTouchStart: TouchEventHandler<TElement>;
}

export function lazyWithPreload<TProps = Record<string, never>>(
  factory: () => Promise<ComponentModule<TProps>>,
): PreloadableComponent<TProps> {
  let promise: Promise<ComponentModule<TProps>> | undefined;
  let resolvedModule: ComponentModule<TProps> | undefined;
  let thrownError: unknown;

  const load = () => {
    if (!promise) {
      promise = factory().then(
        (module) => {
          resolvedModule = module;
          thrownError = undefined;
          return module;
        },
        (error: unknown) => {
          thrownError = error;
          promise = undefined;
          throw error;
        },
      );
    }

    return promise;
  };

  const LazyComponent = lazy(load) as PreloadableComponent<TProps>;

  LazyComponent.preload = load;

  LazyComponent.read = () => {
    if (thrownError) {
      throw thrownError;
    }

    return resolvedModule;
  };

  LazyComponent.clearPreload = () => {
    promise = undefined;
    resolvedModule = undefined;
    thrownError = undefined;
  };

  return LazyComponent;
}

export async function preloadAll(
  preloadables: Array<PreloadableLike | (() => Promise<unknown>)>,
  options: PreloadAllOptions = {},
): Promise<unknown[] | PromiseSettledResult<unknown>[]> {
  const promises = preloadables.map((item) =>
    typeof item === 'function' && !('preload' in item) ? item() : (item as PreloadableLike).preload(),
  );

  if (options.settle) {
    return Promise.allSettled(promises);
  }

  return Promise.all(promises);
}

export function createIntentPreloader<TElement extends HTMLElement = HTMLElement>(
  preload: () => Promise<unknown>,
  options: IntentPreloadOptions = {},
): IntentPreloadHandlers<TElement> {
  const once = options.once ?? true;
  let hasStarted = false;

  const start = () => {
    if (once && hasStarted) {
      return;
    }

    hasStarted = true;
    void preload();
  };

  return {
    onPointerEnter: start,
    onFocus: start,
    onTouchStart: start,
  };
}