import { ReactNode } from 'react';

type ExtractArgs<T extends object> = T[keyof T] extends (...args: infer A) => any ? A : any[];
type EventState<T extends object, Args extends unknown[] = ExtractArgs<T>> = T & {
    (key?: keyof T, fun?: T[keyof T]): EventState<T, Args>;
    (target?: Partial<T>): EventState<T, Args>;
};

type Vec2 = [x: number, y: number];

type DragDevice = 'mouse' | 'touch' | 'pointer';
interface DragState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    device: DragDevice;
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    target: El;
    event: Event;
    memo: any;
    isDragStart: boolean;
    isDragging: boolean;
    isDragEnd: boolean;
    drag(self: DragState<El>): void;
    dragStart(e: Event): void;
    dragging(e: Event): void;
    dragEnd(e: Event): void;
    mount(target: El): void;
    clean(el: null): void;
    ref(traget: El | null): void;
}
type DragArg<El extends Element> = Partial<DragState<El>> | DragState<El>['drag'];

declare const useDrag: <El extends Element = Element>(arg: DragArg<El>) => EventState<DragState<El>>;

interface DragProps<El extends Element = Element> extends Partial<DragState<El>> {
    children(self: DragState<El>): ReactNode;
}
declare const Drag: <El extends Element = Element>(props: DragProps<El>) => ReactNode;

interface HoverState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    device: 'mouse' | 'pointer' | 'touch';
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    event: Event;
    target: El;
    isHoverStart: boolean;
    isHovering: boolean;
    isHoverEnd: boolean;
    hover: (self: HoverState) => void;
    hoverStart(e: Event): void;
    hovering(e: Event): void;
    hoverEnd(e: Event): void;
    mount(target: El): void;
    clean(target?: El): void;
    ref(target: El | null): void;
}
type HoverArg<El extends Element = Element> = Partial<HoverState<El>> | HoverState<El>['hover'];

declare const useHover: <El extends Element = Element>(arg?: HoverArg) => EventState<HoverState<El>>;

interface HoverProps<El extends Element = Element> extends Partial<HoverState<El>> {
    children: (state: HoverState<El>) => ReactNode;
}
declare const Hover: (props: HoverProps) => ReactNode;

interface KeyState<El extends Element = Element> {
    target: El | Window;
    pressedKey: string;
    code: string;
    event: KeyboardEvent;
    key(e: KeyState): void;
    keydown(e: KeyboardEvent): void;
    mount(el: El): void;
    clean(el: null): void;
    ref(el: Element | null): void;
}
type KeyArg<El extends Element = Element> = Partial<KeyState<El>> | KeyState<El>['key'];

declare const useKey: <El extends Element = Element>(arg: KeyArg<El>) => EventState<KeyState<El>>;
interface KeyProps<El extends Element = Element> extends Partial<KeyState<El>> {
    children: (state: KeyState<El>) => ReactNode;
}
declare const Key: <El extends Element = Element>(props: KeyProps<El>) => ReactNode;

type PinchDevice = 'mouse' | 'pointer' | 'touch' | 'wheel' | 'gesture';
interface PinchState<El extends Element = Element> {
    device: PinchDevice;
    active: boolean;
    _active: boolean;
    value: Vec2;
    _value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    initial: Vec2;
    origin: Vec2;
    _touchIds: number[];
    _pointerEvents: Map<number, PointerEvent>;
    scale: number;
    turns: number;
    target: El;
    event: Event | null;
    memo: Record<string, unknown>;
    timeout: number;
    clearTimeout: () => void;
    isPinchStart: boolean;
    isPinching: boolean;
    isPinchEnd: boolean;
    pinch: (self: PinchState<El>) => void;
    pinchStart: (e: Event) => void;
    pinching: (e: Event) => void;
    pinchEnd: (e: Event) => void;
    mount: (target: El) => void;
    clean: () => void;
    ref: (el: El | null) => void;
}
type PinchArg<El extends Element = Element> = Partial<PinchState<El>> | PinchState<El>['pinch'];

declare const usePinch: <El extends Element = Element>(arg?: PinchArg) => EventState<PinchState<El>>;

interface PinchProps<El extends Element = Element> extends Partial<PinchState<El>> {
    children: (state: PinchState<El>) => ReactNode;
}
declare const Pinch: (props: PinchProps) => ReactNode;

interface ResizeState<El extends Element = Element> {
    observer: ResizeObserver | null;
    listener(): void;
    mount(el: El): void;
    clean(el: null): void;
    resize(self: ResizeState<El>): void;
    ref(target: El): void;
}
type ResizeArg<El extends Element = Element> = Partial<ResizeState<El>> | ResizeState<El>['resize'];

declare const useResize: (arg: ResizeArg) => EventState<ResizeState<Element>>;

interface ResizeProps<El extends Element = Element> extends Partial<ResizeState<El>> {
    children: (state: ResizeState<El>) => ReactNode;
}
declare const Resize: <El extends Element = Element>(props: ResizeProps<El>) => ReactNode;

interface ScrollState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    target: El;
    event: Event;
    memo: any;
    isScrollStart: boolean;
    isScrolling: boolean;
    isScrollEnd: boolean;
    timeout: number;
    clearTimeout(): void;
    scroll(self: ScrollState<El>): void;
    scrollStart(e: Event): void;
    scrolling(e: Event): void;
    scrollEnd(e: Event): void;
    mount(target: El): void;
    clean(target: null): void;
    ref(traget: El | null): void;
    tick?: () => void;
}
type ScrollConfig<El extends Element = Element> = Partial<ScrollState<El>> | ScrollState<El>['scroll'];

declare const useScroll: <El extends Element = Element>(config: ScrollConfig) => EventState<ScrollState<El>>;

interface ScrollProps<El extends Element = Element> extends Partial<ScrollState<El>> {
    children: (state: ScrollState<El>) => ReactNode;
}
declare const Scroll: <El extends Element = Element>(props: ScrollProps<El>) => ReactNode;

interface WheelState<El extends Element = Element> {
    _active: boolean;
    active: boolean;
    _value: Vec2;
    value: Vec2;
    delta: Vec2;
    offset: Vec2;
    movement: Vec2;
    target: El;
    event: Event;
    timeout: number;
    clearTimeout(): void;
    memo: any;
    isWheelStart: boolean;
    isWheeling: boolean;
    isWheelEnd: boolean;
    wheel(self: WheelState<El>): void;
    wheelStart(e: Event): void;
    wheeling(e: Event): void;
    wheelEnd(e: Event): void;
    mount(target: El): void;
    clean(target: null): void;
    ref(traget: El | null): void;
    tick?: () => void;
}
type WheelConfig<El extends Element = Element> = Partial<WheelState<El>> | WheelState<El>['wheel'];

declare const useWheel: <El extends Element = Element>(config: WheelConfig) => EventState<WheelState<El>>;

interface WheelProps<El extends Element = Element> extends Partial<WheelState<El>> {
    children: (state: WheelState<El>) => ReactNode;
}
declare const Wheel: <El extends Element = Element>(props: WheelProps<El>) => ReactNode;

export { Drag, type DragProps, Hover, type HoverProps, Key, type KeyProps, Pinch, type PinchProps, Resize, type ResizeProps, Scroll, type ScrollProps, Wheel, type WheelProps, useDrag, useHover, useKey, usePinch, useResize, useScroll, useWheel };