import type { ComputedRef, Ref, VNode, VNodeChild } from 'vue';

/**
 * 任意类型的异步函数
 */

type AnyPromiseFunction<T extends any[] = any[], R = void> = (...arg: T) => Promise<R>;

/**
 * 任意类型的普通函数
 */
type AnyNormalFunction<T extends any[] = any[], R = void> = (...arg: T) => R;

/**
 * 任意类型的函数
 */
type AnyFunction<T extends any[] = any[], R = void> =
  | AnyNormalFunction<T, R>
  | AnyPromiseFunction<T, R>;

/**
 *  T | null 包装
 */
type Nullable<T> = T | null;

/**
 * T | Not null 包装
 */
type NonNullable<T> = T extends null | undefined ? never : T;

/**
 * 字符串类型对象
 */
type Recordable<T = any> = Record<string, T>;

/**
 * 字符串类型对象（只读）
 */
interface ReadonlyRecordable<T = any> {
  readonly [key: string]: T;
}

/**
 * setTimeout 返回值类型
 */
type TimeoutHandle = ReturnType<typeof setTimeout>;

/**
 * setInterval 返回值类型
 */
type IntervalHandle = ReturnType<typeof setInterval>;

/**
 * 也许它是一个Ref，或者一个普通的值
 *
 */
type MaybeRef<T> = T | Ref<T>;

/**
 * 也许它是一个 ref，或者一个普通值，或者一个 getter 函数
 *
 */
type MaybeComputedRef<T> = MaybeReadonlyRef<T> | MaybeRef<T>;

/**
 * 也许它是一个计算的 ref，或者一个 getter 函数
 *
 */
type MaybeReadonlyRef<T> = (() => T) | ComputedRef<T>;

/**
 * 包含label和value属性的下拉框
 *
 */
type LabelValueOptions = {
  label: string;
  value: any;
  [key: string]: string | number | boolean;
}[];

/**
 * 目标源打开方式
 *
 */
type TargetContext = '_self' | '_blank';

/**
 * 组件元素的类型
 */
interface ComponentElRef<T extends HTMLElement = HTMLDivElement> {
  $el: T;
}

/**
 * 组件的类型
 */
type ComponentRef<T extends HTMLElement = HTMLDivElement> = ComponentElRef<T> | null;

/**
 * HTML元素的类型
 */
type ElRef<T extends HTMLElement = HTMLDivElement> = Nullable<T>;

/**
 * 数组类型
 */
type Arrayable<T = any> = T[];

/**
 * 将类型转换为深可选
 */
type DeepPartial<T> = {
  [P in keyof T]?: DeepPartial<T[P]>;
};

/**
 * 动态props
 */
type DynamicProps<T> = {
  [P in keyof T]: Ref<T[P]> | T[P] | ComputedRef<T[P]>;
};

/**
 * 可变的
 */
type Mutable<T> = { -readonly [P in keyof T]: T[P] };

/**
 * 返回类型改为可选
 */
type PartialReturnType<T extends (...args: unknown[]) => unknown> = Partial<ReturnType<T>>;

type EmitType = (event: string, ...args: any[]) => void;

type VueNode = VNodeChild | JSX.Element;

namespace JSX {
  // tslint:disable no-empty-interface
  export type Element = VNode;
  export interface ElementAttributesProperty {
    $props: any;
  }
  export interface IntrinsicElements {
    [elem: string]: any;
  }
  export interface IntrinsicAttributes {
    [elem: string]: any;
  }
}

export {
  type AnyFunction,
  type AnyNormalFunction,
  type AnyPromiseFunction,
  type Arrayable,
  type ComponentElRef,
  type ComponentRef,
  type DeepPartial,
  type DynamicProps,
  type ElRef,
  type EmitType,
  type IntervalHandle,
  type LabelValueOptions,
  type MaybeComputedRef,
  type MaybeReadonlyRef,
  type MaybeRef,
  type Mutable,
  type NonNullable,
  type Nullable,
  type PartialReturnType,
  type ReadonlyRecordable,
  type Recordable,
  type TargetContext,
  type TimeoutHandle,
  type VueNode,
};