namespace('nnet.sd');

nnet.sd.NavigationTree = $j.klass({

    initialize: function(treeData) {
        try {
            // something wrong with server data
            if (treeData == null) this.Data = null;
            else this.Data = new TreeData(treeData);

            // something wrong with server data
            // nnet.sd.onNavigationTreeDataReady.fire(); // ******
            this.AutoComplete = new nnet.sd.NavigationTree.AutoComplete(); // Auto complete category find
            this.Tree = null;
            this.Node = null;  // the current node, may not be the node displayed in the list, as this could be set by a menu click.
            this.DisplayTreeNode = false;    // used at startup to open node
            this.RefreshNodeID = 0;
            var CurrentNodeID = 0; // used when item function selected on tree via right click, menu dropdown, correspons to directory node (category) id


        } catch (e) { logE("sd.NavigationTree.initialize", e); }
    },

    // called fron tree onload event
    startup: function(sender) {
        try {
            SD.NavigationTree.Tree = sender;
            SD.NavigationTree.AutoComplete.startup(sender);
            if (SD.NavigationTree.Data == null) SD.NavigationTree.loadData(false);
            if (SD.NavigationTree.DisplayTreeNode) SD.NavigationTree.showTreeNode();

            onLogIn.subscribe(
                function(type, args) {
                    try {
                        if (!args[0].IsStartUp && args[0].IsAdmin) SD.NavigationTree.refresh();
                    } catch (e) { logE("sd.NavigationTree.onLogIn handler", e); }
                }
            );
            onLogOut.subscribe(
                function(type, args) {
                    try {
                        if (!args[0].IsStartUp && args[0].WasAdmin) SD.NavigationTree.refresh();
                    } catch (e) { logE("sd.NavigationTree.onLogOut handler", e); }
                }
            );


        } catch (e) { logE("sd.NavigationTree.startup", e); }
    },

    loadData: function(render) {
        try {
            if (render) SDCallback.GetTree(SD.NavigationTree.receiveDataAndRender, OnPageError); // Load tree data
            else SDCallback.GetTree(SD.NavigationTree.receiveData, OnPageError); // Load tree data
            if (this.Tree == null) this.Tree = $find(sVars.SD_NavTreeID); // go when initNavigationTree used
        } catch (e) { logE("sd.NavigationTree.loadData", e); }
    },

    // event handler so not in context.
    initNavigationTree: function(sender) {
        try {
        } catch (e) { logE("sd.NavigationTree.initNavigationTree", e); }
    },

    render: function() {
        try {
            this.Tree = $find(sVars.SD_NavTreeID)
            this.renderTree()
            document.body.style.cursor = 'default';
            if (this.RefreshNodeID > 0) {
                this.showTreeNode(this.RefreshNodeID);
                this.RefreshNodeID = 0;
            }
            nnet.sd.onNavigationTreeRendered.fire();
        } catch (e) { logE("sd.NavigationTree.render", e); }
    },

    refresh: function() {
        try {
            document.body.style.cursor = 'wait';
            this.RefreshNodeID = SD.CurrentCategoryId;
            this.loadData(true);
        } catch (e) { logE("sd.NavigationTree.refresh", e); }
    },


    receiveData: function(treeData) {  // Callback event.
        try {
            SD.NavigationTree.Data = new TreeData(treeData);
            nnet.sd.onNavigationTreeDataReady.fire();
        } catch (e) { logE("sd.NavigationTree.receiveData", e); }
    },

    receiveDataAndRender: function(treeData) {  // Callback event.
        try {
            SD.NavigationTree.Data = new TreeData(treeData);
            nnet.sd.onNavigationTreeDataReady.fire();
            if (SD.NavigationTree.Tree == null) SD.NavigationTree.Tree = $find(sVars.SD_NavTreeID); // go when initNavigationTree used
            SD.NavigationTree.render();
        } catch (e) { logE("sd.NavigationTree.receiveDataAndRender", e); }
    },

//    searchAndHighlight: function(text) {
//        var nodes = this.Tree.get_allNodes();

//        var flag = false;
//        for (var i = 0; i < nodes.length; i++) {
//            nodes[i].unhighlight();
//            var nodeText = nodes[i].get_text();
//            if (nodeText.indexOf(text) > -1) {
//                nodes[i].highlight();
//                try {
//                    nodes[i].get_parent().expand();
//                    nodes[i].get_parent().get_parent().expand();
//                    nodes[i].get_parent().get_parent().get_parent().expand();
//                    nodes[i].get_parent().get_parent().get_parent().get_parent().expand();
//                } catch (e) { }
//                if (!flag) {
//                    nodes[i].scrollIntoView();
//                    flag = true;
//                }
//            }
//        }

//    },

//    unHighlight: function() {
//        var nodes = this.Tree.get_allNodes();
//        for (var i = 0; i < nodes.length; i++) {
//            nodes[i].unhighlight();
//        }
//    },


    // event handler so not in context.
    nodeClick: function(node, eventArgs) {
        try {
            SD.NavigationTree.search(eventArgs.get_node());
        } catch (e) { logE("sd.NavigationTree.nodeClick", e); }
    },
    
    search: function(node){
        try {
            this.Node = node;
            SD.ListingView.empty();
            SD.CurrentCategoryType = node.get_category() - 0;
            SD.CurrentCategoryId = node.get_value() - 0;
            currentPage = 0;

            SD.SearchSource = sVars.CATEGORY_SEARCH_SOURCE;

            ServiceContentLoadingImage.show();
            document.body.style.cursor = 'wait';

            CategorySearchServices(SD.CurrentCategoryType, SD.CurrentCategoryId, currentPage, SD.CurrentSearchSite);
            if (SD.ContentViewState != sVars.LIST_CONTENT_VIEW_STATE & SD.ContentViewState != sVars.MAP_CONTENT_VIEW_STATE) {
                SD.show(sVars.LIST_CONTENT_VIEW_STATE);
            }
        } catch (e) { logE("sd.NavigationTree.search", e); }
    },

    menuClick: function(sender, eventArgs) {
        try {
            var menu = eventArgs.get_menuItem().get_value();
            SD.NavigationTree.Node = eventArgs.get_node();
            SD.NavigationTree.CurrentNodeID = SD.NavigationTree.Node.get_value() - 0;
            if (menu == "Edit") SD.NavigationTree.editCategory(SD.NavigationTree.CurrentNodeID);
            else if (menu == "Add") SDCallback.AddCategory(SD.NavigationTree.CurrentNodeID, SD.NavigationTree.addCategory_Callback, OnListCallbackError);
            else if (menu == "Delete") { if (confirm("Do you want to delete the selected Category?")) SDCallback.DeleteCategory(SD.NavigationTree.CurrentNodeID, SD.NavigationTree.deleteCategory_Callback, OnListCallbackError); }
            else if (menu == "MoveListings") SDCallback.MoveListings(SD.NavigationTree.CurrentNodeID, SD.NavigationTree.moveCopyListing_Callback, OnListCallbackError);
            else if (menu == "CopyListings") SDCallback.CopyListings(SD.NavigationTree.CurrentNodeID, SD.NavigationTree.moveCopyListing_Callback, OnListCallbackError);
            else if (menu == "MoveMapping") SDCallback.MoveMappings(SD.NavigationTree.CurrentNodeID, SD.NavigationTree.moveMapping_Callback, OnListCallbackError);
            eventArgs.get_menuItem().get_menu().hide();
            eventArgs.set_cancel(true);
        } catch (e) { logE("sd.NavigationTree.menuClick", e); }
    },

    isLeaf: function() {
        if (this.Node == null) return false;
        if (this.Node.get_nodes().get_count() == 0) return true;
        else return false;
    },

    showTreeNode: function(nodeID) {
        try {
            if (this.Tree != null) {
                if (nodeID == undefined) this.showRTreeNode(SD.CurrentCategoryId);
                else this.showRTreeNode(nodeID);
                this.DisplayTreeNode = false; // do it when tree init
            } else {
                this.DisplayTreeNode = true; // do it on tree staup when tree init
            }
        } catch (e) { logE("sd.NavigationTree.showTreeNode", e); }
    },


    addCategory_Callback: function(result) {
        try {
            if (result == "") {
                var win = new nnet.PopUpWindow({ url: '/Directory/Category?Mode=New&PID=' + SD.NavigationTree.CurrentNodeID, onClose: SD.NavigationTree.categoryWindowCloseHandler, minWidth: 430 });
                win.show();
            } else alert(result);
        } catch (e) { logE("sd.NavigationTree.addCategory_Callback", e); }
    },

    editCategory: function(cid) {
        try {
            var win = new nnet.PopUpWindow({ url: '/Directory/Category?Mode=Edit&CID=' + cid, minWidth: 460 });
            win.show();
        } catch (e) { logE("sd.NavigationTree.addCategory_Callback", e); }
    },


    deleteCategory_Callback: function(result) {
        try {
            if (result == "") {
                SD.NavigationTree.refresh();
            } else alert(result);
        } catch (e) { logE("sd.NavigationTree.deleteCategory_Callback", e); }
    },

    moveCopyListing_Callback: function(result) {
        try {
            if (result == "") {
                SD.NavigationTree.refresh();
            } else alert(result);
        } catch (e) { logE("sd.NavigationTree.moveCopyListing_Callback", e); }
    },

    moveMapping_Callback: function(result) {
        try {
            if (result != "") alert(result);
        } catch (e) { logE("sd.NavigationTree.moveMapping_Callback", e); }
    },

    categoryWindowCloseHandler: function() { SDCallback.TidyUpOnCloseCategory() },

    // copied from global

    renderTree: function() {
        try {
            this.AutoCompleteLength = 0;

            this.Tree.get_nodes().clear();
            for (var x = 0; x < this.Data.Nodes.length; x++) {
                var NodeData = this.Data.Nodes[x];
                var node = this.createRTreeNode(NodeData);
                //this.AutoCompleteData[this.AutoCompleteLength++] = new nnet.sd.NavigationTree.AutoCompleteInfo(NodeData.T, NodeData.V);
                this.Tree.get_nodes().add(node);
                if (NodeData.N != null) this.addTreeNodes(node, NodeData);
            }
            $j("#TreeSearch").autocomplete('setData', { data: SD.NavigationTree.AutoCompleteData });

        } catch (e) { logE("sd.NavigationTree.renderTree", e); }
    },

    addTreeNodes: function(parentNode, parentNodeData) {
        try {
            for (var x = 0; x < parentNodeData.N.length; x++) {
                var NodeData = parentNodeData.N[x];
                var node = this.createRTreeNode(NodeData)
                //this.AutoCompleteData[this.AutoCompleteLength++] = new nnet.sd.NavigationTree.AutoCompleteInfo(NodeData.T, NodeData.V);
                parentNode.get_nodes().add(node);
                if (NodeData.N != null) this.addTreeNodes(node, NodeData);
            }
        } catch (e) { logE("sd.NavigationTree.addTreeNodes", e); }
    },

    createRTreeNode: function(nodeData) {
        try {
            var node = new Telerik.Web.UI.RadTreeNode();
            node.set_text(nodeData.T);
            node.set_value(nodeData.V);
            node.set_category(nodeData.C);
            if (nodeData.I != null) node.set_imageUrl(nodeData.I);
            node.set_expanded(nodeData.E);
            if (nodeData.M != null) node.set_contextMenuID(nodeData.M);
            else node.set_enableContextMenu(false);
            return node;
        } catch (e) { logE("sd.NavigationTree.createRTreeNode", e); }
    },

    showRTreeNode: function(value) {
        try {
            this.Tree.unselectAllNodes();
            this.Node = this.Tree.findNodeByValue(value);
            if (this.Node != null) {
                try {
                    var node = this.Node;
                    while (node = node.get_parent()) node.expand();
                } catch (e) { } // if top level wont have expand function
                this.Node.select();
                this.Node.highlight();
                return this.Node.get_category();
            }
        } catch (e) { logE("sd.NavigationTree.showRTreeNode", e); }
    }
});

