/// <reference path="./css-plugin.d.ts"/>

declare namespace JSX {

    type Ref<T> = ((value: T | undefined) => void);

    interface DjxIntrinsicAttributes<E> {
        /** alias for className */
        class: string;

        /** specifies the name of the property in the widget where the the
         * reference to the current object will be stored
         */
        "data-dojo-attach-point": string;

        /** specifies handlers map for the events */
        "data-dojo-attach-event": string;

        ref: Ref<E>;

        /** @deprecated */
        [attr: string]: any;
    }

    interface DjxIntrinsicElements {
    }

    type RecursivePartial<T> = T extends string | number | boolean | null | undefined | Function ?
        T :
        { [k in keyof T]?: RecursivePartial<T[k]> };

    type MatchingMemberKeys<T, U> = {
        [K in keyof T]: T[K] extends U ? K : never;
    }[keyof T];
    type NotMatchingMemberKeys<T, U> = {
        [K in keyof T]: T[K] extends U ? never : K;
    }[keyof T];

    type ExtractMembers<T, U> = Pick<T, MatchingMemberKeys<T, U>>;

    type ExcludeMembers<T, U> = Pick<T, NotMatchingMemberKeys<T, U>>;

    type ElementAttrNames<E> = NotMatchingMemberKeys<E, (...args: any[]) => any>;

    type ElementAttrType<E, K extends keyof any> = K extends keyof E ? RecursivePartial<E[K]> : string;


    type ElementAttrNamesBlacklist = "children" | "getRootNode" | keyof EventTarget;

    /** This type extracts keys of the specified parameter E by the following rule:
     *  1. skips all ElementAttrNamesBlacklist
     *  2. skips all methods except with the signature of event handlers
     */
    type AssignableElementAttrNames<E> = {
        [K in keyof E]: K extends ElementAttrNamesBlacklist ? never :
            ((evt: Event) => any) extends E[K] ? K :
            E[K] extends ((...args: any[]) => any) ? never :
            K;
    }[keyof E];

    type LaxElement<E extends object> =
        Pick<E, AssignableElementAttrNames<E>> &
        DjxIntrinsicAttributes<E>;

    type LaxIntrinsicElementsMap = {
        [tag in keyof HTMLElementTagNameMap]: LaxElement<HTMLElementTagNameMap[tag]>
    } & DjxIntrinsicElements;

    type IntrinsicElements = {
        [tag in keyof LaxIntrinsicElementsMap]: RecursivePartial<LaxIntrinsicElementsMap[tag]>;
    }

    interface ElementChildrenAttribute {
        children: {};
    }

    interface IntrinsicClassAttributes<T> {
        ref?: (value: T) => void;
        children?: unknown;
    }
}