﻿Veeam.SummaryBox = Ext.extend(Veeam.Box, {
    constructor: function(config){
        var config = Ext.applyIf( config, {
            cls: 'x-summary-box',
            listeners:{ render: this.renderHandler.createDelegate(this) }
        });
        Veeam.SummaryBox.superclass.constructor.apply(this,[config]);
    },

    destroy : function() {
        if ( this.linkEl ) this.linkEl.removeAllListeners();
        Veeam.SummaryBox.superclass.destroy.apply( this, arguments );
    },

    renderHandler: function() {
        var items = this.initialConfig.summaryItems;

        var itemsHtml = '';
        for ( var i = 0, len = items.length; i < len; i++ ) {
            itemsHtml += String.format('<tr class="dashboard-summary-row">' +
                    '<td class="dashboard-summary-label {0}"><div>{1}</div></td>' +
                    '<td class="dashboard-summary-cell"><div>{2}</div></td></tr>',
                    items[i].iconCls ? items[i].iconCls : '', items[i].label, items[i].value );
        };

        var ic = this.initialConfig;

        var html = '<table cellspacing="0" cellpadding="0"><tbody>' + itemsHtml + '</tbody></table>';
        this.body.insertHtml('beforeEnd',html);

        var el = this.body.select( 'td.dashboard-summary-cell' );
        for ( var i = 0, len = items.length; i < len; i++ ) {
            if ( !items[i].link ) continue;
            el.item(i).addClass('dashboard-summary-link-value');
            el.item(i).on('click', this.linkClickHandler, this, { link: items[i].link } );
        };

    },

    linkClickHandler : function( e, t, o ) {
        e.stopEvent();
        var token = Ext.apply( o.link, { replace: true });
        App.go( token );
    },

    destroy : function() {
        if ( this.linkEl ) { this.linkEl.removeAllListeners(); }
        Veeam.SummaryBox.superclass.destroy.call(this);
    }
});

Ext.reg( "vm.ui.summarybox", Veeam.SummaryBox );

/* Dashboard */

Veeam.DashboardPanel = Ext.extend( Ext.Panel, {
    constructor: function(config){
        
        var config = Ext.apply( config || {}, { 
            border:false, 
            header:false,
            footer:true, 
            cls:'dashboard-panel'
        });
    
        Veeam.DashboardPanel.superclass.constructor.apply(this, [config]);    
    },
    
    render: function() {
        Veeam.DashboardPanel.superclass.render.apply(this, arguments);
        this.body.addClass('dashboard-panel-body');
    },
    
    destroy: function() {
        if ( this.hdrButton ) this.hdrButton.destroy();
        Veeam.DashboardPanel.superclass.destroy.apply(this,arguments);
    }
});

Ext.reg('vm.ui.dashboardpanel', Veeam.DashboardPanel);