nnet.sd.NavigationTree.AutoCompleteInfo = $j.klass({

    initialize: function(name, id) {
        this.Name = name;
        this.ID = id;
    }
});

nnet.sd.NavigationTree.AutoComplete = $j.klass({
    initialize: function() {
        this.Tree = null
    },

    startup: function(tree) {
    try {
        this.Tree = tree;
        var TreeNodeArray = tree.get_allNodes();

            var tb = new Ext.Toolbar();
            tb.render('TreeSearchToolbar');

            var search = new Ext.form.TextField({
                id: 'TreeSearch',
                emptyText: 'find a category...',
                selectOnFocus: true,
                width: 162
            });

            tb.addField(search);


            $j("#TreeSearch").autocomplete({
                data: TreeNodeArray,
                minChars: 2,
                scroll: false,
                max: 20,
                matchContains: true,
                formatItem: function(row, i, max) {
                    return row.get_text();
                },
                formatMatch: function(row, i, max) {
                    return row.get_text();
                },
                formatResult: function(row) {
                    return row.get_text();
                },
                result: function(event, data, formatted) {
                    SD.NavigationTree.showTreeNode(data.get_value());
                    SD.NavigationTree.search(data);
                }
            });
            nnet.sd.onNavigationTreeRendered.subscribe(SD.NavigationTree.AutoComplete.refresh);

        } catch (e) { logE("sd.NavigationTree.AutoComplete.startup", e); }
    },

    refresh: function() {
        try {
            var TreeNodeArray = SD.NavigationTree.AutoComplete.Tree.get_allNodes();
            $j("#TreeSearch").autocomplete('flushCache');
            $j("#TreeSearch").autocomplete('setData', { data: TreeNodeArray });
        } catch (e) { logE("sd.NavigationTree.AutoComplete.refresh", e); }
    }

});