/**
 * 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',
		'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']],
	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();
	 	//
	 	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) {
                                                                  
            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)) {
                                // 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 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;
                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);
	},
	 
	

	actionItem: function(grid, cell, cellIndex, record, row, recordIndex, e){

		if (cellIndex == 3)

			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());
	},

	
	/**
	 * 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.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) {
                                            	//It's a component
                                            	idToSent = component_info.parentId;
                                        		components = [];
                                        		if (component_info.index1)
                                        			components['index1'] = component_info.index1;
                                        		if (component_info.index2)
                                        			components['index2'] = component_info.index2;
                                            }

                                            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: "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.actionItem, 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: 'paramArgumentsPlugin', pluginId: 'download-param-arguments-plugin'}]

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

});