import { Page, Frame, ElementHandle, FrameWaitForFunctionOptions, ClickOptions, Dialog } from 'puppeteer';
import { JestExpect } from '@jest/expect';

type PuppeteerInstance = Page | Frame | ElementHandle;
type Selector = {
    type: "css" | "xpath";
    value: string;
};
type SearchExpression = RegExp | string | undefined;

type Options = FrameWaitForFunctionOptions;
declare const setDefaultOptions: (options: Options) => void;
declare const getDefaultOptions: () => Options;

type MatchTextContentOptions = Options & {
    traverseShadowRoots?: boolean;
};

type NotToMatchOptions = MatchTextContentOptions;
declare function notToMatchTextContent(instance: PuppeteerInstance, matcher: SearchExpression, options?: NotToMatchOptions): Promise<void>;

type GetElementOptions = {
    text?: string | RegExp;
    visible?: boolean;
};

type NotToMatchElementOptions = GetElementOptions & Options;
declare function notToMatchElement(instance: PuppeteerInstance, selector: Selector | string, options?: NotToMatchElementOptions): Promise<void>;

type ToMatchElementOptions = GetElementOptions & Options;
declare function toMatchElement(instance: PuppeteerInstance, selector: Selector | string, options?: ToMatchElementOptions): Promise<ElementHandle<Element>>;

type ToClickOptions = ToMatchElementOptions & ClickOptions;
declare function toClick(instance: PuppeteerInstance, selector: Selector | string, options?: ToClickOptions): Promise<void>;

declare function toDisplayDialog(page: Page, block: () => Promise<void>): Promise<Dialog>;

type ToFillOptions = ToMatchElementOptions & {
    delay?: number;
};
declare function toFill(instance: PuppeteerInstance, selector: Selector | string, value: string, options?: ToFillOptions): Promise<void>;

type ToFillFormOptions = ToFillOptions & ToMatchElementOptions;
declare function toFillForm(instance: PuppeteerInstance, selector: Selector | string, values: Record<string, string>, options?: ToFillFormOptions): Promise<void>;

type ToMatchOptions = MatchTextContentOptions;
declare function toMatchTextContent(instance: PuppeteerInstance, matcher: SearchExpression, options?: ToMatchOptions): Promise<void>;

declare function toSelect(instance: PuppeteerInstance, selector: Selector | string, valueOrText: string, options?: ToMatchElementOptions): Promise<void>;

declare function toUploadFile(instance: PuppeteerInstance, selector: Selector | string, filePaths: string | string[], options?: ToMatchElementOptions): Promise<void>;

type Intersection<T> = (T extends unknown ? (k: T) => void : never) extends (k: infer R) => void ? R : never;
type Wrapper<T> = T extends (page: Intersection<PuppeteerInstance>, ...args: infer A) => infer R ? (...args: A) => R : never;
type InstanceMatchers<T> = T extends PuppeteerInstance ? {
    toClick: Wrapper<typeof toClick>;
    toFill: Wrapper<typeof toFill>;
    toFillForm: Wrapper<typeof toFillForm>;
    toMatchTextContent: Wrapper<typeof toMatchTextContent>;
    toMatchElement: Wrapper<typeof toMatchElement>;
    toSelect: Wrapper<typeof toSelect>;
    toUploadFile: Wrapper<typeof toUploadFile>;
    not: {
        toMatchTextContent: Wrapper<typeof notToMatchTextContent>;
        toMatchElement: Wrapper<typeof notToMatchElement>;
    };
} : never;
interface PageMatchers extends InstanceMatchers<Page> {
    toDisplayDialog: Wrapper<typeof toDisplayDialog>;
    not: InstanceMatchers<Page>[`not`] & {};
}
interface FrameMatchers extends InstanceMatchers<Frame> {
    not: InstanceMatchers<Frame>[`not`] & {};
}
interface ElementHandleMatchers extends InstanceMatchers<ElementHandle<Element>> {
    not: InstanceMatchers<ElementHandle<Element>>[`not`] & {};
}
type PMatchersPerType<T> = T extends Page ? PageMatchers : T extends Frame ? FrameMatchers : T extends ElementHandle<Element> ? ElementHandleMatchers : never;
interface PuppeteerExpect {
    <T>(actual: T): PMatchersPerType<T>;
}
interface PuppeteerMatchers<T> {
    toClick: T extends PuppeteerInstance ? Wrapper<typeof toClick> : never;
    toFill: T extends PuppeteerInstance ? Wrapper<typeof toFill> : never;
    toFillForm: T extends PuppeteerInstance ? Wrapper<typeof toFillForm> : never;
    toMatchTextContent: T extends PuppeteerInstance ? Wrapper<typeof toMatchTextContent> : never;
    toMatchElement: T extends PuppeteerInstance ? Wrapper<typeof toMatchElement> : never;
    toSelect: T extends PuppeteerInstance ? Wrapper<typeof toSelect> : never;
    toUploadFile: T extends PuppeteerInstance ? Wrapper<typeof toUploadFile> : never;
    toDisplayDialog: T extends Page ? Wrapper<typeof toDisplayDialog> : never;
    not: {
        toMatchTextContent: T extends PuppeteerInstance ? Wrapper<typeof notToMatchTextContent> : never;
        toMatchElement: T extends PuppeteerInstance ? Wrapper<typeof notToMatchElement> : never;
    };
}
declare global {
    namespace jest {
        interface Matchers<R, T> extends PuppeteerMatchers<T> {
        }
    }
}
declare const expectPuppeteer: PuppeteerExpect & JestExpect;

export { type PuppeteerExpect, expectPuppeteer as expect, getDefaultOptions, setDefaultOptions };