import { IDestroyable } from "@implab/core-amd/interfaces";
import { isDestroyable } from "@implab/core-amd/safe";
import _WidgetBase = require("dijit/_WidgetBase");
import registry = require("dijit/registry");
import dom = require("dojo/dom-construct");

type _WidgetBaseConstructor = typeof _WidgetBase;

export type DojoNodePosition = "first" | "after" | "before" | "last" | "replace" | "only" | number;

export interface BuildContext<TNode extends Node = Node> {
    getDomNode(): TNode;

    placeAt(refNode: string | Node, position?: DojoNodePosition): void;
}

export interface IRecursivelyDestroyable {
    destroyRecursive(): void;
}

export function isNode(el: any): el is Node {
    return el && el.nodeName && el.nodeType;
}

export function isElementNode(el: any): el is Element {
    return isNode(el) && el.nodeType === 1;
}

export function isTextNode(el: any): el is Text {
    return isNode(el) && el.nodeType === 3;
}

export function isProcessingInstructionNode(el: any): el is ProcessingInstruction {
    return isNode(el) && el.nodeType === 7;
}

export function isCommentNode(el: any): el is Comment {
    return isNode(el) && el.nodeType === 8;
}

export function isDocumentNode(el: any): el is Document {
    return isNode(el) && el.nodeType === 9;
}

export function isDocumentTypeNode(el: any): el is DocumentType {
    return isNode(el) && el.nodeType === 10;
}

export function isDocumentFragmentNode(el: any): el is DocumentFragment {
    return isNode(el) && el.nodeType === 11;
}

export function isWidget(v: any): v is _WidgetBase {
    return v && "domNode" in v;
}

export function isBuildContext(v: any): v is BuildContext {
    return typeof v === "object" && typeof v.getDomElement === "function";
}

export function isPlainObject(v: object) {
    if (typeof v !== "object")
        return false;

    const vp = Object.getPrototypeOf(v);
    return !vp || vp === Object.prototype;
}

export function isWidgetConstructor(v: any): v is _WidgetBaseConstructor {
    return typeof v === "function" && v.prototype && (
        "domNode" in v.prototype ||
        "buildRendering" in v.prototype
    );
}

/** Tests whether the specified node is placed in visible dom.
 *  @param {Node} node The node to test
 */
export function isInPage(node: Node) {
    return (node === document.body) ? false : document.body.contains(node);
}

export function isRecursivelyDestroyable(target: any): target is IRecursivelyDestroyable {
    return target && typeof target.destroyRecursive === "function";
}


/** Destroys DOM Node with all contained widgets.
 * If the specified node is the root node of a widget, then the
 * widget will be destroyed.
 *
 * @param target DOM Node or widget to destroy
 */
export function destroy(target: Node | IDestroyable | IRecursivelyDestroyable) {
    if (isRecursivelyDestroyable(target)) {
        target.destroyRecursive();
    } else if (isDestroyable(target)) {
        target.destroy();
    } else if (isNode(target)) {
        const self = registry.byNode(target);
        if (self) {
            self.destroyRecursive();
        } else {
            registry.findWidgets(target).forEach(destroy);
            dom.destroy(target);
        }
    }
}

/** Empties a content of the specified node and destroys all contained widgets.
 *
 * @param target DOM node to .
 */
export function emptyNode(target: Node) {
    registry.findWidgets(target).forEach(destroy);
    dom.empty(target);
}

/** This function starts all widgets inside the DOM node if the target is a node,
 * or starts widget itself if the target is the widget.
 * 
 * @param target DOM node to find and start widgets or the widget itself.
 */
export function startupWidgets(target: Node | _WidgetBase, skipNode?: Node) {
    if (isNode(target)) {
        registry.findWidgets(target, skipNode).forEach(w => w.startup());
    } else {
        target.startup();
    }
}