/**
 * Project   : AMDA-NG
 * Name      : PlotTab.js
 * @class   amdaPlotComp.PlotTab
 * @extends Ext.form.Panel
 * @brief   Tab content to define a plot
 * @author  Benjamin Renard
 * @version $Id: PlotTab.js benjamin $
 */

Ext.define('amdaPlotComp.PlotTabContent', {
    extend: 'Ext.form.Panel',

    requires: [
        'amdaUI.TimeSelectorUI',
        'amdaUI.DescriptionField',
        'amdaPlotComp.PlotTree',
        'amdaPlotComp.PlotOutputForm',
        'amdaPlotComp.PlotElementPanel'
    ],
	
    //Link to the Plot Node
    plotNode: null,

    //Save initial request data to have the possibility to reject all modifications
    initialObjectData: null,

    timeSelector: null,
    plotTree: null,
    plotElement: null,
    plotOutput: null,

    tabIndex: 0,
    plotTabPanel: null,
    
    constructor: function(config) {
		this.init(config);	    
		this.callParent(arguments);
    },

    setTime : function(startDate, stopDate) {
        this.timeSelector.intervalSel.setInterval(startDate, stopDate);
        this.timeSelector.setActiveTimeSource(amdaModel.AmdaTimeObject.inputTimeSrc[1]);
        
    },
    getTimeSelector: function(){
        return this.timeSelector;
    },
	
    updateTimeObject : function() {
        var timeSource = this.timeSelector.getActiveTimeSource();
        var tabForm = this.getForm();
        tabForm.updateRecord(this.plotNode.get('object'));
        this.plotNode.get('object').set('timesrc', timeSource);
        if (timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0])
            this.plotNode.get('object').set('timeTables',this.timeSelector.TTGrid.getStore().data.items);
    },

    doPlot : function() {
        this.plotNode.get('object').set('tab-index', this.tabIndex);
        this.plotNode.get('object').set('tab-title', this.getPlotTitle());
        this.plotNode.get('object').set('multi-selected', false);
        var plotModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.plot.id);
        plotModule.refreshMultiPlot();
        this.plotNode.execute();
    },

    getPlotTitle: function() {
       return (this.plotNode.get('text') != '') ? this.plotNode.get('text') : 'Plot '+(this.tabIndex + 1); 
    },

    savePlot : function() {
        var me = this;

        var object = this.plotNode.get('object');
        if (!object)
            return;

        if ((object.get('id') != '') && (this.plotNode.get('text') == object.get('name'))) {
            //update existing request
            this.updateTimeObject();
            this.plotNode.update({plot: true, callback: function() {
                me.setPlotNode(me.plotNode); //to update initial request data
                me.plotTabPanel.updatePlotTabs();
            }});
            return;
        }

        //save new request
        this.plotNode.isValidName(object.get('name'), function (res) {
            if (!res) {
                myDesktopApp.errorMsg('Error during object validation');
                return;
            }
            if (!res.valid) {
                if (res.error) {
                    if (res.error.search('subtree') != -1) {
                        Ext.Msg.show( { title : 'Warning',
                            msg: res.error + '<br/>Do you want to overwrite it?',
                            width: 300,
                            buttons: Ext.Msg.OKCANCEL,
                            icon: Ext.Msg.WARNING,
                            fn :  function(btn) {
                                if (btn == 'cancel') return;
                                me.saveProcess(true);
                            },
                            scope : me
                        });
                    }
                    else {
                        myDesktopApp.errorMsg(res.error);
                    }
                }
                else {
                    myDesktopApp.errorMsg('Invalid object name');
                }
                return;
            }
            me.saveProcess(false);
        });
    },

    saveProcess : function(overwriteExistingNode) {
        var plotModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.plot.id);
        if (!plotModule)
            return;

        var me = this;
        if (overwriteExistingNode) {
            this.updateTimeObject();
            amdaModel.InteractiveNode.preloadNodes(this.plotNode.getRootNode(), function () {
                var targetPlotNode = me.plotNode.getRootNode().findChild('text', me.plotNode.get('object').get('name'), true);
                if (!targetPlotNode) {
                    myDesktopApp.errorMsg('Cannot retrieve request node');
                    return;
                }
                targetPlotNode = plotModule.linkedNode.get('object').overwritePlot(me.plotNode, targetPlotNode);
                if (targetPlotNode) {
                    //Reject modifications in old plot node
                    me.resetModif();
                    targetPlotNode.update({plot: true, callback: function() {
                        me.setPlotNode(targetPlotNode);
                        me.plotTabPanel.updatePlotTabs();
                        me.updateUI();
			plotModule.updatePlotResultTitle(me.tabIndex, targetPlotNode.get('text'));
                    }});
                }
            });
        }
        else {
            if (this.plotNode.get('object').get('id') != '') {
                //Duplicate request
                var newPlotNode = this.plotTabPanel.duplicatePlotNode(this.plotNode);
                if (newPlotNode) {
                    //Reject modifications in old plot node
                    this.resetModif();
                    //Set new plot node to the current tab
                    this.setPlotNode(newPlotNode);
                }
            }
            this.updateTimeObject();
            this.plotNode.create({plot: true, callback: function() {
                me.plotNode.commit();
                me.setPlotNode(me.plotNode); //to update initial request data
                me.plotTabPanel.updatePlotTabs();
                me.updateUI();
		plotModule.updatePlotResultTitle(me.tabIndex, me.plotNode.get('text'));
            }});
        }
    },

    resetModif : function() {
        this.plotNode.set('object', Ext.create('amdaPlotObj.PlotRequestObject', this.initialObjectData));
    },

    getDataProcess : function() {
	var plotModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.plot.id);
	plotModule.editInDownloadModule(this.plotNode);
    },

    isValidRequest : function(acceptEmptyTTList = true) {
        this.updateTimeObject();
        if (!this.timeSelector.isValid(acceptEmptyTTList)) {
            myDesktopApp.errorMsg('Error in Time definition');
            return false;
        }
        return true;
    },

    updateUI : function() {
        this.plotOutput.setObject(this.plotNode.get('object'));
        var descField = this.descriptionCase.items.items[0];
        descField.setValue(this.plotNode.get('object').get('description'));
        this.timeSelector.intervalSel.setInterval(this.plotNode.get('object').get('startDate'), this.plotNode.get('object').get('stopDate'));
	this.timeSelector.intervalSel.updateStop();
        this.timeSelector.setTTTab(this.plotNode.get('object').get('timeTables'));
        this.timeSelector.timeSrc.setActiveTab(this.plotNode.get('object').get('timesrc'));
        this.treePlot.buildTree(this.plotNode.get('object'));
    },

    setPlotNode : function(plotNode) {
        this.initialObjectData = plotNode.get('object').getJsonValues();
        this.plotNode = plotNode;
    },

    enableTimeSelection : function(enable) {
        this.timeSelector.setDisabled(!enable);
    },

    init : function(config) {
        this.setPlotNode(config.plotNode);
        this.tabIndex = config.tabIndex;
        this.plotTabPanel = config.plotTabPanel;

        this.timeSelector = new amdaUI.TimeSelectorUI( { id: Ext.id()/*'plotTimeSelectorTab' + this.plotNode.id*/, border : false, flex: 6, collapsible: true, collapseDirection : 'bottom'} );
        this.plotElement = new amdaPlotComp.PlotElementPanel({flex: 12});
        this.treePlot = new amdaPlotComp.PlotTree({flex: 11, plotElementPanel: this.plotElement});
        this.plotOutput = new amdaPlotComp.PlotOutputForm({flex: 8, collapseDirection : 'bottom', collapsible : true });
        this.descriptionCase = new Ext.form.FieldSet({
            title:'Request description',
            collapsible:true,
            collapsed:true,
            flex:3,
            bodyStyle: {background: '#dfe8f6',padding: '1', },
            border:false, 
            layout:'fit',
            items:[{ xtype: 'descriptionfield', name: 'description', height:50, 
            emptyText:'Description', fieldLabel: ''}]
        });

        var treePanel = new Ext.form.Panel({
            flex: 1,
            layout: {
                type: 'vbox',
                pack: 'start',
                align: 'stretch'
            },
            bodyStyle: { background : '#dfe8f6' },
            defaults: {
                border: false
            },
            items: [
                this.treePlot,
                this.timeSelector
            ]
        });

        var optionsPanel = new Ext.form.Panel({
            flex: 1,
            layout: {
                type: 'vbox',
                pack: 'start',
                align: 'stretch'
            },
            bodyStyle: { background : '#dfe8f6' },
            defaults: {
                border: false
            },
            items: [
                this.plotElement,
                this.plotOutput,
                this.descriptionCase
            ]
        });

		
        var myConf = {
            bodyStyle: { background : '#dfe8f6' },
            border : false,
            defaults: {
                border: false
            },
            layout: {
                type: 'hbox',
                pack: 'start',
                align: 'stretch'
            },
            items: [
                treePanel,
                optionsPanel
            ],
            listeners: {
                afterrender: function(comp, eOpts) {
                    this.updateUI();
                },
                beforedestroy: function(comp, eOpts) {
                    this.resetModif();
                },
                scope: this
            }
        };

        Ext.apply (this , Ext.apply (arguments, myConf));
		
		
    }
});