Veeam.Dashboard = function(config) {
     
    this.licenseStatus = config.licenseStatus || {};
    var items = [];
    // add boxes
    for ( var i = 0, len = config.boxItems.length; i < len; i++ )
        items.push( Ext.apply({ /*style:'margin-right:10px',*/ boxMinWidth: 180,  boxMaxWidth: 300, flex: 1, autoHeight: true }, config.boxItems[i]) );
    
    this.statusBox = new Veeam.Box({
        title:'Status',
        cls: 'x-summary-box',
        //width: 200,
        boxMinWidth: 180,
        boxMaxWidth: 300,
        autoHeight: true,
        flex: 1,
        //style: "margin-right: 10px;",
        listeners: { render:this.renderStatuses.createDelegate(this) }  
    });
    items.push( this.statusBox );

    this.btnRefresh = new Ext.Button({ 
        text:'Refresh', 
        cls: 'x-btn-outline',
        style:'height:auto',
        icon: 'img/refresh.gif', 
        handler: this.refreshHandler, 
        scope:this 
    });

    var pnTopTitle = 'Veeam Backup & Replication' + (this.licenseStatus.fail == 'NotInstalled' ? '' : ': ' + this.licenseStatus.licenseEdition + ' edition');
    if (this.licenseStatus.fail == 'NotEnoughLicenses'){
        var socksNum = parseInt(this.licenseStatus.exceededSocketsNum);
        var socksLimit = parseInt(this.licenseStatus.exceededSocketsLimit);
        pnTopTitle += String.format('<span class="warn"> | WARNING: License limit of {0} CPU sockets is exceeded by {1}. <a href="{2}" title="details">View details</a></span>',
            socksLimit,  socksNum, './Configuration.aspx?m=licensing');

    }

    if (this.licenseStatus.fail == 'ExpirationElapsed'){
        pnTopTitle += '<span class="warn"> | WARNING: License expired</span>';
    }
    if (this.licenseStatus.fail == 'EvaluationFinished'){
        pnTopTitle += '<span class="warn"> | WARNING: Trial license expired</span>';
    }

    if (this.licenseStatus.supportExpired === true)
    {
        pnTopTitle += '<span class="warn"> | <span>' + this.licenseStatus.supportExpiredMessage + '</span></span>';
    }


    var header = new Ext.Toolbar({
        items: [
            {
                xtype: 'box',
                html: pnTopTitle,
                cls: 'x-title'
            }, '->',
            this.btnRefresh
        ]
    })

    var container = new Ext.Container({
        layout: 'hbox',
        layoutConfig: {pack: 'start', align: 'top' },
        items: items,
        boxMinWidth: 720,
        boxMaxWidth: 1200,
        boxMinHeight: 230
    });

    this.pnTop = new Veeam.DashboardPanel({ 
        border:false,
        region:'north',
        tbar: header,
        boxMinHeight: 255,
        items: { xtype: 'container', items: container, layout: 'fit',  boxMinWidth: 720, boxMaxWidth: 1200}
    });



    var header2 = new Ext.Toolbar({
        items: {
            xtype: 'box',
            html: 'Backup Servers',
            cls: 'x-title'
        }});

    var percentChartPresent = !Ext.isEmpty( config.percentageChartData );
    this.pnBottom = new Veeam.DashboardPanel({
        tbar: header2,
        border:false,
        layout:'anchor',
        region:'center',
        id: 'dashdoard-panel-chart',
        boxMinWidth: 720,
        boxMinHeight: percentChartPresent ? 400 : 445,
        items:[
            Ext.apply({
                    autoEl: { tag: 'div' },
                    anchor: '100% -100'
                }, config.chart),
            {
                id: 'percentage-chart',
                xtype: 'box',
                anchor: '100%',
                autoEl: { tag : 'div' },
                height: 372,
                hidden: !percentChartPresent,
                listeners: { render: this.renderPercentChart, scope: this }
            }
        ]
    });
    

    config = Ext.applyIf({
        layout: 'border',
        ctCls: 'x-dashboard-container',
        autoScroll: true,
        border:false,
        items: [ this.pnTop , this.pnBottom ]
    }, config );
    
    Veeam.Dashboard.superclass.constructor.apply(this, [config]);
};

Ext.reg('vm.ui.dashboard', Veeam.Dashboard);

