/*
 *    Copyright [2015] [wisemapping]
 *
 *   Licensed under WiseMapping Public License, Version 1.0 (the "License").
 *   It is basically the Apache License, Version 2.0 (the "License") plus the
 *   "powered by wisemapping" text requirement on every single page;
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the license at
 *
 *       http://www.wisemapping.org/license
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

const RootedTreeSet = new Class(
    /** @lends RootedTreeSet */ {
        /** @constructs */
        initialize: function () {
            this._rootNodes = [];
        },

        /**
         * @param root
         * @throws will throw an error if root is null or undefined
         */
        setRoot: function (root) {
            $assert(root, 'root can not be null');
            this._rootNodes.push(this._decodate(root));
        },

        /** getter */
        getTreeRoots: function () {
            return this._rootNodes;
        },

        _decodate: function (node) {
            node._children = [];
            return node;
        },

        /**
         * @param {mindplot.model.NodeModel} node
         * @throws will throw an error if node is null or undefined
         * @throws will throw an error if node with id already exists
         * @throws will throw an error if node has been added already
         */
        add: function (node) {
            $assert(node, 'node can not be null');
            $assert(
                !this.find(node.getId(), false),
                'node already exits with this id. Id:' + node.getId()
            );
            $assert(!node._children, 'node already added');
            this._rootNodes.push(this._decodate(node));
        },

        /**
         * @param nodeId
         * @throws will throw an error if nodeId is null or undefined
         */
        remove: function (nodeId) {
            $assert($defined(nodeId), 'nodeId can not be null');
            var node = this.find(nodeId);
            this._rootNodes.erase(node);
        },

        /**
         * @param parentId
         * @param childId
         * @throws will throw an error if parentId is null or undefined
         * @throws will throw an error if childId is null or undefined
         * @throws will throw an error if node with id childId is already a child of parent
         */
        connect: function (parentId, childId) {
            $assert($defined(parentId), 'parent can not be null');
            $assert($defined(childId), 'child can not be null');

            var parent = this.find(parentId);
            var child = this.find(childId, true);
            $assert(
                !child._parent,
                'node already connected. Id:' + child.getId() + ',previous:' + child._parent
            );

            parent._children.push(child);
            child._parent = parent;
            this._rootNodes.erase(child);
        },

        /**
         * @param nodeId
         * @throws will throw an error if nodeId is null or undefined
         * @throws will throw an error if node is not connected
         */
        disconnect: function (nodeId) {
            $assert($defined(nodeId), 'nodeId can not be null');
            var node = this.find(nodeId);
            $assert(node._parent, 'Node is not connected');

            node._parent._children.erase(node);
            this._rootNodes.push(node);
            node._parent = null;
        },

        /**
         * @param id
         * @param validate
         * @throws will throw an error if id is null or undefined
         * @throws will throw an error if node cannot be found
         * @return node
         */
        find: function (id, validate) {
            $assert($defined(id), 'id can not be null');

            var graphs = this._rootNodes;
            var result = null;
            for (var i = 0; i < graphs.length; i++) {
                var node = graphs[i];
                result = this._find(id, node);
                if (result) {
                    break;
                }
            }
            validate = !$defined(validate) ? true : validate;
            $assert(
                validate ? result : true,
                'node could not be found id:' + id + '\n,RootedTreeSet' + this.dump()
            );
            return result;
        },

        _find: function (id, parent) {
            if (parent.getId() == id) {
                return parent;
            }

            var result = null;
            var children = parent._children;
            for (var i = 0; i < children.length; i++) {
                var child = children[i];
                result = this._find(id, child);
                if (result) break;
            }

            return result;
        },

        /**
         * @param node
         * @throws will throw an error if nodeId is null or undefined
         * @return children
         */
        getChildren: function (node) {
            $assert(node, 'node cannot be null');
            return node._children;
        },

        /**
         * @param node
         * @throws will throw an error if node is null or undefined
         * @return root node or the provided node, if it has no parent
         */
        getRootNode: function (node) {
            $assert(node, 'node cannot be null');
            var parent = this.getParent(node);
            if ($defined(parent)) {
                return this.getRootNode(parent);
            }

            return node;
        },

        /**
         * @param node
         * @throws will throw an error if node is null or undefined
         * @return {Array} ancestors*/
        getAncestors: function (node) {
            $assert(node, 'node cannot be null');
            return this._getAncestors(this.getParent(node), []);
        },

        _getAncestors: function (node, ancestors) {
            var result = ancestors;
            if (node) {
                result.push(node);
                this._getAncestors(this.getParent(node), result);
            }
            return result;
        },

        /**
         * @param node
         * @throws will throw an error if node is null or undefined
         * @return {Array} siblings
         */
        getSiblings: function (node) {
            $assert(node, 'node cannot be null');
            if (!$defined(node._parent)) {
                return [];
            }
            var siblings = node._parent._children.filter(function (child) {
                return child != node;
            });
            return siblings;
        },

        /**
         * @param node
         * @throws will throw an error if node is null or undefined
         * @return {Boolean} whether the node has a single path to a single leaf (no branching)
         */
        hasSinglePathToSingleLeaf: function (node) {
            $assert(node, 'node cannot be null');
            return this._hasSinglePathToSingleLeaf(node);
        },

        _hasSinglePathToSingleLeaf: function (node) {
            var children = this.getChildren(node);

            if (children.length == 1) {
                return this._hasSinglePathToSingleLeaf(children[0]);
            }

            return children.length == 0;
        },

        /**
         * @param node
         * @return {Boolean} whether the node is the start of a subbranch*/
        isStartOfSubBranch: function (node) {
            return this.getSiblings(node).length > 0 && this.getChildren(node).length == 1;
        },

        /**
         * @param node
         * @throws will throw an error if node is null or undefined
         * @return {Boolean} whether the node is a leaf
         */
        isLeaf: function (node) {
            $assert(node, 'node cannot be null');
            return this.getChildren(node).length == 0;
        },

        /**
         * @param node
         * @throws will throw an error if node is null or undefined
         * @return parent
         */
        getParent: function (node) {
            $assert(node, 'node cannot be null');
            return node._parent;
        },

        /**
         * @return result
         */
        dump: function () {
            var branches = this._rootNodes;
            var result = '';
            for (var i = 0; i < branches.length; i++) {
                var branch = branches[i];
                result += this._dump(branch, '');
            }
            return result;
        },

        _dump: function (node, indent) {
            var result = indent + node + '\n';
            var children = this.getChildren(node);
            for (var i = 0; i < children.length; i++) {
                var child = children[i];
                result += this._dump(child, indent + '   ');
            }

            return result;
        },

        /**
         * @param canvas
         */
        plot: function (canvas) {
            var branches = this._rootNodes;
            for (var i = 0; i < branches.length; i++) {
                var branch = branches[i];
                this._plot(canvas, branch);
            }
        },

        _plot: function (canvas, node, root) {
            var children = this.getChildren(node);
            var cx = node.getPosition().x + canvas.width / 2 - node.getSize().width / 2;
            var cy = node.getPosition().y + canvas.height / 2 - node.getSize().height / 2;
            var rect = canvas.rect(cx, cy, node.getSize().width, node.getSize().height);
            var order = node.getOrder() == null ? 'r' : node.getOrder();
            var text = canvas.text(
                node.getPosition().x + canvas.width / 2,
                node.getPosition().y + canvas.height / 2,
                node.getId() + '[' + order + ']'
            );
            text.attr('fill', '#FFF');
            var fillColor = this._rootNodes.contains(node)
                ? '#000'
                : node.isFree()
                ? '#abc'
                : '#c00';
            rect.attr('fill', fillColor);

            var rectPosition = {
                x: rect.attr('x') - canvas.width / 2 + rect.attr('width') / 2,
                y: rect.attr('y') - canvas.height / 2 + rect.attr('height') / 2,
            };
            var rectSize = { width: rect.attr('width'), height: rect.attr('height') };
            rect.click(function () {
                console.log(
                    '[id:' +
                        node.getId() +
                        ', order:' +
                        node.getOrder() +
                        ', position:(' +
                        rectPosition.x +
                        ',' +
                        rectPosition.y +
                        '), size:' +
                        rectSize.width +
                        'x' +
                        rectSize.height +
                        ', freeDisplacement:(' +
                        node.getFreeDisplacement().x +
                        ',' +
                        node.getFreeDisplacement().y +
                        ')]'
                );
            });
            text.click(function () {
                console.log(
                    '[id:' +
                        node.getId() +
                        ', order:' +
                        node.getOrder() +
                        ', position:(' +
                        rectPosition.x +
                        ',' +
                        rectPosition.y +
                        '), size:' +
                        rectSize.width +
                        'x' +
                        rectSize.height +
                        ', freeDisplacement:(' +
                        node.getFreeDisplacement().x +
                        ',' +
                        node.getFreeDisplacement().y +
                        ')]'
                );
            });

            for (var i = 0; i < children.length; i++) {
                var child = children[i];
                this._plot(canvas, child);
            }
        },

        /**
         * @param node
         * @param position
         */
        updateBranchPosition: function (node, position) {
            var oldPos = node.getPosition();
            node.setPosition(position);

            var xOffset = oldPos.x - position.x;
            var yOffset = oldPos.y - position.y;

            var children = this.getChildren(node);
            var me = this;
            _.each(children, function (child) {
                me.shiftBranchPosition(child, xOffset, yOffset);
            });
        },

        /**
         * @param node
         * @param xOffset
         * @param yOffset
         */
        shiftBranchPosition: function (node, xOffset, yOffset) {
            var position = node.getPosition();
            node.setPosition({ x: position.x + xOffset, y: position.y + yOffset });

            var children = this.getChildren(node);
            var me = this;
            _.each(children, function (child) {
                me.shiftBranchPosition(child, xOffset, yOffset);
            });
        },

        /**
         * @param node
         * @param yOffset
         * @return siblings in the offset (vertical) direction, i.e. with lower or higher order, respectively
         */
        getSiblingsInVerticalDirection: function (node, yOffset) {
            // siblings with lower or higher order, depending on the direction of the offset and on the same side as their parent
            var parent = this.getParent(node);
            var siblings = this.getSiblings(node).filter(function (sibling) {
                var sameSide =
                    node.getPosition().x > parent.getPosition().x
                        ? sibling.getPosition().x > parent.getPosition().x
                        : sibling.getPosition().x < parent.getPosition().x;
                var orderOK =
                    yOffset < 0
                        ? sibling.getOrder() < node.getOrder()
                        : sibling.getOrder() > node.getOrder();
                return orderOK && sameSide;
            });

            if (yOffset < 0) {
                siblings.reverse();
            }

            return siblings;
        },

        /**
         * @param node
         * @param yOffset
         * @return branches of the root node on the same side as the given node's, in the given
         * vertical direction
         */
        getBranchesInVerticalDirection: function (node, yOffset) {
            // direct descendants of the root that do not contain the node and are on the same side
            // and on the direction of the offset
            var rootNode = this.getRootNode(node);
            var branches = this.getChildren(rootNode).filter(function (child) {
                return this._find(node.getId(), child);
            }, this);

            var branch = branches[0];
            var rootDescendants = this.getSiblings(branch).filter(function (sibling) {
                var sameSide =
                    node.getPosition().x > rootNode.getPosition().x
                        ? sibling.getPosition().x > rootNode.getPosition().x
                        : sibling.getPosition().x < rootNode.getPosition().x;
                var sameDirection =
                    yOffset < 0
                        ? sibling.getOrder() < branch.getOrder()
                        : sibling.getOrder() > branch.getOrder();
                return sameSide && sameDirection;
            }, this);

            return rootDescendants;
        },
    }
);

export default RootedTreeSet;