// 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.
(function(cloudStack) {
    cloudStack.sections.metrics = {
        title: 'label.metrics',
        listView: {
            id: 'metrics',
            fields: {
                name: {
                    label: 'metrics'
                }
            },
        }
    };


    // Zones Metrics
    cloudStack.sections.metrics.zones = {
        title: 'label.metrics',
        listView: {
            id: 'physicalResources',
            fields: {
                name: {
                    label: 'label.metrics.name'
                },
                state: {
                    label: 'label.metrics.state',
                    converter: function (str) {
                        // For localization
                        return str;
                    },
                    indicator: {
                        'Enabled': 'on',
                        'Disabled': 'off'
                    },
                    compact: true
                },
                clusters : {
                    label: 'label.metrics.clusters'
                },
                cpuused: {
                    label: 'label.metrics.cpu.usage',
                    collapsible: true,
                    columns: {
                        cpuusedavg: {
                            label: 'label.metrics.cpu.used.avg',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'cpunotificationthreshold',
                                disable: 'cpudisablethreshold'
                            }
                        },
                        cpumaxdev: {
                            label: 'label.metrics.cpu.max.dev'
                        }
                    }
                },
                cpuallocated: {
                    label: 'label.metrics.cpu.allocated',
                    collapsible: true,
                    columns: {
                        cpuallocated: {
                            label: 'label.metrics.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'cpunotificationthreshold',
                                disable: 'cpudisablethreshold'
                            }
                        },
                        cputotal: {
                            label: 'label.metrics.cpu.total'
                        }
                    }
                },
                memused: {
                    label: 'label.metrics.memory.usage',
                    collapsible: true,
                    columns: {
                        memusedavg: {
                            label: 'label.metrics.memory.used.avg',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'memnotificationthreshold',
                                disable: 'memdisablethreshold'
                            }
                        },
                        memmaxdev: {
                            label: 'label.metrics.memory.max.dev'
                        }
                    }
                },
                memallocated: {
                    label: 'label.metrics.memory.allocated',
                    collapsible: true,
                    columns: {
                        memallocated: {
                            label: 'label.metrics.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'memnotificationthreshold',
                                disable: 'memdisablethreshold'
                            }
                        },
                        memtotal: {
                            label: 'label.metrics.memory.total'
                        }
                    }
                }
            },
            dataProvider: function(args) {
                var data = {};
                listViewDataProvider(args, data);
                $.ajax({
                    url: createURL('listZones'),
                    data: data,
                    success: function(json) {
                        var items = json.listzonesresponse.zone;
                        if (items) {
                            $.each(items, function(idx, zone) {
                                items[idx].clusters = 0;
                                items[idx].clustersUp = 0;
                                items[idx].hosts = 0;
                                items[idx].cpuusedavg = 0.0;
                                items[idx].cpumaxdev = 0.0;
                                items[idx].cpuallocated = 0.0;
                                items[idx].cputotal = 0.0;
                                items[idx].maxCpuUsed = 0.0;
                                items[idx].memusedavg = 0.0;
                                items[idx].memmaxdev = 0.0;
                                items[idx].memallocated = 0.0;
                                items[idx].memtotal = 0.0;
                                items[idx].maxMemUsed = 0.0;

                                // Threshold color coding
                                items[idx].cpunotificationthreshold = 75.0;
                                items[idx].cpudisablethreshold = 95.0;
                                items[idx].memnotificationthreshold = 75.0;
                                items[idx].memdisablethreshold = 95.0;

                                $.ajax({
                                    url: createURL('listClusters'),
                                    data: {zoneid: zone.id},
                                    success: function(json) {
                                        if (json && json.listclustersresponse && json.listclustersresponse.cluster && json.listclustersresponse.count) {
                                            items[idx].clusters += parseInt(json.listclustersresponse.count);
                                            $.each(json.listclustersresponse.cluster, function(i, cluster) {
                                                if (cluster.allocationstate == 'Enabled' && cluster.managedstate == 'Managed') {
                                                    items[idx].clustersUp++;
                                                }
                                                $.ajax({
                                                    url: createURL('listHosts'),
                                                    data: {clusterid: cluster.id, type: 'routing'},
                                                    success: function(json) {
                                                        if (json && json.listhostsresponse && json.listhostsresponse.host && json.listhostsresponse.count) {
                                                            items[idx].hosts += parseInt(json.listhostsresponse.count);
                                                            $.each(json.listhostsresponse.host, function(i, host) {
                                                                if (host.hasOwnProperty('cpuused')) {
                                                                    var hostCpuUsage = parseFloat(host.cpuused);
                                                                    items[idx].cpuusedavg += hostCpuUsage;
                                                                    if (hostCpuUsage > items[idx].maxCpuUsed) {
                                                                        items[idx].maxCpuUsed = hostCpuUsage;
                                                                    }
                                                                }

                                                                if (host.hasOwnProperty('cpuallocated')) {
                                                                    items[idx].cpuallocated += parseFloat(host.cpuallocated.replace('%', ''));
                                                                }

                                                                if (host.hasOwnProperty('memoryused')) {
                                                                    var hostMemoryUsage = 100.0 * parseFloat(host.memoryused) /  parseFloat(host.memorytotal);
                                                                    items[idx].memusedavg += hostMemoryUsage;
                                                                    if (hostMemoryUsage > items[idx].maxMemUsed) {
                                                                        items[idx].maxMemUsed = hostMemoryUsage;
                                                                    }
                                                                }

                                                                if (host.hasOwnProperty('memoryallocated')) {
                                                                    items[idx].memallocated += parseFloat(100.0 * parseFloat(host.memoryallocated)/parseFloat(host.memorytotal));
                                                                }
                                                            });
                                                        }
                                                    },
                                                    async: false
                                                });
                                            });
                                        }
                                    },
                                    async: false
                                });

                                $.ajax({
                                    url: createURL('listCapacity'),
                                    data: {zoneid: zone.id},
                                    success: function(json) {
                                        if (json && json.listcapacityresponse && json.listcapacityresponse.capacity) {
                                            $.each(json.listcapacityresponse.capacity, function(i, capacity) {
                                                // CPU
                                                if (capacity.type == 1) {
                                                    items[idx].cputotal = parseInt(capacity.capacitytotal)/1000.0;
                                                }
                                                // Memory
                                                if (capacity.type == 0) {
                                                    items[idx].memtotal = parseInt(capacity.capacitytotal)/(1024.0*1024.0*1024.0);
                                                }
                                            });
                                        }
                                    },
                                    async: false
                                });

                                if (items[idx].hosts != 0) {
                                    items[idx].cpuusedavg = (items[idx].cpuusedavg / items[idx].hosts);
                                    items[idx].cpumaxdev = (items[idx].maxCpuUsed - items[idx].cpuusedavg);
                                    items[idx].cpuallocated = (items[idx].cpuallocated / items[idx].hosts);

                                    items[idx].memusedavg = (items[idx].memusedavg / items[idx].hosts);
                                    items[idx].memmaxdev = (items[idx].maxMemUsed - items[idx].memusedavg);
                                    items[idx].memallocated = (items[idx].memallocated / items[idx].hosts);
                                }
                                // Format data
                                items[idx].cpuusedavg = (items[idx].cpuusedavg).toFixed(2) + "%";
                                items[idx].cpumaxdev = (items[idx].cpumaxdev).toFixed(2) + "%";
                                items[idx].cpuallocated = (items[idx].cpuallocated).toFixed(2) + "%";
                                items[idx].cputotal = (items[idx].cputotal).toFixed(2) + " Ghz";

                                items[idx].memusedavg = (items[idx].memusedavg).toFixed(2) + "%";
                                items[idx].memmaxdev = (items[idx].memmaxdev).toFixed(2) + "%";
                                items[idx].memallocated = (items[idx].memallocated).toFixed(2) + "%";
                                items[idx].memtotal = (items[idx].memtotal).toFixed(2) + " GB";

                                items[idx].clusters = items[idx].clustersUp + ' / ' + items[idx].clusters;
                                items[idx].state = items[idx].allocationstate;
                            });
                        }
                        args.response.success({
                            data: items
                        });
                    }
                });
            },
            browseBy: {
                filterBy: 'zoneid',
                resource: 'clusters'
            },
            detailView: cloudStack.sections.system.physicalResourceSection.sections.physicalResources.listView.zones.detailView
        }
    };


    // Clusters Metrics
    cloudStack.sections.metrics.clusters = {
        title: 'label.metrics',
        listView: {
            id: 'clusters',
            fields: {
                name: {
                    label: 'label.metrics.name'
                },
                state: {
                    label: 'label.metrics.state',
                    converter: function (str) {
                        // For localization
                        return str;
                    },
                    indicator: {
                        'Enabled': 'on',
                        'Unmanaged': 'warning',
                        'Disabled': 'off'
                    },
                    compact: true
                },
                hosts: {
                    label: 'label.metrics.hosts'
                },
                cpuused: {
                    label: 'label.metrics.cpu.usage',
                    collapsible: true,
                    columns: {
                        cpuusedavg: {
                            label: 'label.metrics.cpu.used.avg',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'cpunotificationthreshold',
                                disable: 'cpudisablethreshold'
                            }
                        },
                        cpumaxdev: {
                            label: 'label.metrics.cpu.max.dev'
                        }
                    }
                },
                cpuallocated: {
                    label: 'label.metrics.cpu.allocated',
                    collapsible: true,
                    columns: {
                        cpuallocated: {
                            label: 'label.metrics.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'cpunotificationthreshold',
                                disable: 'cpudisablethreshold'
                            }
                        },
                        cputotal: {
                            label: 'label.metrics.cpu.total'
                        }
                    }
                },
                memused: {
                    label: 'label.metrics.memory.usage',
                    collapsible: true,
                    columns: {
                        memusedavg: {
                            label: 'label.metrics.memory.used.avg',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'memnotificationthreshold',
                                disable: 'memdisablethreshold'
                            }
                        },
                        memmaxdev: {
                            label: 'label.metrics.memory.max.dev'
                        }
                    }
                },
                memallocated: {
                    label: 'label.metrics.memory.allocated',
                    collapsible: true,
                    columns: {
                        memallocated: {
                            label: 'label.metrics.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'memnotificationthreshold',
                                disable: 'memdisablethreshold'
                            }
                        },
                        memtotal: {
                            label: 'label.metrics.memory.total'
                        }
                    }
                }
            },
            dataProvider: function(args) {
                var data = {};
                listViewDataProvider(args, data);
                if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
                    data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
                }
                $.ajax({
                    url: createURL('listClusters'),
                    data: data,
                    success: function(json) {
                        var items = json.listclustersresponse.cluster;
                        if (items) {
                            $.each(items, function(idx, cluster) {
                                items[idx].hosts = 0;
                                items[idx].hostsUp = 0;
                                items[idx].cpuusedavg = 0.0;
                                items[idx].cpumaxdev = 0.0;
                                items[idx].cpuallocated = 0.0;
                                items[idx].cputotal = 0.0;
                                items[idx].maxCpuUsed = 0;
                                items[idx].memusedavg = 0.0;
                                items[idx].memmaxdev = 0.0;
                                items[idx].memallocated = 0.0;
                                items[idx].memtotal = 0.0;
                                items[idx].maxMemUsed = 0.0;

                                // Threshold color coding
                                items[idx].cpunotificationthreshold = 75.0;
                                items[idx].cpudisablethreshold = 95.0;
                                items[idx].memnotificationthreshold = 75.0;
                                items[idx].memdisablethreshold = 95.0;

                                $.ajax({
                                    url: createURL('listConfigurations'),
                                    data: {clusterid: cluster.id, listAll: true},
                                    success: function(json) {
                                        if (json.listconfigurationsresponse && json.listconfigurationsresponse.configuration) {
                                            $.each(json.listconfigurationsresponse.configuration, function(i, config) {
                                                switch (config.name) {
                                                    case 'cluster.cpu.allocated.capacity.disablethreshold':
                                                        items[idx].cpudisablethreshold = 100 * parseFloat(config.value);
                                                        break;
                                                    case 'cluster.cpu.allocated.capacity.notificationthreshold':
                                                        items[idx].cpunotificationthreshold = 100 * parseFloat(config.value);
                                                        break;
                                                    case 'cluster.memory.allocated.capacity.disablethreshold':
                                                        items[idx].memdisablethreshold = 100 * parseFloat(config.value);
                                                        break;
                                                    case 'cluster.memory.allocated.capacity.notificationthreshold':
                                                        items[idx].memnotificationthreshold = 100 * parseFloat(config.value);
                                                        break;
                                                }
                                            });
                                        }
                                    },
                                    async: false
                                });

                                $.ajax({
                                    url: createURL('listHosts'),
                                    data: {clusterid: cluster.id, type: 'routing'},
                                    success: function(json) {
                                        if (json && json.listhostsresponse && json.listhostsresponse.host && json.listhostsresponse.count) {
                                            items[idx].hosts += parseInt(json.listhostsresponse.count);
                                            $.each(json.listhostsresponse.host, function(i, host) {
                                                if (host.state == 'Up') {
                                                    items[idx].hostsUp += 1;
                                                }
                                                if (host.hasOwnProperty('cpuused')) {
                                                    var hostCpuUsage = parseFloat(host.cpuused);
                                                    items[idx].cpuusedavg += hostCpuUsage;
                                                    if (hostCpuUsage > items[idx].maxCpuUsed) {
                                                        items[idx].maxCpuUsed = hostCpuUsage;
                                                    }
                                                }

                                                if (host.hasOwnProperty('cpuallocated')) {
                                                    items[idx].cpuallocated += parseFloat(host.cpuallocated.replace('%', ''));
                                                }

                                                if (host.hasOwnProperty('memoryused')) {
                                                    var hostMemoryUsage = 100.0 * parseFloat(host.memoryused) /  parseFloat(host.memorytotal);
                                                    items[idx].memusedavg += hostMemoryUsage;
                                                    if (hostMemoryUsage > items[idx].maxMemUsed) {
                                                        items[idx].maxMemUsed = hostMemoryUsage;
                                                    }
                                                }

                                                if (host.hasOwnProperty('memoryallocated')) {
                                                    items[idx].memallocated += parseFloat(100.0 * parseFloat(host.memoryallocated)/parseFloat(host.memorytotal));
                                                }
                                            });
                                        }
                                    },
                                    async: false
                                });

                                $.ajax({
                                    url: createURL('listCapacity'),
                                    data: {clusterid: cluster.id},
                                    success: function(json) {
                                        if (json && json.listcapacityresponse && json.listcapacityresponse.capacity) {
                                            $.each(json.listcapacityresponse.capacity, function(i, capacity) {
                                                // CPU
                                                if (capacity.type == 1) {
                                                    items[idx].cputotal = parseInt(capacity.capacitytotal)/1000.0;
                                                }
                                                // Memory
                                                if (capacity.type == 0) {
                                                    items[idx].memtotal = parseInt(capacity.capacitytotal)/(1024.0*1024.0*1024.0);
                                                }
                                            });
                                        }
                                    },
                                    async: false
                                });

                                if (items[idx].hosts != 0) {
                                    items[idx].cpuusedavg = (items[idx].cpuusedavg / items[idx].hosts);
                                    items[idx].cpumaxdev = (items[idx].maxCpuUsed - items[idx].cpuusedavg);
                                    items[idx].cpuallocated = (items[idx].cpuallocated / items[idx].hosts);

                                    items[idx].memusedavg = (items[idx].memusedavg / items[idx].hosts);
                                    items[idx].memmaxdev = (items[idx].maxMemUsed - items[idx].memusedavg);
                                    items[idx].memallocated = (items[idx].memallocated / items[idx].hosts);
                                }

                                // Format data
                                items[idx].cpuusedavg = (items[idx].cpuusedavg).toFixed(2) + "%";
                                items[idx].cpumaxdev = (items[idx].cpumaxdev).toFixed(2) + "%";
                                items[idx].cpuallocated = (items[idx].cpuallocated).toFixed(2) + "%";
                                items[idx].cputotal = (items[idx].cputotal).toFixed(2) + " Ghz";

                                items[idx].memusedavg = (items[idx].memusedavg).toFixed(2) + "%";
                                items[idx].memmaxdev = (items[idx].memmaxdev).toFixed(2) + "%";
                                items[idx].memallocated = (items[idx].memallocated).toFixed(2) + "%";
                                items[idx].memtotal = (items[idx].memtotal).toFixed(2) + " GB";
                                items[idx].hosts = items[idx].hostsUp + ' / ' + items[idx].hosts;

                                items[idx].state = items[idx].allocationstate;
                                if (items[idx].managedstate == 'Unmanaged') {
                                    items[idx].state = 'Unmanaged';
                                }

                                if (items[idx].managedstate == 'Managed' && items[idx].allocationstate == 'Enabled') {
                                    items[idx].state = 'Enabled';
                                }

                                if (items[idx].managedstate == 'Managed' && items[idx].allocationstate == 'Disabled') {
                                    items[idx].state = 'Disabled';
                                }
                            });
                        }
                        args.response.success({
                            data: items
                        });
                    }
                });
            },
            browseBy: {
                filterBy: 'clusterid',
                resource: 'hosts'
            },
            detailView: cloudStack.sections.system.subsections.clusters.listView.detailView
        }
    };


    // Hosts Metrics
    cloudStack.sections.metrics.hosts = {
        title: 'label.metrics',
        listView: {
            id: 'hosts',
            fields: {
                name: {
                    label: 'label.metrics.name'
                },
                state: {
                    label: 'label.metrics.state',
                    converter: function (str) {
                        // For localization
                        return str;
                    },
                    indicator: {
                        'Up': 'on',
                        'Down': 'off',
                        'Disconnected': 'off',
                        'Removed': 'off',
                        'Error': 'off',
                        'Connecting': 'transition',
                        'Rebalancing': 'transition',
                        'Alert': 'warning',
                    },
                    compact: true
                },
                cpuused: {
                    label: 'label.metrics.cpu.usage',
                    collapsible: true,
                    columns: {
                        cores: {
                            label: 'label.metrics.num.cpu.cores',
                        },
                        cputotal: {
                            label: 'label.metrics.cpu.total'
                        },
                        cpuusedavg: {
                            label: 'label.metrics.cpu.used.avg',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'cpunotificationthreshold',
                                disable: 'cpudisablethreshold'
                            }
                        },
                        cpuallocated: {
                            label: 'label.metrics.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'cpunotificationthreshold',
                                disable: 'cpudisablethreshold'
                            }
                        }
                    }
                },
                memused: {
                    label: 'label.metrics.memory.usage',
                    collapsible: true,
                    columns: {
                        memtotal: {
                            label: 'label.metrics.memory.total'
                        },
                        memusedavg: {
                            label: 'label.metrics.memory.used.avg',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'memnotificationthreshold',
                                disable: 'memdisablethreshold'
                            }
                        },
                        memallocated: {
                            label: 'label.metrics.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'memnotificationthreshold',
                                disable: 'memdisablethreshold'
                            }
                        }
                    }
                },
                network: {
                    label: 'label.metrics.network.usage',
                    collapsible: true,
                    columns: {
                        networkread: {
                            label: 'label.metrics.network.read'
                        },
                        networkwrite: {
                            label: 'label.metrics.network.write'
                        }
                    }
                }
            },
            dataProvider: function(args) {
                var data = {};
                data.type = 'routing';
                listViewDataProvider(args, data);
                if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
                    data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
                }
                $.ajax({
                    url: createURL('listHosts'),
                    data: data,
                    success: function(json) {
                        var items = json.listhostsresponse.host;
                        if (items) {
                            $.each(items, function(idx, host) {
                                items[idx].cores = host.cpunumber;
                                items[idx].cputotal = (parseFloat(host.cpunumber) * parseFloat(host.cpuspeed) / 1000.0).toFixed(2);
                                if (host.cpuused) {
                                    items[idx].cpuusedavg = (parseFloat(host.cpuused) * items[idx].cputotal / 100.0).toFixed(2) + ' Ghz';
                                } else {
                                    items[idx].cpuusedavg = '--';
                                }
                                items[idx].cpuallocated = (parseFloat(host.cpuallocated) * items[idx].cputotal / 100.0).toFixed(2) + ' Ghz';
                                items[idx].memtotal = (parseFloat(host.memorytotal)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
                                items[idx].memallocated = (parseFloat(host.memoryallocated)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
                                if (host.memoryused) {
                                    items[idx].memusedavg = (parseFloat(host.memoryused)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
                                } else {
                                    items[idx].memusedavg = '--';
                                }
                                if (host.networkkbsread && host.networkkbswrite) {
                                    items[idx].networkread = (parseFloat(host.networkkbsread)/(1024.0*1024.0)).toFixed(2) + ' GB';
                                    items[idx].networkwrite = (parseFloat(host.networkkbswrite)/(1024.0*1024.0)).toFixed(2) + ' GB';
                                } else {
                                    items[idx].networkread = '--';
                                    items[idx].networkwrite = '--';
                                }

                                // Threshold color coding
                                items[idx].cpunotificationthreshold = 0.75 * parseFloat(items[idx].cputotal);
                                items[idx].cpudisablethreshold = 0.95 * parseFloat(items[idx].cputotal);
                                items[idx].memnotificationthreshold = 0.75 * parseFloat(items[idx].memtotal);
                                items[idx].memdisablethreshold = 0.95 * parseFloat(items[idx].memtotal);

                                $.ajax({
                                    url: createURL('listConfigurations'),
                                    data: {clusterid: host.clusterid, listAll: true},
                                    success: function(json) {
                                        if (json.listconfigurationsresponse && json.listconfigurationsresponse.configuration) {
                                            $.each(json.listconfigurationsresponse.configuration, function(i, config) {
                                                switch (config.name) {
                                                    case 'cluster.cpu.allocated.capacity.disablethreshold':
                                                        items[idx].cpudisablethreshold = parseFloat(config.value) * parseFloat(items[idx].cputotal);
                                                        break;
                                                    case 'cluster.cpu.allocated.capacity.notificationthreshold':
                                                        items[idx].cpunotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].cputotal);
                                                        break;
                                                    case 'cluster.memory.allocated.capacity.disablethreshold':
                                                        items[idx].memdisablethreshold = parseFloat(config.value) * parseFloat(items[idx].memtotal);
                                                        break;
                                                    case 'cluster.memory.allocated.capacity.notificationthreshold':
                                                        items[idx].memnotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].memtotal);
                                                        break;
                                                }
                                            });
                                        }
                                    },
                                    async: false
                                });

                                var cpuOverCommit = 1.0;
                                var memOverCommit = 1.0;
                                $.ajax({
                                    url: createURL('listClusters'),
                                    data: {clusterid: host.clusterid, listAll: true},
                                    success: function(json) {
                                        if (json.listclustersresponse && json.listclustersresponse.cluster) {
                                            var cluster = json.listclustersresponse.cluster[0];
                                            cpuOverCommit = cluster.cpuovercommitratio;
                                            memOverCommit = cluster.memoryovercommitratio;
                                        }
                                    },
                                    async: false
                                });

                                items[idx].cputotal = items[idx].cputotal + ' Ghz (x' + cpuOverCommit + ')';
                                items[idx].memtotal = items[idx].memtotal + ' (x' + memOverCommit + ')';
                            });
                        }
                        args.response.success({
                            data: items
                        });
                    }
                });
            },
            browseBy: {
                filterBy: 'hostid',
                resource: 'vms'
            },
            detailView: cloudStack.sections.system.subsections.hosts.listView.detailView
        }
    };


    // VMs Metrics
    cloudStack.sections.metrics.instances = {
        title: 'label.metrics',
        listView: {
            id: 'instances',
            fields: {
                name: {
                    label: 'label.metrics.name'
                },
                state: {
                    label: 'label.metrics.state',
                    converter: function (str) {
                        // For localization
                        return str;
                    },
                    indicator: {
                        'Running': 'on',
                        'Stopped': 'off',
                        'Error': 'off',
                        'Destroyed': 'off',
                        'Expunging': 'off',
                        'Stopping': 'transition',
                        'Starting': 'transition',
                        'Migrating': 'transition',
                        'Shutdowned': 'warning',
                    },
                    compact: true
                },
                cpuused: {
                    label: 'label.metrics.cpu.usage',
                    collapsible: true,
                    columns: {
                        cores: {
                            label: 'label.metrics.num.cpu.cores',
                        },
                        cputotal: {
                            label: 'label.metrics.cpu.total'
                        },
                        cpuused: {
                            label: 'label.metrics.cpu.used.avg',
                        }
                    }
                },
                memused: {
                    label: 'label.metrics.memory.usage',
                    collapsible: true,
                    columns: {
                        memallocated: {
                            label: 'label.metrics.allocated'
                        },
                        memused: {
                            label: 'label.metrics.memory.used.avg'
                        }
                    }
                },
                network: {
                    label: 'label.metrics.network.usage',
                    collapsible: true,
                    columns: {
                        networkread: {
                            label: 'label.metrics.network.read'
                        },
                        networkwrite: {
                            label: 'label.metrics.network.write'
                        }
                    }
                },
                disk: {
                    label: 'label.metrics.disk.usage',
                    collapsible: true,
                    columns: {
                        diskread: {
                            label: 'label.metrics.disk.read'
                        },
                        diskwrite: {
                            label: 'label.metrics.disk.write'
                        },
                        diskiopstotal: {
                            label: 'label.metrics.disk.iops.total'
                        }
                    }
                }
            },
            dataProvider: function(args) {
                var data = {};
                listViewDataProvider(args, data);
                if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
                    data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
                }
                $.ajax({
                    url: createURL('listVirtualMachines'),
                    data: data,
                    success: function(json) {
                        var items = [];
                        if (json && json.listvirtualmachinesresponse && json.listvirtualmachinesresponse.virtualmachine) {
                            items = json.listvirtualmachinesresponse.virtualmachine;
                            $.each(items, function(idx, vm) {
                                items[idx].cores = vm.cpunumber;
                                items[idx].cputotal = (parseFloat(vm.cpunumber) * parseFloat(vm.cpuspeed)).toFixed(0) + ' Mhz';
                                items[idx].cpuusedavg = vm.cpuused;
                                items[idx].cpuallocated = vm.cpuallocated;
                                items[idx].memallocated = (parseFloat(vm.memory)/1024.0).toFixed(2) + ' GB';
                                items[idx].memused = (parseFloat(vm.memoryused)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
                                items[idx].networkread = (parseFloat(vm.networkkbsread)/(1024.0)).toFixed(2) + ' MB';
                                items[idx].networkwrite = (parseFloat(vm.networkkbswrite)/(1024.0)).toFixed(2) + ' MB';
                                items[idx].diskread = (parseFloat(vm.diskkbsread)/(1024.0)).toFixed(2) + ' MB';
                                items[idx].diskwrite = (parseFloat(vm.diskkbswrite)/(1024.0)).toFixed(2) + ' MB';
                                items[idx].diskiopstotal = parseFloat(vm.diskioread) + parseFloat(vm.diskiowrite);

                                var keys = [{'cpuused': 'cpuusedavg'},
                                            {'memoryused': 'memused'},
                                            {'networkkbsread': 'networkread'},
                                            {'networkkbswrite': 'networkwrite'},
                                            {'diskkbsread': 'diskread'},
                                            {'diskkbswrite': 'diskwrite'},
                                            {'diskioread': 'diskiopstotal'}];
                                for (keyIdx in keys) {
                                    var map = keys[keyIdx];
                                    var key = Object.keys(map)[0];
                                    var uiKey = map[key];
                                    if (!vm.hasOwnProperty(key)) {
                                        items[idx][uiKey] = '--';
                                    }
                                }
                            });
                        }
                        args.response.success({
                            data: items
                        });
                    }
                });
            },
            browseBy: {
                filterBy: 'virtualmachineid',
                resource: 'volumes'
            },
            detailView: cloudStack.sections.instances.listView.detailView
        }
    };


    // Volumes Metrics
    cloudStack.sections.metrics.volumes = {
        title: 'label.metrics',
        listView: {
            id: 'volumes',
            fields: {
                name: {
                    label: 'label.metrics.name'
                },
                state: {
                    label: 'label.metrics.state',
                    converter: function (str) {
                        // For localization
                        return str;
                    },
                    indicator: {
                        'Allocated': 'transition',
                        'Creating': 'transition',
                        'Ready': 'on',
                        'Destroy': 'off',
                        'Expunging': 'off',
                        'Migrating': 'warning',
                        'UploadOp': 'transition',
                        'Snapshotting': 'warning',
                    },
                    compact: true
                },
                vmname: {
                    label: 'label.metrics.vm.name'
                },
                diskoffering: {
                    label: 'label.metrics.disk.offering'
                },
                disksize: {
                    label: 'label.metrics.disk.size'
                },
                storagetype: {
                    label: 'label.metrics.disk.storagetype'
                },
                storagepool: {
                    label: 'label.metrics.storagepool'
                },
            },
            dataProvider: function(args) {
                var data = {listAll: true};
                listViewDataProvider(args, data);
                if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
                    data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
                }
                $.ajax({
                    url: createURL('listVolumes'),
                    data: data,
                    success: function(json) {
                        var items = [];
                        if (json && json.listvolumesresponse && json.listvolumesresponse.volume) {
                            items = json.listvolumesresponse.volume;
                            $.each(items, function(idx, volume) {
                                items[idx].name = volume.name;
                                items[idx].state = volume.state;
                                items[idx].vmname = volume.vmname;
                                items[idx].diskoffering = volume.diskofferingname;
                                items[idx].disksize = parseFloat(volume.size)/(1024.0*1024.0*1024.0) + ' GB';
                                items[idx].storagetype = volume.storagetype.replace(/\w\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();}) + ' (' + volume.type + ')';
                                if (volume.storage) {
                                    items[idx].storagepool = volume.storage;
                                }
                            });
                        }
                        args.response.success({
                            data: items
                        });
                    }
                });
            },
            browseBy: {
                filterKey: 'storageid',
                filterBy: 'id',
                resource: 'storagepool'
            },
            detailView: cloudStack.sections.storage.sections.volumes.listView.detailView
        }
    };


    // Storage Pool Metrics
    cloudStack.sections.metrics.storagepool = {
        title: 'label.metrics',
        listView: {
            id: 'primarystorages',
            fields: {
                name: {
                    label: 'label.metrics.name'
                },
                property: {
                    label: 'label.metrics.property',
                    collapsible: true,
                    columns: {
                        state: {
                            label: 'label.metrics.state',
                            converter: function (str) {
                                // For localization
                                return str;
                            },
                            indicator: {
                                'Up': 'on',
                                'Down': 'off',
                                'Removed': 'off',
                                'ErrorInMaintenance': 'off',
                                'PrepareForMaintenance': 'transition',
                                'CancelMaintenance': 'warning',
                                'Maintenance': 'warning',
                            },
                            compact: true
                        },
                        scope: {
                            label: 'label.metrics.scope'
                        },
                        type: {
                            label: 'label.metrics.disk.storagetype'
                        },
                    }
                },
                disk: {
                    label: 'label.metrics.disk',
                    collapsible: true,
                    columns: {
                        disksizeused: {
                            label: 'label.metrics.disk.used',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'storagenotificationthreshold',
                                disable: 'storagedisablethreshold'
                            }
                        },
                        disksizetotal: {
                            label: 'label.metrics.disk.total'
                        },
                        disksizeallocated: {
                            label: 'label.metrics.disk.allocated',
                            thresholdcolor: true,
                            thresholds: {
                                notification: 'storageallocatednotificationthreshold',
                                disable: 'storageallocateddisablethreshold'
                            }
                        },
                        disksizeunallocated: {
                            label: 'label.metrics.disk.unallocated'
                        }
                    }
                }
            },
            dataProvider: function(args) {
                var data = {};
                listViewDataProvider(args, data);
                if (args.context.metricsFilterData && args.context.metricsFilterData.key && args.context.metricsFilterData.value) {
                    data[args.context.metricsFilterData.key] = args.context.metricsFilterData.value;
                }
                $.ajax({
                    url: createURL('listStoragePools'),
                    data: data,
                    success: function(json) {
                        var items = [];
                        if (json && json.liststoragepoolsresponse && json.liststoragepoolsresponse.storagepool) {
                            items = json.liststoragepoolsresponse.storagepool;
                            $.each(items, function(idx, pool) {
                                items[idx].name = pool.name;
                                items[idx].state = pool.state;
                                items[idx].scope = pool.scope;
                                items[idx].type = pool.type;
                                items[idx].overprovisionfactor = parseFloat(pool.overprovisionfactor);
                                if (pool.disksizeused) {
                                    items[idx].disksizeused = (parseFloat(pool.disksizeused)/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
                                } else {
                                    items[idx].disksizeused = '--';
                                }
                                items[idx].disksizetotal = parseFloat(pool.disksizetotal);
                                items[idx].disksizeallocated = parseFloat(pool.disksizeallocated);
                                items[idx].disksizeunallocated = (items[idx].overprovisionfactor * items[idx].disksizetotal) - items[idx].disksizeallocated;

                                // Format presentation
                                items[idx].disksizetotal = (items[idx].disksizetotal/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB (x' + items[idx].overprovisionfactor + ')';
                                items[idx].disksizeallocated = (items[idx].disksizeallocated/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';
                                items[idx].disksizeunallocated = (items[idx].disksizeunallocated/(1024.0*1024.0*1024.0)).toFixed(2) + ' GB';

                                // Threshold color coding
                                items[idx].storagenotificationthreshold = 0.75 * parseFloat(items[idx].disksizetotal);
                                items[idx].storagedisablethreshold = 0.95 * parseFloat(items[idx].disksizetotal);
                                items[idx].storageallocatednotificationthreshold = 0.75 * parseFloat(items[idx].disksizetotal);
                                items[idx].storageallocateddisablethreshold = 0.95 * parseFloat(items[idx].disksizetotal);


                                var getThresholds = function(data, items, idx) {
                                    data.listAll = true;
                                    $.ajax({
                                        url: createURL('listConfigurations'),
                                        data: data,
                                        success: function(json) {
                                            if (json.listconfigurationsresponse && json.listconfigurationsresponse.configuration) {
                                                $.each(json.listconfigurationsresponse.configuration, function(i, config) {
                                                    switch (config.name) {
                                                        case 'cluster.storage.allocated.capacity.notificationthreshold':
                                                            items[idx].storageallocatednotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].disksizetotal);
                                                            break;
                                                        case 'cluster.storage.capacity.notificationthreshold':
                                                            items[idx].storagenotificationthreshold = parseFloat(config.value) * parseFloat(items[idx].disksizetotal);
                                                            break;
                                                        case 'pool.storage.allocated.capacity.disablethreshold':
                                                            items[idx].storageallocateddisablethreshold = parseFloat(config.value) * parseFloat(items[idx].disksizetotal);
                                                            break;
                                                        case 'pool.storage.capacity.disablethreshold':
                                                            items[idx].storagedisablethreshold = parseFloat(config.value) * parseFloat(items[idx].disksizetotal);
                                                            break;
                                                    }
                                                });
                                            }
                                        },
                                        async: false
                                    });
                                };
                                // Update global and cluster level thresholds
                                getThresholds({}, items, idx);
                                getThresholds({clusterid: pool.clusterid}, items, idx);
                            });
                        }
                        args.response.success({
                            data: items
                        });
                    }
                });
            },
            browseBy: {
                filterBy: 'storageid',
                resource: 'volumes'
            },
            detailView: cloudStack.sections.system.subsections['primary-storage'].listView.detailView
        }
    };

})(cloudStack);