Ext.extend( Veeam.Dashboard, Ext.Container, {

    initComponent: function(){
        Veeam.Dashboard.superclass.initComponent.call(this);
        if (!Ext.isEmpty( this.initialConfig.percentageChartData))
            this.pnBottom.addListener('resize', this.resizeHandler, this);
    },

    renderStatuses : function() {
        var config = this.initialConfig;
        var html ='<table cellpadding="0" cellspacing="0"><tbody>';

        if (config.backups){
            html += String.format('<tr class="dashboard-summary-row"><td class="dashboard-summary-label">Backups</td>' +
                    '<td class="dashboard-summary-cell"><div class="x-icon-cell {0}">{1}</div></td></tr>', config.backups.iconCls, config.backups.html );
        }

        if ( config.backupServers ) {
            var serversHtml = config.backupServers.html;
            html += String.format('<tr class="dashboard-summary-row">' +
                    '<td class="dashboard-summary-label"><a href="#" >Backup servers</a></td>' +
                    '<td class="dashboard-summary-cell" ><div class="x-icon-cell {0}">{1}</div></td>' +
                    '</tr>', config.backupServers.iconCls, serversHtml );
        }

        html += String.format('<tr class="dashboard-summary-row">' +
                '<td class="dashboard-summary-label">Management server</td>' +
                '<td class="dashboard-summary-cell" ><div class="x-icon-cell {0}">{1}</div></td>' +
                '</tr>', config.mngServer.iconCls, config.mngServer.html );

        html += this.renderLicenseInfo(config.licenseStatus);
        html += '</tbody></table>';

        html = "<div>" + html + "</div>";
        this.statusBox.body.insertHtml('afterBegin', html);

        this.serversLink = this.statusBox.body.child('a');
        if ( this.serversLink )
            this.serversLink.on('click', this.openServersWindow, this );

        this.licenseLink = Ext.get("x-license-link");
        if (this.licenseLink){
            this.licenseLink.on('click', this.openLicenseStatus, this );
        }

      
    },
    renderLicenseInfo: function(config){
        /* license status */
        var statusCls = {
            error: 'icon-statuses-error',
            success: 'icon-statuses-success',
            warning: 'icon-statuses-warning'
        };
        
        var installedButError = !!config.fail.match('^(NotEnoughLicenses|ExpirationElapsed|EvaluationFinished)$');
        var html = String.format('<tr class="dashboard-summary-row">' +
                '<td class="dashboard-summary-label">'
                + (config.validationStatus  != 'success' ?
                    '<a href="#" id="x-license-link">License</a>' :
                    'License') +
                '</td>' +
                '<td class="dashboard-summary-cell"><div class="x-icon-cell  {0}">{1}</div></td>' +
                '</tr>', statusCls[ config.validationStatus ], config.validationStatus  != 'success' ? "Error" : "OK" );
        // Store result
        this.licenseStatus = config;
        return html;
    },

    openServersWindow : function() {
        var w = new Veeam.OfflineServersWindow({
            title:'Backup servers',
            modal:true,
            width: 600,
            height:350,
            serverData : this.initialConfig.backupServers.serverData
        });
        w.show();
    },

    openLicenseStatus: function(){
        Ext.Msg.show({
           title:'License status',
           msg: this.licenseStatus.validationStatusComment,
           buttons: Ext.Msg.OK,
           icon: (this.licenseStatus.validationStatus == 'error') ? Ext.MessageBox.ERROR  : Ext.MessageBox.WARNING
        });
    },

    refreshHandler : function() {
        App.registerActivity();
        var c = Veeam.ContainerPanel.containers[ this.initialConfig.currentContainerId ];
        c.activateContent({ 
            xtype:'vm.ui.metadataloader', 
            reload: true,
            query: this.initialConfig.reportQuery }, true);
    },

    renderPercentChart: function(){

        var chartConfig = Ext.apply({}, this.initialConfig.percentageChartData, {
            chart: {
               renderTo: 'percentage-chart',
               defaultSeriesType: 'bar',
               showAxes: true,
               height: 100,
               marginLeft: 30
            },
            title: {
               style: { color: '#333333', fontSize: '12px', fontFamily: 'Tahoma, Geneva, sans-serif' },
               verticalAlign: 'bottom',
               align: 'left',
               x: 30,
               y: 8,
               margin: 10,
               text: 'Source data distribution across backup servers'
            },
            xAxis: { labels: { enabled: false }, lineWidth: 0 },
            yAxis: {
               min: 0,
               lineWidth: 0,
               gridLineWidth: 0,
               minorGridLineWidth: 0,
               labels: { enabled: false },
               title: {
                  text: ''
               }
            },
            legend: {
               enabled: false,
               reversed: true
            },
            tooltip: {
               formatter: function() {
                  return "<b>" + this.series.name + "</b>: "+ this.y + '%';
               }
            },
            plotOptions: {
               series: {
                  stacking: 'normal'
               }
            },
            credits: {
                 enabled: false
            }
        });
        
        if (chartConfig.series && chartConfig.series.length){
            for (var i =0, l = chartConfig.series.length; i < l; i++){
                var dataSet = chartConfig.series[i];
                dataSet['color'] = App.getChartHelper().getColorForSever( dataSet.name);
            }
        }

        this.percentageChart = new Highcharts.Chart(chartConfig);
        this.syncSize();


    },
    
    destroy: function() {
        if ( this.serversLink ) this.serversLink.removeAllListeners();
        if (this.pnBottom && this.pnBottom.removeAllListeners)  this.pnBottom.removeAllListeners();
        Veeam.Dashboard.superclass.destroy.call(this);
    },

    resizeHandler: function(pn, adjWidth, adjHeight, width, height){
        var chart  = Ext.fly('percentage-chart');
        if (chart) {
            var w = adjWidth ? adjWidth : width ? width : chart.getWidth();
            var h = chart.getHeight();
            if (this.percentageChart)
                this.percentageChart.setSize(w, h, false);
        }

    },
    activateContent: function(){
        this.pnTop.syncSize();
    }
});


