import {type UniDriverList} from '@wix/unidriver-core';
import {type DriverContext} from '@wix/unidriver-core/internal';
import {jsdomReactUniDriver} from './jsdomReactUniDriver';

export const jsdomReactUniDriverList = (
  adapterParams: (() => Element[]) | Element[] | (() => Promise<Element[]>),
  context: DriverContext = {selector: 'Root React list driver'},
): UniDriverList => {
  const isPromise = (a: unknown): a is Promise<any> => {
    // @ts-expect-error we don't care about deprecated adapter types
    return !!a.then;
  };

  const getBaseElement = async () => {
    const elements = typeof adapterParams === 'function' ? adapterParams() : adapterParams;

    return isPromise(elements) ? await elements : elements;
  };

  const at = (idx: number) => {
    return jsdomReactUniDriver(
      async () => {
        const base = await getBaseElement();
        const element = base[idx];
        if (!element) {
          throw new Error('React base driver - element was not found');
        } else {
          return element;
        }
      },
      {...context, idx},
    );
  };

  const createUniDriver = (element: Element, idx: number) => {
    return jsdomReactUniDriver(element, {
      parent: context,
      idx,
      selector: context.selector,
    });
  };

  const api: UniDriverList<HTMLElement> & {
    getType: () => void;
  } = {
    getType: () => {
      throw new Error(`Not implemented. Deprecated adapter - migrate to "@wix/unidriver-jsdom-react"`);
    },
    at,
    text: async () => (await getBaseElement()).map((e) => (e.textContent as string | null) ?? ''),
    count: async () => (await getBaseElement()).length,
    map: async (fn) => {
      const base = Array.from(await getBaseElement());

      return Promise.all(
        base.map((element, idx) => {
          return fn(createUniDriver(element, idx), idx);
        }),
      );
    },
    filter: (fn) => {
      return jsdomReactUniDriverList(async () => {
        const base = await getBaseElement();

        const filterResults = await Promise.all(
          base.map((element, idx) => {
            return fn(createUniDriver(element, idx), idx);
          }),
        );

        return base.filter((_, i) => {
          return filterResults[i];
        });
      }, context);
    },
    get: at,
    find: (fn) => api.filter(fn).at(0),
    async some(fn) {
      const base = await getBaseElement();
      for (let idx = 0; idx < base.length; idx++) {
        if (await fn(createUniDriver(base[idx]!, idx), idx)) {
          return true;
        }
      }
      return false;
    },
    async every(fn) {
      const base = await getBaseElement();
      const results = await Promise.all(
        base.map((element, idx) => {
          return fn(createUniDriver(element, idx), idx);
        }),
      );

      return results.every(Boolean);
    },
    type: 'react' as const,
  };

  return api;
};