import { SubscriberObj } from "../../functionUtils";
import { HOOKS_EVENTS } from "./constants";

export interface HookConfiguration {}

/* existing Hook Plugn props: sample */

/*
interface _HookModulePlugin {
  Component:
    | React.FC<HookPluginProps>
    | React.Component<HookPluginProps, any>
    | React.ReactNode;
  ModalContainer?: React.FC<ModalProps> | React.Component<ModalProps, any>;
  skipHook?: (payload: ZappRiver | ZappEntry) => boolean;
  presentFullScreen: boolean;
  showNavBar?: boolean;
  isFlowBlocker: (() => boolean) | boolean; // narrow this
  hasPlayerHook?: boolean;
  name: string;
  runInBackground?: (
    item: HookPluginProps["payload"],
    callback: hookCallback,
    hookPlugin: HookScreenData,
    presentUI: (payload?: HookPluginProps["payload"]) => void
  ) => any;
}
*/

//* Derived from usage */
export interface HookModule {
  ModalContainer?: React.ComponentType<any>;
  Component: React.ComponentType<any>;
  presentFullScreen: boolean;
  run?: (
    arg0: unknown,
    callback: () => void,
    configuration: HookConfiguration
  ) => void; // not sure about optional parameter
  hasPlayerHook?: boolean;
  configuration?: HookConfiguration;
  isFlowBlocker: () => boolean;
  skipHook?: (payload?: ZappRiver | ZappEntry) => boolean;
  runInBackground?: (
    arg0: unknown,
    callback: () => void,
    hookPlugin: Hook,
    presentUI: (payload?: HookPluginProps["payload"]) => void
  ) => void;
  name: string;
  showNavBar?: boolean; // unsure
}

export type HookManagerArgs = {
  rivers: Record<string, ZappRiver>;
  plugins: ZappPlugin[];
  targetScreen: ZappRiver;
  startUpHooksData?: {
    startUpHooks?: unknown[] | "in_process";
    setStartUpHooks?: (arg0: string) => void;
  };
};

export interface HookManager {
  subscriber: SubscriberObj;
  presentScreenHook: (
    hook: Hook,
    payload: unknown,
    callback: (...any) => void
  ) => void;
  executeHook: (
    hook: Hook,
    payload: unknown,
    callback: (...any) => void
  ) => void;
  handleHooks: (payload: unknown) => void;
  runInBackground: (
    hook: Hook,
    payload: unknown,
    callback: (...any) => void,
    presentUI: (payload?: HookPluginProps["payload"]) => void
  ) => void;
}

export type HookIniObj = {
  hook: HookModule & {
    module: HookModule;
    general: unknown;
    screen_id?: string;
    identifier?: string;
    weight?: number | string;
  };
  hooks: Hook<any>[];
  manager: HookManager;
};

export interface Hook<T extends HookModule = HookModule> {
  manager: HookManager;
  lastHook: boolean;
  state: number;
  module: T;
  screen_id: string;
  identifier: string;
  configuration: T["configuration"];
  setStateAndNotify(
    event: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS],
    opts: {
      error?: typeof Error;
      route?: string;
      hookPlugin: Hook<T>;
      payload: unknown;
    }
  );
  general?: {
    transition_type: (typeof HOOKS_EVENTS)[keyof typeof HOOKS_EVENTS];
    allow_screen_plugin_presentation: boolean;
    is_flow_blocker: boolean;
  };
}