import type { ModalBuiltinKey } from '../constants/modalBuiltinKeys';

export type ModalAction = 'end' | 'cancel';

export type { ModalBuiltinKey };

/** 内置弹层类型 */
export type BuiltinModalType = 'modal' | 'drawer' | 'popover';

/** 与 {@link BuiltinModalType} 相同，保留兼容 */
export type ModalType = BuiltinModalType;

/**
 * 用户可通过 module augmentation 扩展的弹层类型注册表。
 * @example
 * declare module 'use-modal-ref' {
 *   interface ModalTypeRegistry {
 *     sidePanel: ModalTypeItem;
 *   }
 * }
 */
// eslint-disable-next-line @typescript-eslint/no-empty-interface
export interface ModalTypeRegistry {}

/** 内置 + 用户扩展的弹层类型 */
export type ExtendedModalType = BuiltinModalType | Extract<keyof ModalTypeRegistry, string>;

export type ModalTypeItem = {
  visible: string,
  onClose: string,
};

/** 内置弹层类型的默认字段映射（字面量，用于 props 类型推导） */
export type BuiltinModalTypeMap = {
  modal: { readonly visible: 'visible', readonly onClose: 'onCancel' },
  drawer: { readonly visible: 'visible', readonly onClose: 'onClose' },
  popover: { readonly visible: 'visible', readonly onClose: 'onClose' },
};

/** 内置映射 + 用户扩展映射（扩展项运行时通过 mergeModalType 注册，编译期可选） */
export type MergeableModalTypeMap = BuiltinModalTypeMap & {
  [K in keyof ModalTypeRegistry]?: ModalTypeRegistry[K];
};

/** mergeModalType 入参：允许覆盖内置类型的字段映射为任意字符串 */
export type MergeModalTypeInput = Partial<{
  [K in keyof MergeableModalTypeMap]: ModalTypeItem;
}>;

export type ModalTypeMap = {
  // eslint-disable-next-line no-unused-vars
  [key in BuiltinModalType]: ModalTypeItem
} & ModalTypeRegistry;

type EndModalMethod<U = any> = (result?: U, onDone?: () => void) => Promise<void>;
type CancelModalMethod<R = unknown> = (ex?: R, onDone?: () => void) => Promise<void>;

type BuildModalPropsFromItem<Item extends ModalTypeItem> = {
  readonly [K in Item['visible']]: boolean;
} & {
  readonly [K in Item['onClose']]: CancelModalMethod;
};

/** 将显隐字段名 From 替换为 To（用于 visibleKey 泛型） */
type ReplaceVisibleProp<
  Props,
  From extends string,
  To extends string,
> = Omit<Props, From> & Record<To, boolean>;

type RegistryModalTypeItem<P extends keyof ModalTypeRegistry> =
  ModalTypeRegistry[P] extends ModalTypeItem ? ModalTypeRegistry[P] : ModalTypeItem;

type PropsFromTypeItem<
  Item extends ModalTypeItem,
  VK extends string | undefined = undefined,
> = VK extends string
  ? ReplaceVisibleProp<
    BuildModalPropsFromItem<Item>,
    Item['visible'],
    VK
  >
  : BuildModalPropsFromItem<Item>;

/** modal.props 类型：P 决定默认字段名，VK 覆盖显隐字段名 */
export type ModalRefProps<
  P extends ExtendedModalType,
  VK extends string | undefined = undefined,
> = P extends BuiltinModalType
  ? PropsFromTypeItem<BuiltinModalTypeMap[P], VK>
  : P extends keyof ModalTypeRegistry
    ? PropsFromTypeItem<RegistryModalTypeItem<P>, VK>
    : Record<string, unknown>;

/** @deprecated 请优先使用 ModalRefProps<P>；保留以兼容旧引用 */
export type ModalPropsTypeMap = {
  [P in BuiltinModalType]: ModalRefProps<P>;
};

export type ModalBeforeCloseHandler = (
  next: (ok: any) => void,
  action: ModalAction,
) => void | Promise<void>;

/** 结束关闭前钩子：可改写 endModal / resolve 的最终返回值 */
export type ModalBeforeEndHandler<U = any> = (
  value?: U,
) => Promise<U | undefined | void>;

/** 取消关闭前钩子：可改写 cancel 原因 / reject 值 */
export type ModalBeforeCancelHandler<R = unknown> = (
  reason?: R,
) => Promise<R | undefined | void>;

export type ModalModalOptions<U = any, R = unknown> = {
  modalDataEvent?: boolean,
  afterModal?: (newData: any, options?: ModalModalOptions<U, R>) => void,
  beforeCloseModal?: ModalBeforeCloseHandler,
  beforeEndModal?: ModalBeforeEndHandler<U>,
  beforeCancelModal?: ModalBeforeCancelHandler<R>,
  afterCloseModal?: (
    newData: any,
    action: ModalAction,
    modal: ModalRef<any, any, any, any, any, any>
  ) => void | Promise<void>;

  forceVisible?: boolean,
  alwaysResolve?: boolean,
  [key: string]: any
};

/** 从 custom 泛型中排除 modal 内置属性键 */
export type ModalCustomMap<C extends Record<string, any>> = {
  [K in keyof C as K extends ModalBuiltinKey ? never : K]: C[K];
};

