/**
 * Project   : AMDA-NG
 * Name      : DownloadUI.js
 * @class 	 amdaUI.DownloadUI
 * @extends  Ext.container.Container 
 * @brief    Download Module UI definition (View)
 * @author 	 Myriam
 * @version $Id: DownloadUI.js 2622 2014-11-07 14:50:09Z elena $  
 */
 
 
Ext.define('amdaUI.DownloadUI', {
	extend: 'Ext.container.Container',
	alias: 'widget.panelDownload',

	requires: [
		'amdaUI.TimeSelectorUI',
		'amdaUI.SearchParamEditorPlugin'
	],   
	
	//Old kernel time formats
	//timeformatData    : [['Y-m-dTH:i:s', 'YYYY-MM-DDThh:mm:ss'], ['Y m d H i s', 'YYYY MM DD hh mm ss'], ['d m Y H i s', 'DD MM YYYY hh mm ss'], ['Y z H i s', 'YYYY DDD hh mm ss']],
	//New kernel time formats
	timeformatData    : [['Y-m-dTH:i:s', 'YYYY-MM-DDThh:mm:ss'], ['DD Time', 'DD Time'], ['Timestamp', 'Timestamp']],
	fileformatData    : [['ASCII', 'ASCII'],['vot', 'VOTable'],['cdf', 'CDF'],['json', 'JSON']],
	fileformatTTData  : [['text', 'plain text'], ['vot','VOTable']],
	filecompressData  : [['zip', 'zip'], ['tar+gzip', 'tar+gzip']],
	filestructureData : [['0','All In One File'], ['1','One File Per Time Interval'], ['2','One File Per Param/Interval']],

	constructor: function(config) {	  
		this.init(config);
		this.callParent(arguments);		
	    // load object into view		 
	 	if (this.object) this.loadObject();	        
	},

	addTT : function(newTTName,newTTid)
        {		 
		var tabPanel = this.formPanel.down();
		var downloadSrc = tabPanel.items.indexOf(tabPanel.getActiveTab());
		 
		if (downloadSrc === 0) {
                    this.timeSelector.addTT(newTTName,newTTid);
		}
		else {
                    // search for an existing record in store with this unique name
                    var existingIndex = this.TTGrid.store.findExact( 'name', newTTName);
                    // if no corresponding TT found
                    if (existingIndex == -1){
                        // adding the time table to the TTGrid of TT download 
                        var r = Ext.create('amdaModel.TTobject', { id: newTTid, name: newTTName });
                        this.TTGrid.store.insert(this.TTGrid.store.getCount(),r);   
                    }        
		}
	},

	addTTs : function(TTarray) {
	// set TTTab	    
	this.timeSelector.setTTTab(TTarray);
	},
	
	// Add TT in download TT module
	addTTdownload : function(newTTName,newTTid){
		var tabPanel = this.formPanel.down();
		tabPanel.setActiveTab(1);
		this.addTT(newTTName,newTTid);
		
	},	
        
        /**
         * Set Start-Stop from parameter info (Local & MyData)
         */ 
        setTimeFromData : function(obj) {
                                                                  
            var dateStart = new Date(obj.start.replace(/[T|Z]/g,' ').replace(/\-/g,'\/')); 
            var dateStop = new Date(obj.stop.replace(/[T|Z]/g,' ').replace(/\-/g,'\/')); 
            
            this.down('form').getForm().setValues({ startDate : dateStart, stopDate : dateStop });
            this.timeSelector.intervalSel.updateDuration();
        },
        
        addParam : function(newParamName,isLeaf) 
        {
            // search for an existing record in store with this unique name
            var existingIndex = this.paramGrid.store.findExact('name', newParamName);
            // if no corresponding parameter found
            if (existingIndex == -1){
                // adding the parameter to the  paramGrid
                var r = Ext.create('amdaModel.AmdaObject', {name: newParamName });
                var pos = newParamName.indexOf('ws_',0) == -1 ? 0 :this.paramGrid.store.getCount();
                this.paramGrid.store.insert(pos,r); 
                this.paramGrid.getView().refresh();                
            }        
        },

        addParams: function(arrayParams) 
        {
            var arrayRec = new Array();
            var index = 1;		 
            if (arrayParams)
            {
                index = 0;            
                Ext.Array.each(arrayParams,function(item){		
                        if (Ext.isObject(item)) {
                                // for Parameter Name in Download Module
                                var r = Ext.create('amdaModel.AmdaObject', { name: item.get('name') });
                        }
                        else {
                                // for Download By Request in Operations menu
                                var r = Ext.create('amdaModel.AmdaObject', { name: item });
                        }
                    arrayRec.push(r);
                });
            } 	     
            this.paramGrid.getStore().loadData(arrayRec);
        },
	
	// parameter name -> alias
	updateConstruct : function(oldval,newval) {
		var index = this.paramGrid.store.findExact('name', oldval);
		if (index != -1) {
			this.paramGrid.getStore().getAt(index).set('name',newval);
			this.paramGrid.getStore().getAt(index).set('text',newval);	
    	}
	},
	
	setObject : function(obj) {
		this.object = obj;  
		this.loadObject();
	},

	/**
	 * update this.object from form
	 */
        updateObject : function()
        {    
            // get the basic form
            var tabPanel = this.formPanel.down();
            var downloadSrc = tabPanel.items.indexOf(tabPanel.getActiveTab());
            var basicForm = this.formPanel.getForm();
            var updateStatus = true;
            var values = basicForm.getValues();
            
            // data download
            if (downloadSrc === 0) 
            {            
                var timeformat =  basicForm.findField('timeformat').getRawValue();         
                var timeSource = this.timeSelector.getActiveTimeSource();     
                var structure = values.filestructure;
                var sampling = values.sampling ? values.sampling : 600;
		var refparamSampling = values.refparamsampling == 'on';
                var fileprefix = values.fileprefix ? values.fileprefix : '';
                var fileformat = values.fileformat;
                var compression = values.compression;

          	  var fieldsWithoutName = basicForm.getFields().items;
        	  Ext.Array.each(fieldsWithoutName, function(item, index,allItems){		     
        		   if (!item.isValid()) {
            		  if ((timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0]) &&
               			   ((item.name == 'startDate') || (item.name == 'stopDate') || (item.name == 'duration'))) {
               			  	updateStatus = true;
               		  }
               		  else {
               			// set update isn't allowed
                             updateStatus = false;
                             return false;
               		  }       
        		   }
        	  }, this);
        	  
                if (timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0] // timeSource  'TimeTable'
                        && this.timeSelector.TTGrid.getStore().count() == 0) {
                    myDesktopApp.warningMsg('You\'ve chosen Time Selection `by TimeTable` but no timeTable was added!'
                            +'<br>You must add one or choose Time Selection `by Interval`'); 
                    updateStatus = false;    
                }
                                
                if (updateStatus) 
                {
                    /// real object update
                    // update TimeTable object with the content of form
                    basicForm.updateRecord(this.object);
                    this.object.set('timesrc', timeSource);
                    // set valid intervals into TimeTable object
                    if (timeSource === amdaModel.AmdaTimeObject.inputTimeSrc[0])
                            this.object.set('timeTables',this.timeSelector.TTGrid.getStore().data.items);
                    // set parameters			    
                    this.object.set('list',this.paramGrid.getStore().data.items);
                    this.object.set('structure', structure);
		    this.object.set('refparamSampling', refparamSampling);
                    this.object.set('sampling', sampling);
                    this.object.set('fileprefix',fileprefix);
                    this.object.set('timeformat',timeformat);
                    this.object.set('fileformat',fileformat);
                    this.object.set('compression',compression);
                }    
            }
            //TT download
            else 
            {
                var timeformat =  values.timeformatTT;
                var compression = values.compressionTT;
                var fileformat = values.fileformatTT;
                this.object.set('timeTables',this.TTGrid.getStore().data.items);
                this.object.set('timeformatTT',timeformat);
                this.object.set('fileformatTT',fileformat);
                this.object.set('compressionTT',compression);
            }
            
            this.object.set('downloadSrc',downloadSrc);
            // return the update status
            return updateStatus;	    
	},

	/**
	 * load this.object into form
	 */
	loadObject : function(){	
	
	if (!this.object.get('timeformat'))
		 this.object.set('timeformat', this.timeformatData[0][0]);
	
	if (!this.object.get('timeformatTT'))
		 this.object.set('timeformatTT', this.timeformatData[0][0]);
	
	if (!this.object.get('fileformat'))
		this.object.set('fileformat', this.fileformatData[0][0]);
	
	if (!this.object.get('fileformatTT'))
		  this.object.set('fileformatTT', this.fileformatTTData[0][0]);
	
	if (!this.object.get('compression'))
		    this.object.set('compression', this.filecompressData[1][0]);

	if (!this.object.get('compressionTT'))
	    this.object.set('compressionTT', this.filecompressData[1][0]);
	
	// load object into form	
	this.formPanel.getForm().loadRecord(this.object);
        // set object's TTs into the timeselector
	this.addTTs(this.object.get('timeTables'));	 
	// set parameters 	
	this.addParams(this.object.get('list'));	     
	},

	/**
	 * download method called by 'Download' button to launch the download process
	 */
	doDownload : function(){	 
		var downloadModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
		if (downloadModule)
			downloadModule.linkedNode.execute();	
	   // fire execution  
	  //  this.object.fireEvent('execute',this.object.dirty);
	},
	 
	
	removeItem: function(grid, cell, cellIndex, record, row, recordIndex, e){
		if (cellIndex == 2)
			grid.getStore().remove(record);
	},
	 
	onFileStructureChange : function(combo, newValue, oldValue){
		if (!this.formPanel)
			return;

		var refParamCheck = this.formPanel.getForm().findField('refparamsampling');
		var samplingField = this.formPanel.getForm().findField('sampling');

		if (samplingField &&  newValue !== oldValue) {
		     refParamCheck.setDisabled(newValue == 2);
		     samplingField.setDisabled((newValue == 2) || refParamCheck.getValue());
		}
	},

	onRefParamSamplingChange : function(check, newValue, oldValue){
		if (!this.formPanel)
                        return;

		var samplingField = this.formPanel.getForm().findField('sampling');
		var structureCombo = this.formPanel.getForm().findField('filestructure');

		if (samplingField &&  newValue !== oldValue)
			samplingField.setDisabled((structureCombo.getValue() == 2) || check.getValue());
	},
	
	/**
	 * Check if changes were made before closing window 
	 * @return false
	 */	
	fclose : function() {
		return false;
	},
	
	init : function (config){
		
		this.timeSelector = new amdaUI.TimeSelectorUI({id: 'downloadTimeSelector',flex: 1});
		
		this.paramGrid = Ext.create('Ext.grid.Panel', {
		    flex: 2,
		    store : Ext.create('Ext.data.Store', { model: 'amdaModel.AmdaObject'} ),  
		    columns: [ 
			{ xtype: 'rownumberer', width: 20 },
			{ header: "Parameter Name", dataIndex: 'name', flex:1, sortable: false, menuDisabled : true },
			{ 
			    menuDisabled : true, width: 30, renderer: function(){
				return'<div class="icon-remover" style="width: 15px; height: 15px;"></div>';
			    }
			}
		    ],
			//TODO - BRE - Wait the fix for drag&drop issue
		    listeners :
			{
			  render : function(o,op)
			  {
			    var me = this;
			    var el = me.body.dom;
			    var dropTarget = Ext.create('Ext.dd.DropTarget', el, {
			        ddGroup: 'explorerTree',
			        notifyEnter : function(ddSource, e, data) 
			        { },
			        notifyOver  : function(ddSource, e, data)
			        {                                    
                                    if (data.records[0].data.nodeType == 'localParam' && data.records[0].get('notyet')) {
                                        this.valid = false;
                                        return this.dropNotAllowed;   
                                    }	
                                    if (((data.records[0].data.nodeType == 'localParam')   ||
                                                (data.records[0].data.nodeType == 'remoteParam') || 
                                                (data.records[0].data.nodeType == 'remoteSimuParam') ||
                                                (data.records[0].data.nodeType == 'derivedParam') || 
                                                (data.records[0].data.nodeType == 'myDataParam') ||
                                                (data.records[0].data.nodeType == 'alias'))&&
                                                (data.records[0].isLeaf() || data.records[0].data.isParameter) &&
                                                !data.records[0].data.disable)
                                    {
                                        this.valid = true;
                                        return this.dropAllowed;
                                    }
                                    
                                    this.valid = false;
                                    return this.dropNotAllowed;
			        },
			        notifyDrop  : function(ddSource, e, data)
			        {
			          if (!this.valid)
			            return false;
                                    var nameToSent;
                                    switch (data.records[0].data.nodeType)
                                    {
                                        case 'localParam' :
                                        case 'remoteParam':
                                        case 'remoteSimuParam':                                           
                                            nameToSent = data.records[0].get('id');
                                            if (data.records[0].get('alias')!= "" )
                                            var nameToSent = "#"+data.records[0].get('alias');
                                            break;
                                        case 'alias' :
                                            nameToSent = "#"+data.records[0].get('text');
                                            break;
                                        case 'derivedParam' :
                                            nameToSent = "ws_"+data.records[0].get('text');
                                            break;
                                        case 'myDataParam' :
                                            nameToSent = "wsd_"+data.records[0].get('text');
                                            break;
                                        default :
                                            return false;
                                    }
                                    var downModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
                                    if (downModule)
                                    {
                                    	if (data.records[0].get('needsArgs') && !data.records[0].get('isSpectra')) { 				    
                                    		downModule.getUiContent().fireEvent('openParamEditor',nameToSent);
                                    	}
                                    	else {
                                    		downModule.addParam(nameToSent,true);	
                                    	}
                                    }
			          return true;
			        }
			    });
			  }
			}
			
		});      
						
		this.paramGrid.on('cellclick', this.removeItem, this);

		this.TTGrid = Ext.create('Ext.grid.Panel', {
		    flex: 2,
		    store : Ext.create('Ext.data.Store', {model: 'amdaModel.TTobject'}),  
		    columns: [ 
			{ xtype: 'rownumberer', width: 20 },
			{ header: "Time Table Name", dataIndex: 'name', flex:1, sortable: false, menuDisabled: true},
			{ 
			    menuDisabled : true, width: 30, renderer: function(){
				return '<div class="icon-remover" style="width: 15px; height: 15px;"></div>';
			    }
			}
		    ],
	    listeners :
		{
		  render : function(o,op)
		  {
		    var me = this;
		    var el = me.body.dom;
		    var dropTarget = Ext.create('Ext.dd.DropTarget', el, {
		        ddGroup: 'explorerTree',
		        notifyEnter : function(ddSource, e, data) 
		        {
		    	  
		        },
		        notifyOver  : function(ddSource, e, data)
		        {
		        	if ((data.records[0].get('nodeType') == 'timeTable' || data.records[0].get('nodeType') == 'sharedtimeTable') && (data.records[0].get('leaf')))
		        	{
		        	  this.valid = true;
		        	  return this.dropAllowed;
		        	}
		        	this.valid = false;
		        	return this.dropNotAllowed;
		        },
		        notifyDrop  : function(ddSource, e, data)
		        {
		          if (!this.valid)
		            return false;
		          var downModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
		          if (downModule)
		        	  downModule.getUiContent().addTTdownload(data.records[0].get('text'),data.records[0].get('id'));
		          return true;
		        }
		    });
		  }
		}
		});
		this.TTGrid.on('cellclick', this.removeItem, this);
						
		this.paramPanel = { 		 
		      xtype: 'container',	  
		      title: 'Get Data',		   
		      layout: {
			  type: 'hbox',
			  align : 'stretch',
			  defaultMargins: {top: 10, left:10, bottom: 5, right:10}
		      },
		      items: [		     
			  {
			     xtype: 'container',
			     flex: 2,
			     layout: {
			 	type: 'vbox',
			 	align : 'stretch'
			      },
			     items: [ 				
				{
				  xtype: 'textfield',				 				 
				  fieldLabel: 'Request Name',
				  disabled: true,
				  name : 'name'	 
				}, 
				{
				  xtype: 'splitter',
				  flex: 0.05 
				},  	 			 				 			 	      
			 	this.paramGrid
			      ]  
			   },			 
			  {                 		   
			    xtype: 'container',
			    flex: 2,
			    defaults : {
			      xtype : 'combo',
			      labelWidth: 90,
			      queryMode: 'local',
			      editable: false
			    },
			    layout: {
				type: 'vbox',
				align: 'stretch'
			    },
			    items: [				
				{				    				  
				  fieldLabel: 'Time Format',				  
				  name: 'timeformat',				   
				  store: this.timeformatData,
				  value: this.timeformatData[0]					     
				},
				{				    
				    fieldLabel: 'File Structure',
				    name: 'filestructure',
				    store: this.filestructureData,
				    value: this.filestructureData[2],
				    listeners : {
				      change  : { fn : this.onFileStructureChange },
				      scope: this
				    } 
				},
				{
				    xtype: 'checkbox', boxLabel: 'Use first param. as reference for sampling', 		
				    boxLabelAlign: 'before',
				    name: 'refparamsampling', checked: false, disabled: true,
				    listeners : {
				      change : { fn : this.onRefParamSamplingChange },
				      scope : this
				    }
				},  		 					    						
				{
				    xtype: 'numberfield', name: 'sampling',
				    fieldLabel: 'Sampling Time', value: 600,
				    hideTrigger: true,  editable: true,
				    disabled: true
				},
				{
				    xtype: 'textfield', name: 'fileprefix',
				    fieldLabel: 'File Prefix',				    
				    disabled: false,  editable: true
				},
				{				     
				      fieldLabel: 'File Format',
				      name: 'fileformat',				    
				      store: this.fileformatData, 
				      value: this.fileformatData[0]                  	        	        	 
				},				
				{
				      fieldLabel: 'Compression', 
				      name: 'compression',
				      store: this.filecompressData, 
				      value: this.filecompressData[0]
				},
				this.timeSelector
                      ]
                   } 
                ]};
 
		     this.ttPanel =
		     {  
			  xtype: 'container',	        
			  title: 'Get Time Table',			 
			  layout: {
			      type: 'hbox',
			      align : 'stretch',
			      defaultMargins: {top: 10, left:10, bottom: 5, right:10}
			  },
			  items: [ 			 									 			 				 			 	      
			 	this.TTGrid,			         
			  {                 		   
			    xtype: 'container',
			    flex: 2,
			    defaults : {
			      xtype : 'combo',
			      labelWidth: 90,
			      queryMode: 'local',
			      editable: false			      
			    },
			    layout: {
				type: 'vbox',
				align : 'stretch'
			    },
			    items: [			       
				{				    				  
				  fieldLabel:'Time Format',				  
				  name:'timeformatTT',				   
				  store: this.timeformatData,
				  value: this.timeformatData[0]					     
                   		 }, 
				{				     
				    fieldLabel: 'File Format ',
				    name: 'fileformatTT',				    
				    store: this.fileformatTTData, 
				    value: this.fileformatTTData[0]                  	        	        	 
				},				
				{
				    fieldLabel: 'Compression ', 
				    name: 'compressionTT',
				    store: this.filecompressData, 
				    value: this.filecompressData[0]
				}	          	        	           
			    ]
                         }
	             ]
			 } ;       
 
		this.formPanel = new Ext.form.Panel({
		    layout: 'fit',
		    region: 'center',
		    bodyStyle: { background : '#dfe8f6' },  
		    buttonAlign: 'left',
		    trackResetOnLoad: true,  //reset to the last loaded record
		    defaults: {
			border: false
		    },
		    items: [  			   
			 {
			   xtype: 'tabpanel',
			   activeTab : 0,
			   bodyStyle: { background : '#dfe8f6' },
			   items: [
			       this.paramPanel,
			       this.ttPanel			      
			   ]
			 }
		      ],
		    fbar: [
			  {
			    text: 'Download',
			    scope : this,
			    handler: function(button){
			    // if the return is true (object had been updated)
			      if(this.updateObject()){
			      // launch the search process 			        
				this.doDownload();				   				
			      }
			    } 
			  },
			  {
                            text: 'Reset',
			    scope : this,
			    handler: function(){
				  this.formPanel.getForm().reset();	
				  
				  var tabPanel = this.formPanel.down();
				  var downloadSrc = tabPanel.items.indexOf(tabPanel.getActiveTab());					 
			      if (downloadSrc === 0) {
			    	  // reset parameters and Time Tables in Get Data
			    	  this.paramGrid.store.removeAll();
			    	  this.timeSelector.TTGrid.store.removeAll();
			      }
			      else {
			    	// reset Time Tables in Get time Table
			    	  this.TTGrid.store.removeAll();
			      }
			    }			 
			  }
		    ]  
		});
    	 
		
	var myConf = {
		layout: 'border',
		items: [		   
		      this.formPanel, 		     
		      {
			xtype: 'panel', 
			region: 'south',
			title: 'Information',
			collapsible: true,
			height: 100,
			autoHide: false,
			bodyStyle: 'padding:5px',
			iconCls: 'icon-information',
			  loader: {
			    autoLoad: true,
			    url: helpDir+'downloadHOWTO'
			  }

		    	  
		      }
		],
		plugins: [ {ptype: 'searchParamEditorPlugin'}]
	  };
        
	Ext.apply (this, Ext.apply(arguments, myConf));
      }

});