/**
 * 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.ParamArgumentsPlug',
		'amdaUI.SendToSampButtonUI',
		'amdaModel.DownloadParam'
	],   
	
	//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']],
	timeformatTTData    : [['Y-m-dTH:i:s', 'YYYY-MM-DDThh:mm:ss']],
	fileformatData    : [['ASCII', 'ASCII'],['vot', 'VOTable'],['cdf', 'CDF'],['json', 'JSON']],
	fileformatTTData  : [['text', 'plain text'], ['vot','VOTable']],
	filecompressData  : [['zip', 'zip'], ['tar+gzip', 'tar+gzip']],
	filecompressTT    : [['zip', 'zip'], ['tar+gzip', 'tar+gzip'], ['none', 'none']],
	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();
		//
		var paramArgsPlug = this.getPlugin('download-param-arguments-plugin');
		if (paramArgsPlug)
			paramArgsPlug.onApply = this.onApplyParameterArgs;
	},

	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) {
		if (!obj.start || !obj.stop)
			return;
		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(paramId, isLeaf, needArgs, components) 
	{
		// adding the parameter to the  paramGrid	
		var paramObj = {
			paramid: paramId,
			type: 0,
			'dim1-is-range': false,
			'dim1-min-range': 0.,
			'dim1-max-range': 0.,
			'dim1-index': '*',
			'dim2-is-range': false,
			'dim2-min-range': 0.,
			'dim2-max-range': 0.,
			'dim2-index': '*',
			template_args: {}
		};
        	
		if (components) {
			if (components['index1']) {
				paramObj['dim1-index'] = components['index1'];
				++paramObj['type'];
			}
			
			if (components['index2']) {
				paramObj['dim2-index'] = components['index2'];
				++paramObj['type'];
			}
		}
        	
		var r = Ext.create('amdaModel.DownloadParam', paramObj);
		var pos = this.paramGrid.store.getCount();
		this.paramGrid.store.insert(pos,r); 
		this.paramGrid.getView().refresh();
		//if (!isLeaf || needArgs)
		//	this.editParameterArgs(r);
	},

	addParams: function(arrayParams) 
	{
		var arrayRec = new Array();
		var index = 1;		 
		if (arrayParams)
		{
			index = 0;            
			Ext.Array.each(arrayParams,function(item){		
				if (Ext.isObject(item)) {
					if (typeof paramId !== 'undefined')
					{
						// for Parameter Name in Download Module
						var paramObj = {
							paramid: paramId,
							type: 0,
							'dim1-is-range': false,
							'dim1-min-range': 0.,
							'dim1-max-range': 0.,
							'dim1-index': item.get('dim1'),
							'dim2-is-range': false,
							'dim2-min-range': 0.,
							'dim2-max-range': 0.,
							'dim2-index': item.get('dim2'),
							template_args: {}
						};		
						
						var r = Ext.create('amdaModel.DownloadParam', paramObj);	
					}
					else
					{
						//for download from get Data in Plot module
						var r = Ext.create('amdaModel.DownloadParam', item);	 
					}
						 				 
				}
				else {
				// for Download By Request in Operations menu
				//TODO BRE - Components selection
					var r = Ext.create('amdaModel.DownloadParam', { paramid: 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;
			if (compression === 'none'  
				&& this.TTGrid.getStore().count() > 1) {
				myDesktopApp.warningMsg('You are going to download several time tables -  select the Compression please'); 
				updateStatus = false;    
			}			
			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.timeformatTTData[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(sendToSamp, clientId){	 
		var downloadModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);
		if (downloadModule)
			downloadModule.linkedNode.execute(sendToSamp, clientId);		  
	},
	 	
	actionItem: function(grid, cell, cellIndex, record, row, recordIndex, e){
		
		var isTimeTable  = record instanceof amdaModel.TTobject; 
		 
		if ( cellIndex == 3 || ( cellIndex == 2 && isTimeTable ))
			grid.getStore().remove(record);
		else if ( cellIndex == 2 ) {
			this.paramGrid.getView().select(row);
			this.editParameterArgs(record);
		}
	},
	
	editParameterArgs: function(record) {
		var paramArgsPlug = this.getPlugin('download-param-arguments-plugin');
		if (paramArgsPlug)
			paramArgsPlug.show('download-param-arguments-plugin', record);
	},
	
	onApplyParameterArgs : function(parentUI, paramObject) {
		parentUI.paramGrid.getView().refresh();
	},
	 
	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());
	},

        onSendVOTableToSamp : function (clientId, sendOpt){
                var me = sendOpt.scope;
		if(me.updateObject()){
			me.doDownload(true, clientId);
		}
        },
	
	/**
	 * Check if changes were made before closing window 
	 * @return false
	 */	
	fclose : function() {
		return false;
	},
	
	init : function (config){
		var me = this;
		
		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.DownloadParam'} ),  
			columns: [ 
				{ xtype: 'rownumberer', width: 20 },
				{ 
					header: "Parameter Name", 
					dataIndex: 'name', 
					flex:1, 
					sortable: false, 
					menuDisabled : true ,
					renderer: function (val, meta, rec) {
						return rec.getParamFullName();
					}
				},
				{
					menuDisabled : true, width: 30, renderer: function(){
						return'<div class="icon-parameters" style="width: 15px; height: 15px;"></div>';
					}
				},
				{ 
					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 idToSent;
							var components = null;
							switch (data.records[0].data.nodeType)
							{
								case 'localParam' :
								case 'remoteParam':
								case 'remoteSimuParam':                                           
									idToSent = data.records[0].get('id');
									if (data.records[0].get('alias')!= "" )
										idToSent = "#"+data.records[0].get('alias');
									var component_info = data.records[0].get('component_info');
									if (component_info && component_info.parentId) 
									{													
										if ( component_info.index1 || component_info.index2 )
										{															 
											idToSent = component_info.parentId;
											components = [];												
											if (component_info.index1)
												components['index1'] = component_info.index1;
											if (component_info.index2)
												components['index2'] = component_info.index2;
										}	
										if ( data.records[0].get('needsArgs') )
										{															
											idToSent = component_info.parentId;	
											if (component_info.index1)
											{
												components = [];	
												components['index1'] = component_info.index1;
											}
										}													
									}
									break;
								case 'alias' :
									idToSent = "#"+data.records[0].get('text');
									break;
								case 'derivedParam' :
									idToSent = "ws_"+data.records[0].get('text');
									break;
								case 'myDataParam' :
									idToSent = "wsd_"+data.records[0].get('text');
									break;
								default :
								return false;
							}
							var downModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.download.id);							
							if (downModule)
								downModule.addParam(idToSent,data.records[0].get('leaf'), data.records[0].get('needsArgs'), components);	
							return true;
						}
					});
				}
			}			
		});      
						
		this.paramGrid.on('cellclick', this.actionItem, 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: "TimeTable/Catalog 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)
						{
							var nodeType = data.records[0].get('nodeType');
							
							if ((nodeType == 'timeTable' || nodeType == 'sharedtimeTable') ||
							(nodeType == 'catalog' || nodeType == 'sharedCatalog') &&
							(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.actionItem, this);
						
		this.paramPanel = { 		 
			xtype: 'container',	  
			title: 'Parameters',		   
			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: 'Header in a separate file',
                                                boxLabelAlign: 'before',
                                                name: 'separateInfoFile', checked: false
                                
                                        },
					{
						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: 'Time Tables / Catalogs',			 
			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.timeformatTTData,
						value: this.timeformatTTData[0]					     
					}, 
					{				     
						fieldLabel: 'File Format ',
						name: 'fileformatTT',				    
						store: this.fileformatTTData, 
						value: this.fileformatTTData[0]                  	        	        	 
					},				
					{
						fieldLabel: 'Compression ', 
						name: 'compressionTT',
						store: this.filecompressTT, 
						value: this.filecompressTT[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			      
				],
				listeners: {
					'tabchange' : function (tabPanel, tab) {
						var sampAvailable = (tab.title == me.paramPanel.title);
						me.down('sendToSampButton').setDisabled(!sampAvailable);
					}
				}
			}],
			fbar: [
			{
				text: 'Download',
				scope : this,
				handler: function(button){
					// if the return is true (object had been updated)
					if(this.updateObject()){
						// launch the download 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();
					}
				}			 
			},
			'->',
			{
                                xtype        : 'sendToSampButton',
                                type         : 'votable',
                                onSendToSamp : this.onSendVOTableToSamp,
                                sendOpt      : {scope : this}
                        }]  
		});    	 
		
		var myConf = {
			layout: 'border',
			items: [		   
				this.formPanel,   
				{
					xtype: 'panel', 
					region: 'south',
					title: 'Information',
					collapsible: true,
					collapseMode: 'header',
					height: 100,
					autoHide: false,
					bodyStyle: 'padding:5px',
					iconCls: 'icon-information',
					loader: {
						autoLoad: true,
						url: helpDir + 'downloadHOWTO'
					}				
				}				
			],
			plugins: [ {ptype: 'paramArgumentsPlugin', pluginId: 'download-param-arguments-plugin'}]
		}; 
		
		Ext.apply (this, Ext.apply(arguments, myConf));
	}
});