/** 将 Hook options 泛型 O 规范为可用于类型推断的对象形状（默认宽 ModalRefOption 时不做字面量推断） */
export type ResolveHookOptions<O> = ModalRefOption<any, any, any, any, any> extends O ? {} : O;

/** 从 options.custom 字面量推断 custom 形状（忽略宽类型与 undefined） */
export type ExtractCustomMap<O> = O extends { custom: infer Raw extends Record<string, any> }
  ? undefined extends Raw
    ? {}
    : string extends keyof Raw
      ? {}
      : ModalCustomMap<Raw>
  : {};

/** 合并显式 C 泛型与 options.custom 推断 */
export type ResolveCustomMap<
  C extends Record<string, any>,
  O,
> = keyof ExtractCustomMap<O> extends never
  ? ModalCustomMap<C>
  : ExtractCustomMap<O>;

/** 从 options.visibleKey 字面量推断 VK（忽略宽 string 类型） */
type IsLiteralString<S> = string extends S ? false : S extends string ? true : false;

export type ExtractVisibleKey<O> = O extends { visibleKey: infer VK }
  ? IsLiteralString<VK> extends true ? VK : undefined
  : undefined;

/** 合并显式 VK 泛型与 options.visibleKey 推断 */
export type ResolveVisibleKey<
  VK extends string | undefined,
  O,
> = ExtractVisibleKey<O> extends infer Inferred
  ? [Inferred] extends [undefined]
    ? VK
    : Inferred extends string
      ? Inferred
      : VK
  : VK;

export type ModalRefOption<
  P extends ExtendedModalType,
  T extends Record<string, any>,
  U,
  C extends Record<string, any> = {},
  R = unknown,
> = {
  useImperativeHandle?: boolean,
  alwaysResolve?: boolean,
  /** 覆盖 modalTypeMap 默认显隐字段名，生成 modal.props.[visibleKey]（如 Ant Design 5 Drawer 使用 open） */
  visibleKey?: string,
  /** 自定义属性，不可使用 modal 内置属性名（如 modal、visible、endModal 等） */
  custom?: ModalCustomMap<C>,
  /** 打开前钩子（仅通过 options 配置，不暴露在 modal 公开 API 上） */
  beforeModal?: (
    newData: Partial<T>,
    pause: (result: any, isError?: boolean) => void, options: Record<string, any>
  ) => void | Partial<T> | Promise<void | Partial<T>>;
  afterModal?: (newData: any, options?: ModalModalOptions<U, R>) => void | Promise<void>;
  init?: (newData: T, options: Record<string, any>) => void | Promise<void>;
  beforeCloseModal?: (
    next: (ok: any) => void,
    action: ModalAction,
    modal: ModalRef<P, T, U, C, undefined, R>,
  ) => void | Promise<void>;
  afterCloseModal?: (
    newData: T,
    action: ModalAction,
    modal: ModalRef<P, T, U, C, undefined, R>,
  ) => void | Promise<void>;

  [key: string]: any
};

/** modal.data 只读数据形状 */
export type ModalRefData<T extends Record<string, any>> = Partial<Omit<T, 'onCancel' | 'onOK'>> & {
  [key: string]: any
};

export type ModalRef<
  P extends ExtendedModalType = 'modal',
  T extends Record<string, any> = Record<string, any>,
  U = any,
  C extends Record<string, any> = {},
  VK extends string | undefined = undefined,
  R = unknown,
> = {
  readonly visible: boolean;
  readonly data: ModalRefData<T>;
  readonly props: ModalRefProps<P, VK>;
  readonly options: ModalRefOption<P, T, U, C, R>;
  readonly modalOptions: ModalModalOptions<U, R>;
  readonly modalPromise: Promise<U> | null;

  modal(newData?: Partial<T>, options?: ModalModalOptions<U, R>): Promise<U>;

  endModal: EndModalMethod<U>;
  cancelModal: CancelModalMethod<R>;
} & ModalCustomMap<C>;

/** useCommonRef / useModalRef / useDrawerRef 返回值 */
export type UseCommonRefReturn<
  P extends ExtendedModalType,
  T extends Record<string, any>,
  U = any,
  C extends Record<string, any> = {},
  VK extends string | undefined = undefined,
  R = unknown,
> = {
  modal: ModalRef<P, T, U, C, VK, R>;
  data: T;
  setData: (newData: T | ((data: T) => T)) => void;
};

export interface ModalResult<P extends ExtendedModalType, T = Partial<any>> {
  modal: ModalRef<P, ModalData>,
  data: T,
}

export interface ModalData extends Partial<any> {
  onOK?: (data: any) => any;
  onCancel?: (data: any) => any;

  [key: string]: any;
}

export interface ModalVisibleProps {
  pending?: Promise<any>,
  resolve: (value: any) => any,
  reject: (value: any) => any
}

/** 允许按字符串动态访问方法的 modal ref（命令式 API 使用） */
export type ModalRefDynamic = ModalRef<any, any, any, any, any, any> & Record<string, any>;

export type { EndModalMethod, CancelModalMethod };