import { djbase, djclass } from "../declare";
import _WidgetBase = require("dijit/_WidgetBase");
import _AttachMixin = require("dijit/_AttachMixin");
import { isNode, isElementNode } from "./traits";
import registry = require("dijit/registry");
import on = require("dojo/on");
import { Scope } from "./Scope";
import { queueRenderTask, getPriority, render } from "./render";
import { isNull } from "@implab/core-amd/safe";

// type Handle = dojo.Handle;

export interface EventArgs {
    bubbles?: boolean;

    cancelable?: boolean;

    composed?: boolean;
}

// eslint-disable-next-line @typescript-eslint/no-unused-vars
export interface DjxWidgetBase<Attrs = object, Events extends { [name in keyof Events]: Event } = object> extends
    _WidgetBase<Events> {

    /** This property is declared only for type inference to work, it is never assigned
     * and should not be used.
     */
    readonly _eventMap: Events & GlobalEventHandlersEventMap;

    /** The list of pairs of event and method names. When the widget is created all methods from
     * this list will be connected to corresponding events.
     *
     * This property is maintained in the prototype
     */
    _eventHandlers: Array<{
        eventName: string,
        handlerMethod: string;
    }>;
}

type _super = {
    startup(): void;

    destroy(preserveDom?: boolean): void;
};

@djclass
// eslint-disable-next-line @typescript-eslint/no-unused-vars
export abstract class DjxWidgetBase<Attrs = object, Events = object> extends djbase<_super, _AttachMixin>(_WidgetBase, _AttachMixin) {
    private readonly _scope = new Scope();

    private readonly _priority = getPriority() + 1;

    buildRendering() {
        const node = render(this.render(), this._scope);
        if (!isElementNode(node))
            throw new Error("The render method must return a single DOM element");
        this.domNode = node as HTMLElement;

        super.buildRendering();

        // now we should get assigned data-dojo-attach-points
        // place the contents of the original srcNode to the containerNode
        const src = this.srcNodeRef;
        const dest = this.containerNode;

        // the donNode is constructed now we need to connect event handlers
        this._connectEventHandlers();

        if (src && dest) {
            while (src.firstChild)
                dest.appendChild(src.firstChild);
        }
    }

    /** Schedules a new deferred rendition within the scope of the widget */
    scheduleRender(task: () => void) {
        return queueRenderTask(task, this._scope, this._priority);
    }

    abstract render(): JSX.Element;

    private _connectEventHandlers() {
        if (this._eventHandlers)
            this._eventHandlers.forEach(({ eventName, handlerMethod }) => {
                const handler = this[handlerMethod as keyof this];
                if (typeof handler === "function")
                    on(this.domNode, eventName, handler.bind(this) as (...args: unknown[]) => unknown);
            });
    }

    _processTemplateNode<T extends (Element | Node | _WidgetBase)>(
        baseNode: T,
        getAttrFunc: (baseNode: T, attr: string) => string | undefined,
        // tslint:disable-next-line: ban-types
        attachFunc: (node: T, type: string, func?: (...args: unknown[]) => unknown) => dojo.Handle
    ): boolean {
        if (isNode(baseNode)) {
            const w = registry.byNode(baseNode);
            if (w) {
                // from dijit/_WidgetsInTemplateMixin
                this._processTemplateNode(w,
                    (n, p) => {
                        const v = n.get(p as keyof typeof n);
                        return isNull(v) ? undefined : String(v);
                    }, // callback to get a property of a widget
                    (widget, type, callback) => {
                        if (!callback)
                            throw new Error("The callback must be specified");

                        // callback to do data-dojo-attach-event to a widget
                        if (type in widget) {
                            // back-compat, remove for 2.0
                            return widget.connect(widget, type, callback as EventListener);
                        } else {
                            // 1.x may never hit this branch, but it's the default for 2.0
                            return widget.on(type as keyof GlobalEventHandlersEventMap, callback);
                        }

                    });
                // don't process widgets internals
                return false;
            }
        }
        // eslint-disable-next-line @typescript-eslint/ban-types
        return super._processTemplateNode(baseNode, getAttrFunc as (baseNode: T, attr: string) => string, attachFunc as (node: T, type: string, func?: Function) => dojo.Handle);
    }

    /** Starts current widget and all its supporting widgets (placed outside
     * `containerNode`) and child widgets (placed inside `containerNode`)
     */
    startup() {
        // startup supporting widgets
        registry.findWidgets(this.domNode, this.containerNode).forEach(w => w.startup());
        super.startup();
    }

    destroy(preserveDom?: boolean) {
        this._scope.destroy();
        super.destroy(preserveDom);
    }
}