/*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

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.
*/
/**
 * @module QDR
 */
/**
 * @module QDR
 */
var QDR = (function (QDR) {

  /**
   * @method OverviewController
   * @param $scope
   * @param QDRService
   * @param QDRChartServer
   * dialogServer
   * $location
   *
   * Controller that handles the QDR overview page
   */
	QDR.module.controller("QDR.OverviewController", ['$scope', 'QDRService', '$location', 'localStorage', '$timeout', function($scope, QDRService, $location, localStorage, $timeout) {

		console.log("QDR.OverviewControll started with location of " + $location.path() + " and connection of  " + QDRService.connected);
		var columnStateKey = 'QDRColumnKey.';
		var OverviewExpandedKey = "QDROverviewExpanded"
		var OverviewActivatedKey = "QDROverviewActivated"

		// we want attributes to be listed first, so add it at index 0
		$scope.subLevelTabs = [{
		    content: '<i class="icon-list"></i> Attributes',
		    title: "View the attribute values on your selection",
		    isValid: function (workspace) { return true; },
		    href: function () { return "#/" + QDR.pluginName + "/attributes"; },
		    index: 0
		},
		{
		    content: '<i class="icon-leaf"></i> Operations',
		    title: "Execute operations on your selection",
		    isValid: function (workspace) { return true; },
		    href: function () { return "#/" + QDR.pluginName + "/operations"; },
		    index: 1
		}]
		$scope.activeTab = $scope.subLevelTabs[0];
		$scope.setActive = function (nav) {
			$scope.activeTab = nav;
		}
		$scope.isValid = function (nav) {
			return nav.isValid()
		}
		$scope.isActive = function (nav) {
			return nav == $scope.activeTab;
		}
		$scope.linkFields = []
		$scope.link = null;
		var currentTimer;
		var refreshInterval = 5000
	    $scope.modes = [
	    	{title: 'Overview', name: 'Overview', right: false}
	    	];

		$scope.templates =
		[     { name: 'Routers', url: 'routers.html'},
		      { name: 'Router', url: 'router.html'},
              { name: 'Addresses', url: 'addresses.html'},
		      { name: 'Address', url: 'address.html'},
              { name: 'Links', url: 'links.html'},
		      { name: 'Link', url: 'link.html'},
              { name: 'Connections', url: 'connections.html'},
		      { name: 'Connection', url: 'connection.html'},
              { name: 'Logs', url: 'logs.html'},
              { name: 'Log', url: 'log.html'}
        ];
		var topLevelChildren = [];

		$scope.allRouterSelected = function (row ) {
			console.log("row selected" + row)
		}
		function afterSelectionChange(rowItem, checkAll) {
			var nodeId = rowItem.entity.nodeId;
			$("#overtree").dynatree("getTree").activateKey(nodeId);
        }

		$scope.allRouterFields = [];
		$scope.allRouterSelections = [];
		$scope.allRouters = {
		    saveKey: 'allRouters',
			data: 'allRouterFields',
			columnDefs: [
                 {
                     field: 'routerId',
                     saveKey: 'allRouters',
                     displayName: 'Router'
                 },
                 {
                     field: 'area',
                     displayName: 'Area'
                 },
                 {
                     field: 'mode',
                     displayName: 'Mode'
                 },
                 {
                     field: 'connections',
                     displayName: 'External connections'
                 },
                 {
                     field: 'addrCount',
                     displayName: 'Address count'
                 },
                 {
                     field: 'linkCount',
                     displayName: 'Link count'
                 }
            ],
			enableColumnResize: true,
			multiSelect: false,
			selectedItems: $scope.allRouterSelections,
			afterSelectionChange: function(data) {
				if (data.selected) {
					var selItem = $scope.allRouterSelections[0]
					var nodeId = selItem.nodeId
					// activate Routers->nodeId in the tree
					$("#overtree").dynatree("getTree").activateKey(nodeId);

				}
            }
		};

		// get info for all routers
		var allRouterInfo = function () {
			var nodeIds = QDRService.nodeIdList()
			var expected = Object.keys(nodeIds).length
			var received = 0;
			var allRouterFields = [];
			var gotNodeInfo = function (nodeName, entity, response) {
				var results = response.results;
				var name = QDRService.nameFromId(nodeName)
				var connections = 0;
				results.forEach( function (result) {
					var role = QDRService.valFor(response.attributeNames, result, "role")
					if (role != 'inter-router') {
						++connections
					}
				})
				allRouterFields.push({routerId: name, connections: connections, nodeId: nodeName})
				++received
				if (expected == received) {
					allRouterFields.sort ( function (a,b) { return a.routerId < b.routerId ? -1 : a.routerId > b.routerId ? 1 : 0})
					// now get each router's node info
					QDRService.getMultipleNodeInfo(nodeIds, "router", [], function (nodeIds, entity, responses) {
						for(var r in responses) {
							var result = responses[r]
							var routerId = QDRService.valFor(result.attributeNames, result.results[0], "routerId")
							allRouterFields.some( function (connField) {
								if (routerId === connField.routerId) {
									result.attributeNames.forEach ( function (attrName) {
										connField[attrName] = QDRService.valFor(result.attributeNames, result.results[0], attrName)
									})
									return true
								}
								return false
							})
						}
						$scope.allRouterFields = allRouterFields
					}, nodeIds[0], false)
				}
			}
			nodeIds.forEach ( function (nodeId, i) {
				QDRService.getNodeInfo(nodeId, ".connection", ["role"], gotNodeInfo)
			})
			loadColState($scope.allRouters)
			updateRouterTree(nodeIds)
		}

		$scope.routerFields = []
        $scope.routerGrid = {
            saveKey: 'routerGrid',
            data: 'routerFields',
            columnDefs: [
                 {
                     field: 'attribute',
                     displayName: 'Attribute',
                     saveKey: 'routerGrid',
                     width: '40%'
                 },
                 {
                     field: 'value',
                     displayName: 'Value',
                     width: '40%'
                 }
            ],
            enableColumnResize: true,
            multiSelect: false
        }

		// get info for a single router
		var routerInfo = function (node) {
			$scope.router = node

			$scope.routerFields = [];
			$scope.allRouterFields.some( function (field) {
				if (field.routerId === node.data.title) {
					Object.keys(field).forEach ( function (key) {
						if (key !== '$$hashKey')
							$scope.routerFields.push({attribute: key, value: field[key]})
					})
					return true
				}
			})
	        loadColState($scope.routerGrid);
		}

		$scope.addressesData = []
		$scope.selectedAddresses = []
		$scope.addressesGrid = {
			saveKey: 'addressesGrid',
			data: 'addressesData',
			columnDefs: [
                 {
                     field: 'address',
                    saveKey: 'addressesGrid',
                     displayName: 'address'
                 },
                 {
                     field: 'class',
                     displayName: 'class'
                 },
                 {
                     field: 'phase',
                     displayName: 'phase',
                     cellClass: 'grid-align-value'
                 },
                 {
                     field: 'inproc',
                     displayName: 'in-proc'
                 },
                 {
                     field: 'local',
                     displayName: 'local',
                     cellClass: 'grid-align-value'
                 },
                 {
                     field: 'remote',
                     displayName: 'remote',
                     cellClass: 'grid-align-value'
                 },
                 {
                     field: 'in',
                     displayName: 'in',
                     cellClass: 'grid-align-value'
                 },
                 {
                     field: 'out',
                     displayName: 'out',
                     cellClass: 'grid-align-value'
                 }
            ],
			enableColumnResize: true,
			multiSelect: false,
			selectedItems: $scope.selectedAddresses,
			afterSelectionChange: function(data) {
				if (data.selected) {
					var selItem = data.entity;
					var nodeId = selItem.uid
					$("#overtree").dynatree("getTree").activateKey(nodeId);
				}
            }
		};

		// get info for all addresses
		var allAddressInfo = function () {
			var gotAllAddressFields = function ( addressFields ) {
				// update the grid's data
				addressFields.sort ( function (a,b) { return a.address < b.address ? -1 : a.address > b.address ? 1 : 0})
				addressFields[0].title = addressFields[0].address
				for (var i=1; i<addressFields.length; ++i) {
					if (addressFields[i].address === addressFields[i-1].address) {
						addressFields[i-1].title = addressFields[i-1].address + " (" + addressFields[i-1]['class'] + ")"
						addressFields[i].title = addressFields[i].address + " (" + addressFields[i]['class'] + ")"
					} else
						addressFields[i].title = addressFields[i].address
				}
				$scope.addressesData = addressFields

				// repopulate the tree's child nodes
				updateAddressTree(addressFields)
			}
			getAllAddressFields(gotAllAddressFields)
	        loadColState($scope.addressesGrid);
		}

		var getAllAddressFields = function (callback) {
			var nodeIds = QDRService.nodeIdList()
			var addr_class = function (addr) {
				if (!addr) return "-"
		        if (addr[0] == 'M')  return "mobile"
		        if (addr[0] == 'R')  return "router"
		        if (addr[0] == 'A')  return "area"
		        if (addr[0] == 'L')  return "local"
		        if (addr[0] == 'C')  return "link-incoming"
		        if (addr[0] == 'D')  return "link-outgoing"
		        return "unknown: " + addr[0]
			}

			var addr_text = function (addr) {
		        if (!addr)
		            return "-"
		        if (addr[0] == 'M')
		            return addr.substring(2)
		        else
		            return addr.substring(1)
			}

			var addr_phase = function (addr) {
		        if (!addr)
		            return "-"
		        if (addr[0] == 'M')
		            return addr[1]
		        return ''
			}

			var identity_clean = function (identity) {
		        if (!identity)
		            return "-"
		        var pos = identity.indexOf('/')
		        if (pos >= 0)
		            return identity.substring(pos + 1)
		        return identity
			}

			var addressFields = []
			QDRService.getMultipleNodeInfo(nodeIds, "router.address", [], function (nodeIds, entity, response) {
				response.aggregates.forEach( function (result) {
					var prettySum = function (field) {
						var fieldIndex = response.attributeNames.indexOf(field)
						if (fieldIndex < 0) {
							return "-"
						}
						var val = result[fieldIndex].sum
						return QDRService.pretty(val)
					}

					var uid = QDRService.valFor(response.attributeNames, result, "identity").sum
					var identity = identity_clean(uid)

					addressFields.push({
						address: addr_text(identity),
						'class': addr_class(identity),
						phase:   addr_phase(identity),
						inproc:  prettySum("inProcess"),
						local:   prettySum("subscriberCount"),
						remote:  prettySum("remoteCount"),
						'in':    prettySum("deliveriesIngress"),
						out:     prettySum("deliveriesEgress"),
						thru:    prettySum("deliveriesTransit"),
						toproc:  prettySum("deliveriesToContainer"),
						fromproc:prettySum("deliveriesFromContainer"),
						uid:     uid
					})
				})
				callback(addressFields)
			}, nodeIds[0])
		}

		var updateLinkGrid = function ( linkFields ) {
			$scope.linkFields = linkFields
			// if we have a selected link
			if ($scope.link) {
				// find the selected link in the array of all links
				var links = $scope.linkFields.filter(function (link) {
					return link.name === $scope.link.data.fields.name;
				})
				if (links.length > 0) {
					// linkInfo() is the function that is called by dynatree when a link is selected
					// It is passed a dynatree node. We need to simulate that node type to update the link grid
					linkInfo({data: {title: links[0].title, fields: links[0]}})
				}
			}
		}

		// get info for a all links
		$scope.selectedLinks = []
		$scope.linksGrid = {
			saveKey: 'linksGrid',
			data: 'linkFields',
			columnDefs: [
                 {
                     field: 'link',
                     displayName: 'Link',
                     groupable:	false,
                     saveKey: 'linksGrid',
                     width: '12%'
                 },
                 {
                     field: 'linkType',
                     displayName: 'Link type',
                     groupable:	false,
                     width: '10%'
                 },
                 {
                     field: 'linkDir',
                     displayName: 'Link dir',
                     groupable:	false,
                     width: '8%'
                 },
                 {
                     field: 'adminStatus',
                     displayName: 'Admin status',
                     groupable:	false,
                     width: '10%'
                 },
                 {
                     field: 'operStatus',
                     displayName: 'Oper status',
                     groupable:	false,
                     width: '10%'
                 },
                 {
                     field: 'deliveryCount',
                     displayName: 'Delivery Count',
                     groupable:	false,
                     cellClass: 'grid-align-value',
                     width: '12%'
                 },
                 {
                     field: 'rate',
                     displayName: 'Rate',
                     groupable:	false,
                     cellClass: 'grid-align-value',
                     width: '8%'
                 },
                 {
                     field: 'uncounts',
                     displayName: 'Outstanding',
                     groupable:	false,
                     cellClass: 'grid-align-value',
                     width: '10%'
                 },
                 {
                     field: 'owningAddr',
                     displayName: 'Address',
                     groupable:	false,
                     width: '20%'
                 }
            ],
			enableColumnResize: true,
			enableColumnReordering: true,
			showColumnMenu: true,
			rowTemplate: 'linkRowTemplate.html',
			// aggregateTemplate: "linkAggTemplate.html",
	        multiSelect: false,
			selectedItems: $scope.selectedLinks,
			afterSelectionChange: function(data) {
				if (data.selected) {
					var selItem = data.entity;
					var nodeId = selItem.uid
					$("#overtree").dynatree("getTree").activateKey(nodeId);
				}
            }
		};


		$scope.$on('ngGridEventColumns', function (e, columns) {
			var saveInfo = columns.map( function (col) {
				return [col.width, col.visible]
			})
			var saveKey = columns[0].colDef.saveKey
			if (saveKey)
                localStorage.setItem(columnStateKey+saveKey, JSON.stringify(saveInfo));
        })

        var loadColState = function (grid) {
            if (!grid)
                return;
            var columns = localStorage.getItem(columnStateKey+grid.saveKey);
            if (columns) {
                var cols = JSON.parse(columns);
                cols.forEach( function (col, index) {
                    grid.columnDefs[index].width = col[0];
                    grid.columnDefs[index].visible = col[1]
                })
            }
        }
		var allLinkInfo = function () {
			getAllLinkFields([updateLinkGrid, updateLinkTree])
	        loadColState($scope.linksGrid);
		}

		var getAllLinkFields = function (callbacks) {
			var nodeIds = QDRService.nodeIdList()
			var linkFields = []
			var now = Date.now()
			var rate = function (response, result) {
				var name = QDRService.valFor(response.attributeNames, result, "linkName").sum
				var oldname = $scope.linkFields.filter(function (link) {
					return link.linkName === name
				})
				if (oldname.length > 0) {
					var elapsed = (now - oldname[0].timestamp) / 1000;
					var delivered = QDRService.valFor(response.attributeNames, result, "deliveryCount").sum - oldname[0].rawDeliveryCount
					//QDR.log.debug("elapsed " + elapsed + " delivered " + delivered)
					return elapsed > 0 ? parseFloat(Math.round((delivered/elapsed) * 100) / 100).toFixed(2) : 0;
				} else {
					//QDR.log.debug("unable to find old linkName")
					return 0
				}
			}
			QDRService.getMultipleNodeInfo(nodeIds, "router.link", [], function (nodeIds, entity, response) {
				response.aggregates.forEach( function (result) {
					var prettySum = function (field) {
						var fieldIndex = response.attributeNames.indexOf(field)
						if (fieldIndex < 0) {
							return "-"
						}
						var val = result[fieldIndex].sum
						return QDRService.pretty(val)
					}
					var uncounts = function () {
						var und = QDRService.valFor(response.attributeNames, result, "undeliveredCount").sum
						var uns = QDRService.valFor(response.attributeNames, result, "unsettledCount").sum
						return und + uns
					}
					var nameIndex = response.attributeNames.indexOf('name')
					var linkName = function () {
						var details = result[nameIndex].detail
						var names = []
						details.forEach( function (detail) {
							if (detail.node.endsWith(':'))
								names.push(detail.node.slice(0, -1))
							else
								names.push(detail.node)
						})
						//var namestr = names.join('-')
						var namestr = names.length > 0 ? names[0] : ""
						return namestr + ':' + QDRService.valFor(response.attributeNames, result, "identity").sum
					}
					var fixAddress = function () {
						var owningAddr = QDRService.valFor(response.attributeNames, result, "owningAddr").sum || ""
						/*
						     - "L*"  =>  "* (local)"
						     - "M0*" =>  "* (direct)"
						     - "M1*" =>  "* (dequeue)"
						     - "MX*" =>  "* (phase X)"
						*/
						var address = undefined;
						var starts = {'L': '(local)', 'M0': '(direct)', 'M1': '(dequeue)'}
						for (var start in starts) {
							if (owningAddr.startsWith(start)) {
								var ends = owningAddr.substr(start.length)
								address = ends + " " + starts[start]
								break;
							}
						}
						if (!address) {
							// check for MX*
							if (owningAddr.length > 3) {
								if (owningAddr[0] === 'M') {
									var phase = parseInt(owningAddress.substr(1))
									if (phase && !isNaN(phase)) {
										var phaseStr = phase + "";
										var star = owningAddress.substr(2 + phaseStr.length)
										address = star + " " + "(phase " + phaseStr + ")"
									}
								}
							}
						}
						return address || owningAddr;
					}

					var adminStatus = QDRService.valFor(response.attributeNames, result, "adminStatus").sum
					var operStatus = QDRService.valFor(response.attributeNames, result, "operStatus").sum
					var linkName = linkName()
					var linkType = QDRService.valFor(response.attributeNames, result, "linkType").sum
					if ($scope.currentLinkFilter === "" || $scope.currentLinkFilter === linkType) {
						linkFields.push({
							link:       linkName,
							title:      linkName,
							uncounts:   uncounts(),
							operStatus: operStatus,
							adminStatus:adminStatus,
							owningAddr: fixAddress(),
							deliveryCount:prettySum("deliveryCount") + " ",
							rawDeliveryCount: QDRService.valFor(response.attributeNames, result, "deliveryCount").sum,
							name: QDRService.valFor(response.attributeNames, result, "name").sum,
							linkName: QDRService.valFor(response.attributeNames, result, "linkName").sum,
							capacity: QDRService.valFor(response.attributeNames, result, "capacity").sum,
							connectionId: QDRService.valFor(response.attributeNames, result, "connectionId").sum,
							linkDir: QDRService.valFor(response.attributeNames, result, "linkDir").sum,
							linkType: linkType,
							peer: QDRService.valFor(response.attributeNames, result, "peer").sum,
							type: QDRService.valFor(response.attributeNames, result, "type").sum,
							undeliveredCount: QDRService.valFor(response.attributeNames, result, "undeliveredCount").sum,
							unsettledCount: QDRService.valFor(response.attributeNames, result, "unsettledCount").sum,
							uid:     linkName,
							timestamp: now,
							rate: rate(response, result)
						})
					}
				})
				callbacks.forEach( function (cb) {
					cb(linkFields)
				})
			}, nodeIds[0])
		}

		$scope.allConnectionFields = []
		$scope.allConnectionSelections = [];
		$scope.allConnectionGrid = {
			saveKey: 'allConnGrid',
            data: 'allConnectionFields',
            columnDefs: [
                 {
                     field: 'host',
                    saveKey: 'allConnGrid',
                     displayName: 'host'
                 },
                 {
                     field: 'container',
                     displayName: 'container'
                 },
                 {
                     field: 'role',
                     displayName: 'role'
                 },
                 {
                     field: 'dir',
                     displayName: 'dir'
                 },
                 {
                     field: 'security',
                     displayName: 'security'
                 },
                 {
                     field: 'authentication',
                     displayName: 'authentication'
                 }
            ],
            enableColumnResize: true,
            multiSelect: false,
            selectedItems: $scope.allConnectionSelections,
            afterSelectionChange: function(data) {
                if (data.selected) {
                    var selItem = $scope.allConnectionSelections[0]
                    var nodeId = selItem.host
                    // activate Routers->nodeId in the tree
                    $("#overtree").dynatree("getTree").activateKey(nodeId);
                }
            }
        };
		// get info for a all connections
		var allConnectionInfo = function () {
			var nodeIds = QDRService.nodeIdList()
			updateConnectionTree(nodeIds)
			$scope.allConnectionFields = [];;
            var connectionNodes = $("#overtree").dynatree("getTree").getNodeByKey('Connections').getChildren()
			connectionNodes.forEach( function (connection) {
				$scope.allConnectionFields.push(connection.data.fields)
			})
	        loadColState($scope.allConnectionGrid);
		}

		$scope.addressFields = []
		$scope.addressGrid = {
			saveKey: 'addGrid',
			data: 'addressFields',
			columnDefs: [
                 {
                     field: 'attribute',
                     displayName: 'Attribute',
                     saveKey: 'addGrid',
                     width: '40%'
                 },
                 {
                     field: 'value',
                     displayName: 'Value',
                     width: '40%'
                 }
            ],
			enableColumnResize: true,
			multiSelect: false
		}

		// get info for a single address
		var addressInfo = function (address) {
			if (!address)
				return;
			$scope.address = address
			$scope.addressFields = [];

			var fields = Object.keys(address.data.fields)
			fields.forEach( function (field) {
				if (field != "title" && field != "uid")
					$scope.addressFields.push({attribute: field, value: address.data.fields[field]})
			})
	        loadColState($scope.addressGrid);
		}

		$scope.singleLinkFields = []
		$scope.linkGrid = {
		    saveKey: 'linkGrid',
			data: 'singleLinkFields',
			columnDefs: [
                 {
                    field: 'attribute',
                    displayName: 'Attribute',
                     width: '40%'
                 },
                 {
                    field: 'value',
                    displayName: 'Value',
                    width: '40%'
                 }
            ],
			enableColumnResize: true,
			multiSelect: false
		}

		// display the grid detail info for a single link
		var linkInfo = function (link) {
			if (!link)
				return;
			$scope.link = link

			$scope.singleLinkFields = [];
			var fields = Object.keys(link.data.fields)
			var excludeFields = ["title", "uid", "uncounts", "rawDeliveryCount", "timestamp"]
			fields.forEach( function (field) {
				if (excludeFields.indexOf(field) == -1)
					$scope.singleLinkFields.push({attribute: field, value: link.data.fields[field]})
			})
	        loadColState($scope.linkGrid);
		}

		// get info for a single connection
		$scope.connectionModes = [{
	        content: '<a><i class="icon-list"></i> Attriutes</a>',
			id: 'attributes',
			title: "View connection attributes",
	        isValid: function () { return true; }
	    },
	    {
	        content: '<a><i class="icon-link"></i> Links</a>',
	        id: 'links',
	        title: "Show links",
	        isValid: function () { return true }
	    }
	    ];
        $scope.currentMode = $scope.connectionModes[0];
		$scope.isModeSelected = function (mode) {
			return mode === $scope.currentMode;
		}
		$scope.connectionLinks = [];
		var updateConnectionLinks = function () {
			var n = $scope.connection.data.fields
			var key = n.routerId
			var nodeInfo = QDRService.topology.nodeInfo();
			var links = nodeInfo[key]['.router.link'];
			var linkTypeIndex = links.attributeNames.indexOf('linkType');
			var connectionIdIndex = links.attributeNames.indexOf('connectionId');
			$scope.connectionLinks = [];
			links.results.forEach( function (link) {
				if (link[linkTypeIndex] === 'endpoint' && link[connectionIdIndex] === n.identity) {
					var l = {};
					l.owningAddr = QDRService.valFor(links.attributeNames, link, 'owningAddr');
					l.dir = QDRService.valFor(links.attributeNames, link, 'linkDir');
					if (l.owningAddr && l.owningAddr.length > 2)
						if (l.owningAddr[0] === 'M')
							l.owningAddr = l.owningAddr.substr(2)
						else
							l.owningAddr = l.owningAddr.substr(1)

					l.adminStatus = QDRService.valFor(links.attributeNames, link, 'adminStatus');
					l.operStatus = QDRService.valFor(links.attributeNames, link, 'operStatus');
					l.identity = QDRService.valFor(links.attributeNames, link, 'identity')
					l.connectionId = QDRService.valFor(links.attributeNames, link, 'connectionId')
/*
						l.deliveryCount = QDRService.pretty(QDRService.valFor(links.attributeNames, link, 'deliveryCount'));
						l.undeliveredCount = QDRService.pretty(QDRService.valFor(links.attributeNames, link, 'undeliveredCount'));
						l.unsettledCount = QDRService.pretty(QDRService.valFor(links.attributeNames, link, 'unsettledCount'));
*/
					// ---------------------------------------------
					// TODO: remove this fake quiescing/reviving logic when the routers do the work
					if ($scope.quiesceState.linkStates[l.identity])
						l.adminStatus = $scope.quiesceState.linkStates[l.identity];
					if ($scope.quiesceState.operStates[l.identity])
						l.operStatus = $scope.quiesceState.operStates[l.identity];
					if ($scope.quiesceState.state == 'quiescing') {
						if (l.adminStatus === 'enabled') {
							var chance = Math.floor(Math.random() * 2);
							if (chance == 1) {
								l.adminStatus = 'disabled';
								$scope.quiesceState.linkStates[l.identity] = 'disabled';
								$scope.quiesceState.operStates[l.identity] = 'idle';
							}
						}
					}
					if ($scope.quiesceState.state == 'reviving') {
						if (l.adminStatus === 'disabled') {
							var chance = Math.floor(Math.random() * 2);
							if (chance == 1) {
								l.adminStatus = 'enabled';
								$scope.quiesceState.linkStates[l.identity] = 'enabled';
								$scope.quiesceState.operStates[l.identity] = 'up';
							}
						}
					}
					if ($scope.quiesceState.linkStates[l.identity] === 'disabled') {
						l.unsettledCount = 0;
						l.undeliveredCount = 0;
						l.operState = 'idle'
						$scope.quiesceState.operStates[l.identity] = l.operState
					} else {
						l.deliveryCount = QDRService.pretty(QDRService.valFor(links.attributeNames, link, 'deliveryCount'));
						l.undeliveredCount = QDRService.pretty(QDRService.valFor(links.attributeNames, link, 'undeliveredCount'));
						l.unsettledCount = QDRService.pretty(QDRService.valFor(links.attributeNames, link, 'unsettledCount'));
						l.operState = 'up'
						$scope.quiesceState.operStates[l.identity] = l.operState
					}
					// ---------------------------------------------

					$scope.connectionLinks.push(l)
				}
			})
			$scope.connectionLinksGrid.updateState()
		}

		$scope.selectMode = function (mode) {
			$scope.currentMode = mode;
			if (mode.id === 'links') {
		        QDRService.addUpdatedAction("connectionLinks", updateConnectionLinks)
				updateConnectionLinks();
			} else {
				QDRService.delUpdatedAction("connectionLinks");
			}
		}
		$scope.isValid = function (mode) {
			return mode.isValid()
		}
		$scope.quiesceState = {
			state: 'enabled',
			buttonText: 'Quiesce',
			buttonDisabled: false,
			linkStates: {},
			operStates: {}
		}
		$scope.quiesceAllClicked = function () {
			var state = $scope.quiesceState.state;
			if (state === 'enabled') {
				// start quiescing all links
				$scope.quiesceState.state = 'quiescing';
			} else if (state === 'quiesced') {
				// start reviving all links
				$scope.quiesceState.state = 'reviving';
			}
			$scope.connectionLinksGrid.updateState();
		}
		$scope.quiesceClass = function (row) {
			var stateClassMap = {
				enabled: 'btn-primary',
				quiescing: 'btn-warning',
				reviving: 'btn-warning',
				quiesced: 'btn-danger'
			}
			return stateClassMap[$scope.quiesceState.state];
		}
		$scope.quiesceLinkClass = function (row) {
			var stateClassMap = {
				enabled: 'btn-primary',
				disabled: 'btn-danger'
			}
			return stateClassMap[row.entity.adminStatus]
		}
		$scope.quiesceLink = function (row) {
			var state = row.entity.adminStatus === 'enabled' ? 'disabled' : 'enabled';
			var operState = state === 'enabled' ? 'up' : 'idle';
			$scope.quiesceState.linkStates[row.entity.identity] = state;
			$scope.quiesceState.operStates[row.entity.identity] = operState;
		}
		$scope.quiesceLinkDisabled = function (row) {
			return false;
		}
		$scope.quiesceLinkText = function (row) {
			return row.entity.adminStatus === 'disabled' ? "Revive" : "Quiesce";
		}
		$scope.quiesceHide = function () {
			return $scope.connectionLinks.length == 0;
		}
		$scope.connectionLinksGrid = {
		    saveKey: 'connLinksGrid',

			data: 'connectionLinks',
			updateState: function () {
				var state = $scope.quiesceState.state;

				// count enabled and disabled links for this connection
				var enabled = 0, disabled = 0;
				$scope.connectionLinks.forEach ( function (link) {
					if (link.adminStatus === 'enabled')
						++enabled;
					if (link.adminStatus === 'disabled')
						++disabled;
				})

				var linkCount = $scope.connectionLinks.length;
				if (linkCount == 0) {
					$scope.quiesceState.buttonText = 'Quiesce';
					$scope.quiesceState.buttonDisabled = false;
					$scope.quiesceState.state = 'enabled'
					return;
				}
				// if state is quiescing and any links are enabled, button should say 'Quiescing' and be disabled
				if (state === 'quiescing' && (enabled > 0)) {
					$scope.quiesceState.buttonText = 'Quiescing';
					$scope.quiesceState.buttonDisabled = true;
				} else
				// if state is enabled and all links are disabled, button should say Revive and be enabled. set state to quisced
				// if state is quiescing and all links are disabled, button should say 'Revive' and be enabled. set state to quiesced
				if ((state === 'quiescing' || state === 'enabled') && (disabled === linkCount)) {
					$scope.quiesceState.buttonText = 'Revive';
					$scope.quiesceState.buttonDisabled = false;
					$scope.quiesceState.state = 'quiesced'
				} else
				// if state is reviving and any links are disabled, button should say 'Reviving' and be disabled
				if (state === 'reviving' && (disabled > 0)) {
					$scope.quiesceState.buttonText = 'Reviving';
					$scope.quiesceState.buttonDisabled = true;
				} else
				// if state is reviving or quiesced and all links are enabled, button should say 'Quiesce' and be enabled. set state to enabled
				if ((state === 'reviving' || state === 'quiesced') && (enabled === linkCount)) {
					$scope.quiesceState.buttonText = 'Quiesce';
					$scope.quiesceState.buttonDisabled = false;
					$scope.quiesceState.state = 'enabled'
				}

				if ($scope.quiesceState.state === 'quiesced') {
					d3.selectAll('.external.connection.dynatree-active')
						.classed('quiesced', true)
				} else {
					d3.selectAll('.external.connection.dynatree-active.quiesced')
						.classed('quiesced', false)
				}
			},
            columnDefs: [
			{
				field: 'adminStatus',
                cellTemplate: "titleCellTemplate.html",
				headerCellTemplate: 'titleHeaderCellTemplate.html',
			    saveKey: 'connLinksGrid',
				displayName: 'Admin state'
			},
			{
				field: 'operStatus',
                cellTemplate: "titleCellTemplate.html",
				headerCellTemplate: 'titleHeaderCellTemplate.html',
				displayName: 'Oper state'
			},
			{
				field: 'dir',
                cellTemplate: "titleCellTemplate.html",
				headerCellTemplate: 'titleHeaderCellTemplate.html',
				displayName: 'dir'
			},
			{
				field: 'owningAddr',
                cellTemplate: "titleCellTemplate.html",
				headerCellTemplate: 'titleHeaderCellTemplate.html',
				displayName: 'Address'
			},
			{
				field: 'deliveryCount',
				displayName: 'Delivered',
				headerCellTemplate: 'titleHeaderCellTemplate.html',
				cellClass: 'grid-values'

			},
			{
				field: 'undeliveredCount',
				displayName: 'Undelivered',
				headerCellTemplate: 'titleHeaderCellTemplate.html',
				cellClass: 'grid-values'
			},
			{
				field: 'unsettledCount',
				displayName: 'Unsettled',
				headerCellTemplate: 'titleHeaderCellTemplate.html',
				cellClass: 'grid-values'
			}/*,
			{
				cellClass: 'gridCellButton',
				cellTemplate: '<button title="{{quiesceLinkText(row)}} this link" type="button" ng-class="quiesceLinkClass(row)" class="btn" ng-click="quiesceLink(row)" ng-disabled="quiesceLinkDisabled(row)">{{quiesceLinkText(row)}}</button>'
			}*/
			]
		}

		$scope.connectionFields = []
		$scope.connectionGrid = {
		    saveKey: 'connGrid',
			data: 'connectionFields',
			columnDefs: [
                 {
                     field: 'attribute',
                     displayName: 'Attribute',
                    saveKey: 'connGrid',
                     width: '40%'
                 },
                 {
                     field: 'value',
                     displayName: 'Value',
                     width: '40%'
                 }
            ],
			enableColumnResize: true,
			multiSelect: false
		}

		var connectionInfo = function (connection) {
			$scope.connection = connection

			$scope.connectionFields = [];
			var fields = Object.keys(connection.data.fields)
			fields.forEach( function (field) {
				$scope.connectionFields.push({attribute: field, value: connection.data.fields[field]})
			})
			$scope.selectMode($scope.currentMode)
	        loadColState($scope.connectionGrid);
		}

		// get info for a all logs
		var allLogInfo = function () {
		}

		// get info for a single log
		var logInfo = function (node) {
			$scope.log = node
		}

		var getExpandedList = function () {
			var list = [];
			var tree = $("#overtree").dynatree("getRoot");
			if (tree.length !== 0) {
				tree.visit(function(node){
	                if (node.isExpanded()) {
	                    list.push(node.data.parent)
	                }
	            });
			}
			return list;
		}

		var updateExpanded = function () {
			var tree = $("#overtree").dynatree("getRoot");
			if (tree.length !== 0) {
				tree.visit(function(node){
	                if (node.isExpanded() || node.isActive()) {
	                    node.data.info(node)
	                }
	            });
			}
		}

		// loads the tree node name that was last selected
		var loadActivatedNode = function () {
			return localStorage[OverviewActivatedKey] || 'Routers'
		}
		// saved the tree node name that is currently selected
		var saveActivated = function (key) {
			localStorage[OverviewActivatedKey] = key;
			lastKey = key;
		}
		// loads list that was saved
		var loadExpandedNodeList = function () {
			return angular.fromJson(localStorage[OverviewExpandedKey]) || [];
		}
		// called when a node is expanded
		// here we save the expanded node so it can be restored when the page reloads
		var saveExpanded = function () {
			var list = getExpandedList();
			localStorage[OverviewExpandedKey] = JSON.stringify(list)
		}

		// activated is called each time a tree node is clicked
		// based on which node is clicked, load the correct data grid template and start getting the data
		var activated = function (node) {
			//QDR.log.debug("node activated: " + node.data.title)
			var type = node.data.type;
			saveExpanded()
			saveActivated(node.data.key)

			var template = $scope.templates.filter( function (tpl) {
				return tpl.name == type;
			})
			$scope.template = template[0];
			// the nodes info function will fetch the grids data
			if (node.data.info) {
				$timeout(function () {node.data.info(node)})
			}

		}
        $scope.template = {url: ''};

		if (!QDRService.connected) {
			QDRService.redirectWhenConnected("overview")
			return;
		}

		// we are currently connected. setup a handler to get notified if we are ever disconnected
		QDRService.addDisconnectAction( function () {
			QDRService.redirectWhenConnected("overview")
			$scope.$apply();
		})

	/* --------------------------------------------------
	 *
     * setup the tree on the left
     *
     * -------------------------------------------------
     */
		// utility function called by each top level tree node when it needs to populate its child nodes
		var updateLeaves = function (leaves, parentKey, parentFolder, worker) {
			var scrollTree = $('.qdr-overview.pane.left .pane-viewport')
			var scrollTop = scrollTree.scrollTop();
			var tree = $("#overtree").dynatree("getTree")
			var parentNode = tree.count ? tree.getNodeByKey(parentKey) : null;
			// if we were called after the tree is created, replace the existing nodes
			var activeNode;
			if (parentNode) {
				activeNode = tree.getActiveNode();
				parentNode.removeChildren();
			}
			leaves.forEach( function (leaf) {
				var childFolder = worker(leaf)
				if (parentNode)
					parentNode.addChild(childFolder)
				else
					parentFolder.children.push(childFolder)
			})
			scrollTree.scrollTop(scrollTop)
			if (activeNode) {
				var newNode = tree.getNodeByKey(activeNode.data.key)
				newNode.activateSilently()
			}
		}

		// get saved tree state
        var lastKey = loadActivatedNode();
		var expandedNodeList = loadExpandedNodeList();

		// create a routers tree branch
		var routers = new Folder("Routers")
		routers.type = "Routers"
		routers.info = allRouterInfo
		routers.activate = lastKey === 'Routers'
		routers.expand = (expandedNodeList.indexOf("Routers") > -1)
		routers.clickFolderMode = 1
		routers.key = "Routers"
		routers.parent = "Routers"
	    routers.addClass = "routers"
		topLevelChildren.push(routers)
		// called when the list of routers changes
		var updateRouterTree = function (nodes) {
			var worker = function (node) {
				var name = QDRService.nameFromId(node)
				var router = new Folder(name)
				router.type = "Router"
				router.info = routerInfo
				router.nodeId = node
				router.key = node
				router.addClass = "router"
				router.parent = "Routers"
				router.activate = lastKey === node
				return router;
			}
			updateLeaves(nodes, "Routers", routers, worker)
		}
		updateRouterTree(QDRService.nodeIdList());

		// create an addresses tree branch
		var addresses = new Folder("Addresses")
		addresses.type = "Addresses"
		addresses.info = allAddressInfo
		addresses.activate = lastKey === 'Addresses'
		addresses.expand = (expandedNodeList.indexOf("Addresses") > -1)
		addresses.clickFolderMode = 1
		addresses.key = "Addresses"
		addresses.parent = "Addresses"
	    addresses.addClass = "addresses"
		topLevelChildren.push(addresses)
		var updateAddressTree = function (addressFields) {
			var worker = function (address) {
				var a = new Folder(address.title)
				a.info = addressInfo
				a.key = address.uid
				a.fields = address
				a.type = "Address"
				a.addClass = "address"
				a.activate = lastKey === address.uid
				a.parent = "Addresses"
				return a;
			}
			updateLeaves(addressFields, "Addresses", addresses, worker)
		}
		allAddressInfo();

		$scope.setLinkFilter = function (cur) {
			// filter out non-matching links from the tree and the grid
			getAllLinkFields([updateLinkGrid, updateLinkTree])
		}
		$scope.filterClose = function () {
			var filter = $('#linkFilter')
			filter.hide();
		}
		$scope.currentLinkFilter = "endpoint"
		var filterHtml = "<button type='button' class='btn btn-secondary btn-filter'><span class='filter-icon'><i class='icon-filter'> Filter</span></button>";
		var links = new Folder("Links " + filterHtml)
		links.type = "Links"
		links.info = allLinkInfo
		links.activate = lastKey === 'Links'
		links.expand = (expandedNodeList.indexOf("Links") > -1)
		links.clickFolderMode = 1
		links.key = "Links"
		links.parent = "Links"
	    links.addClass = "links"
		topLevelChildren.push(links)

		// called both before the tree is created and whenever a background update is done
		var updateLinkTree = function (linkFields) {
			var worker = function (link) {
				var l = new Folder(link.title)
				l.info = linkInfo
				l.key = link.uid
				l.fields = link
				l.type = "Link"
				l.parent = "Links"
				l.activate = lastKey === link.uid
				l.addClass = "link"
				return l;
			}
			linkFields.sort ( function (a,b) { return a.link < b.link ? -1 : a.link > b.link ? 1 : 0})
			updateLeaves(linkFields, "Links", links, worker)
		}
		allLinkInfo();

		var connections = new Folder("Connections")
		connections.type = "Connections"
		connections.info = allConnectionInfo
		connections.activate = lastKey === 'Connections'
		connections.expand = (expandedNodeList.indexOf("Connections") > -1)
		connections.clickFolderMode = 1
		connections.key = "Connections"
		connections.parent = "Connections"
	    connections.addClass = "connections"
		topLevelChildren.push(connections)

		updateConnectionTree = function (nodes) {
			var connectionsObj = {}
			var expected = nodes.length;
			var connreceived = 0;
			nodes.forEach( function (nodeId) {
				QDRService.getNodeInfo(nodeId, ".connection", [], function (nodeName, entity, response) {
					response.results.forEach( function (result) {

						var auth = "no_auth"
						var sasl = QDRService.valFor(response.attributeNames, result, "sasl")
						if (QDRService.valFor(response.attributeNames, result, "isAuthenticated")) {
							auth = sasl
							if (sasl === "ANONYMOUS")
								auth = "anonymous-user"
							else {
								if (sasl === "GSSAPI")
									sasl = "Kerberos"
								if (sasl === "EXTERNAL")
									sasl = "x.509"
								auth = QDRService.valFor(response.attributeNames, result, "user") + "(" +
										QDRService.valFor(response.attributeNames, result, "sslCipher") + ")"
								}
						}

						var sec = "no-security"
						if (QDRService.valFor(response.attributeNames, result, "isEncrypted")) {
							if (sasl === "GSSAPI")
								sec = "Kerberos"
							else
								sec = QDRService.valFor(response.attributeNames, result, "sslProto") + "(" +
										QDRService.valFor(response.attributeNames, result, "sslCipher") + ")"
						}

						var host = QDRService.valFor(response.attributeNames, result, "host")
						connectionsObj[host] = {}
						response.attributeNames.forEach( function (attribute, i) {
							connectionsObj[host][attribute] = result[i]
						})
						connectionsObj[host].security = sec
						connectionsObj[host].authentication = auth
						connectionsObj[host].routerId = nodeName

					})
					++connreceived;
					if (connreceived == expected) {
						var worker = function (connection) {
							var c = new Folder(connection)
							c.type = "Connection"
							c.info = connectionInfo
							c.key = connection
							c.fields = connectionsObj[connection]
							c.tooltip = connectionsObj[connection].role === "inter-router" ? "inter-router connection" : "external connection"
							c.addClass = c.tooltip
							c.parent = "Connections"
							c.activate = lastKey === connection
							return c
						}
						var allConnections = Object.keys(connectionsObj).sort()
						updateLeaves(allConnections, "Connections", connections, worker)
					}
				})
			})
		}
		updateConnectionTree(QDRService.nodeIdList())

		var logsreceived = 0;
		var logObj = {}
		var logs = new Folder("Logs")
		logs.type = "Logs"
		logs.info = allLogInfo
		logs.activate = lastKey === 'Logs'
		logs.expand = (expandedNodeList.indexOf("Logs") > -1)
		logs.clickFolderMode = 1
		logs.key = "Logs"
		logs.parent = "Logs"
		//topLevelChildren.push(logs)
		var nodeIds = QDRService.nodeIdList()
		var expected = nodeIds.length;
		nodeIds.forEach( function (nodeId) {
			QDRService.getNodeInfo(nodeId, ".log", ["name"], function (nodeName, entity, response) {
				response.results.forEach( function (result) {
					logObj[result[0]] = 1    // use object to collapse duplicates
				})
				++logsreceived;
				if (logsreceived == expected) {
					var allLogs = Object.keys(logObj).sort()
					allLogs.forEach(function (log) {
						var l = new Folder(log)
						l.type = "Log"
						l.info = logInfo
						l.key = log
						l.parent = "Logs"
						l.activate = lastKey === log
						logs.children.push(l)
					})
					$('#overtree').dynatree({
						onActivate: activated,
						onExpand: saveExpanded,
						onClick: function (n, e) {
							if (e.target.className.indexOf('-filter') > -1) {
								//QDR.log.debug("overtree on click called")
								e.preventDefault();
								e.stopPropagation()
								var filter = $('#linkFilter')
								var treeLink = $('span.links')
								filter.css({
                                              top: treeLink.offset().top + treeLink.height(),
                                              left: treeLink.offset().left,
                                              zIndex:5000
                                            });
								filter.toggle()
								$("#overtree").dynatree("getTree").getNodeByKey('Links').activate()
								return false;
							}
						},
						selectMode: 1,
						activeVisible: false,
						children: topLevelChildren
					})
					// simulate a click on the previous active node
					var active = $("#overtree").dynatree("getActiveNode");
					if (!active) {
						active = $("#overtree").dynatree("getTree").getNodeByKey("Routers")
					}
					activated(active);

					// populate the data for each expanded node
					updateExpanded();
					QDRService.addUpdatedAction( "overview", function () {
						$timeout(updateExpanded);
					})
					// update the node list
					QDRService.startUpdating()

			        loadColState($scope.allRouters);
			        loadColState($scope.routerGrid);
			        loadColState($scope.addressesGrid);
			        loadColState($scope.addressGrid);
			        loadColState($scope.linksGrid);
			        loadColState($scope.linkGrid);
			        loadColState($scope.allConnectionGrid);
			        loadColState($scope.connectionGrid);

				}
			})
		})

        $scope.$on("$destroy", function( event ) {
			QDRService.stopUpdating()
			QDRService.delUpdatedAction("overview")
			if (currentTimer) {
				clearTimeout(currentTimer)
				currentTimer = null;
			}
        });

    }]);

  return QDR;

}(QDR || {}));