//
// OfflineServersWindow
//
Veeam.OfflineServersWindow = function(config) {
    this.store = new Ext.data.JsonStore({ 
        root: 'items',
        totalProperty: 'totalCount',
        sortInfo:{field:'server', direction:'ASC'},
        remoteSort:false,
        fields:['server', 'status', 'css', 'info'], 
        data: config.serverData || { items:[], totalCount:0 }
    });
    
    var render = function( value, meta, record ) {
        meta.css = record.data.css + " icon-cell";
        return value;
    };

    var renderinfo = function( value, meta, record ) {
        meta.attr += ' ext:qtip="'  + value.replace('"',"'") + '"';
        return value;
    };
    
    this.grid = new Ext.grid.GridPanel({
        enableColumnMove: false, enableColumnHide: false, enableHdMenu: false,
        store: this.store,
        disableSelection:true,
        trackMouseOver: false,
        columns: [{
            header: 'Server', dataIndex:'server', width:120, sortable:true 
        },{ header: 'Status', dataIndex:'status', width:80,  sortable:true, renderer : render.createDelegate(this)
        },{ header: 'Info', dataIndex:'info', id: 'wrap-text', width:200, sortable:false, renderer : renderinfo.createDelegate(this)
        }],
        viewConfig: {
            forceFit:true,
            deferEmptyText: false,
            emptyText: 'No backup servers added. To add, go to Configuration > Backup Servers'
        }
    });
    
    config = Ext.applyIf({
        items:[this.grid],
        layout:'fit',
        buttons:[{text:'Close', handler: this.close, scope:this}],
        buttonAlign:'center'
    }, config);
    Veeam.OfflineServersWindow.superclass.constructor.apply(this, [config] );
};

Ext.extend( Veeam.OfflineServersWindow, Veeam.Window, {
});

Veeam.ChartHelper = function() {
    var _counter = 0,
        _servers = {},
        _colors = [
            '#4572A7', '#AA4643', '#89A54E', '#80699B', '#3D96AE', '#DB843D', '#92A8CD', '#A47D7C', '#B5CA92',
            '#000080', '#800080', '#808000', '#800000', '#000000', '#FFFF00', '#00FF00', '#00FFFF', '#008080',
            '#D2691E', '#2E8B57', '#DC143C', '#FFA500', '#4B0082', '#191970', '#696969', '#9400D3', '#B22222',
            '#C71585', '#FFD700', '#7B68EE'
        ];

    _servers = Ext.state.Manager.get('chartColors', {});
    for (var key in _servers){
        if (_servers.hasOwnProperty(key))
            _counter++
    }
    return {
        getColorForSever: function(serverName){
            var color = _servers[ serverName ]
            if (color)
                return color;

            if (_counter > _colors.length )
                _counter = 0;

            color = _colors[ _counter ];
            if (color){
                _servers[ serverName ] = color;
                _counter++;
                Ext.state.Manager.set( 'chartColors', _servers);
                Ext.state.Manager.getProvider().update();
            }
            return color;
        },

        clearColors: function(){
             Ext.state.Manager.set( 'chartColors', {});
             Ext.state.Manager.getProvider().update();
        }
    }
};




