// Used in React hooks to indicate empty deps are intentional.
import { MaybePromise, Nullable, WritableProps } from 'tsdef';

import { FileAction, FileActionEffect } from '../types/action.types';
import { Logger } from './logger';

// Used in contexts that need to provide some default value for a function.
// eslint-disable-next-line no-unused-vars,@typescript-eslint/no-unused-vars
export const NOOP_FUNCTION = (...args: any[]) => {
  Logger.warn(
    `The "NOOP_FUNCTION" from the constants module was called. ` +
      `This can indicate a bug in one of the components. Supplied args:`,
    args,
  );
};

export const isPromise = <T>(value: MaybePromise<T> | any): value is Promise<T> => {
  if (typeof value !== 'object' || !value) return false;
  const then = (value as Promise<T>).then;
  return then && typeof then === 'function';
};

export const defineFileAction = <Action extends FileAction>(
  action: Action,
  effect?: FileActionEffect<FileAction>,
): WritableProps<Action> => {
  if (action.__payloadType !== undefined && (action.hotkeys || action.button)) {
    const errorMessage =
      `Invalid definition was provided for file action "${action.id}". Actions ` +
      `that specify hotkeys or buttons cannot define a payload type. If ` +
      `your application requires this functionality, define two actions ` +
      `and chain them using effects.`;
    Logger.error(errorMessage);
    throw new Error(errorMessage);
  }

  action.effect = effect;
  return action;
};

/**
 * Recursively check the current element and the parent elements, going bottom-up.
 * Returns the first element to match the predicate, otherwise returns null if such
 * element is not found.
 */
export const findElementAmongAncestors = (
  maybeElement: HTMLElement | any,
  predicate: (maybeElement: HTMLElement | any) => boolean,
): Nullable<HTMLElement> => {
  if (!maybeElement) return maybeElement;

  if (predicate(maybeElement)) return maybeElement;

  if (maybeElement.parentElement) {
    return findElementAmongAncestors(maybeElement.parentElement, predicate);
  }

  return null;
};

export const elementIsInsideButton = (buttonCandidate: HTMLElement | any): boolean => {
  return !!findElementAmongAncestors(
    buttonCandidate,
    (element: any) => element.tagName && element.tagName.toLowerCase() === 'button',
  );
};

export const getValueOrFallback = <T extends any>(
  value: T | undefined,
  fallback: T,
  desiredType?: 'boolean' | 'string' | 'number',
): NonNullable<T> => {
  if (desiredType) {
    return (typeof value === desiredType ? value : fallback) as NonNullable<T>;
  }
  return (value !== undefined ? value : fallback) as NonNullable<T>;
};