/**
 * Project       AMDA-NG
 * Name          CatalogUI.js
 * @class 	 amdaUI.catalogUI
 * @extends      Ext.container.Container
 * @brief	 Catalog Module UI definition (View)
 * @author 	 elena
 */

Ext.define('amdaUI.CatalogUI', {
	extend: 'Ext.container.Container',
	alias: 'widget.panelCatalog',

	isCatalog : true,
	
	constructor: function(config) {
	        this.init(config);
		this.callParent(arguments);;
	 	if (this.object) this.loadObject();	         
	},
	
	
	/**
	 * set params description into this.object
	 */
	setParamInfo : function(parameters) {
	  
	   var params = [];
	   Ext.Array.each(parameters, function(item, index) {
	      params[index] = item;	     	  
	   }, this);
	   
	   this.object.set('parameters', params);
	  
	},
	
	/**
	 * update this.object from form
	 */	
	updateObject : function(){  
	// get the basic form	
	  var basicForm = this.formPanel.getForm();        
	  var updateStatus = true;

	  var fieldsWithoutName = basicForm.getFields().items;
	  Ext.Array.each(fieldsWithoutName, function(item, index,allItems){
	      if(item !== this.fieldName) { 		     
		  if (!item.isValid()) {
		      // set update isn't allowed
		      updateStatus = false;    
		  }
	      }
	  }, this);
	      // if the update is allowed
	  if (updateStatus) {
	  /// real object update
	  // update TimeTable object with the content of form
	      basicForm.updateRecord(this.object);	
	  }
	  // return the update status  
	   return updateStatus;	    
	},
	
	
	updateCount : function() {
		this.object.set('nbIntervals',this.TTGrid.getStore().getTotalCount());		
		this.formPanel.getForm().findField('nbIntervals').setValue(this.object.get('nbIntervals'));
	},
	
	/**
	 * load object catalog into this view
	 */
	loadObject : function(){ 	  
        // load object into form
	  this.formPanel.getForm().loadRecord(this.object);
	  
	  this.status = null;
		
	  var me = this;
	  
	  var onAfterInit = function(result, e) {
	  
	    if (!result || !result.success)
          	{
          		if (result.message)
          			myDesktopApp.errorMsg(result.message);
          		else
          			myDesktopApp.errorMsg('Unknown error during catalog cache initialisation');
          		return;
          	}
          	
          	
	    var fields = [], columns = [], i = 2, width, index;
	    
	    fields[0] =  Ext.create('Ext.data.Field',{ name : 'start' });
	    fields[1] =  Ext.create('Ext.data.Field',{ name : 'stop' }); 
			    
	    columns[0] =  Ext.create('Ext.grid.column.RowNumberer');
	    
	    columns[1] = Ext.create('Ext.grid.column.Column', { text: 'Start Time', sortable : false,  dataIndex: 'start',  
				  width : 120, menuDisabled: true });
	    columns[2] = Ext.create('Ext.grid.column.Column', { text: 'Stop Time', sortable : false,  dataIndex: 'stop',  
				  width : 120, menuDisabled: true });
	    
	    Ext.Array.each(result.parameters, function(obj) {
		    index = 'param'+i.toString();			
		    fields[i] = Ext.create('Ext.data.Field',{ name : index });
		    width = 50. *  parseInt(obj.size);
		    columns[i+1] = Ext.create('Ext.grid.column.Column', { text: obj.name, sortable : false,  dataIndex: index,  
				  width : width, menuDisabled: true });
		    i++;
	      });
            

             var store = Ext.create('Ext.data.Store', {
		  fields: fields,
		  autoDestroy: false,
		  pageSize : 200,
		  buffered : true, 
		  purgePageCount: 0,
		  remoteSort: true,
		  proxy: {
		    type: 'direct',
		    api :
		    {
			  read   :  AmdaAction.readTTCacheIntervals
		    },
		  // remplir automatiquement tt, sharedtt , catalog, shared catalog
		  extraParams : {'typeTT' : 'catalog'},
		  reader:
		  {
		    type: 'json',
		    root: 'intervals',
		    totalProperty : 'totalCount'
		  }
		  },
		  listeners: {
		    scope : me,
	            load: function(store,records) {        
                       // myDesktopApp.EventManager.fireEvent('refresh');
                        me.TTGrid.getView().refresh();
                        me.TTGrid.getSelectionModel().refresh();
                        me.updateCount();
                        //Statistical plugin
             		//   	this.fireEvent("refresh");
	            }
		  }
                 });
	   
	      me.TTGrid.reconfigure(store, columns);
	             	             
//         	
//         	me.TTGrid.getSelectionModel().deselectAll();
//         	        	
//         	// clear filters
//         	me.TTGrid.getStore().clearFilter(true);
//         
//     		//clear sort
//         	me.TTGrid.getStore().sorters.clear();
//         	//me.TTGrid.getStore().sorters = new Ext.util.MixedCollection();
//         	
         	//set cache token to the Catalog object
         	me.object.set('cacheToken', result.token);
         	me.setParamInfo(result.parameters);
		
        	me.TTGrid.getStore().load();
		
         	me.status = result.status;

	  };
	  
	if (this.object.get('fromPlugin'))
        {
        	if (this.object.get('objFormat') && this.object.get('objFormat') != '')
        	{
        		//From uploaded file
        		//AmdaAction.initTTCacheFromUploadedFile(this.object.get('objName'), this.object.get('objFormat'), onAfterInit);
        	}
        	else
        	{
        		//From tmp object (ie Search result)		    
        		AmdaAction.initTTCacheFromTmpObject(this.object.get('folderId'), this.object.get('objName'), this.isCatalog, onAfterInit);
        	}
        }
        else
        {
        	var typeTT = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.tt.id).linkedNode.data.nodeType;
        	if (this.object.get('id') == '')
        	{
        		//Init empty cache
        		//AmdaAction.initTTCache(onAfterInit);
        	}	
        	else
        	{
        		//From existing TT file
        		//AmdaAction.initTTCacheFromTT(this.object.get('id'), typeTT, onAfterInit);
        	}
        }
	},
	checkIntervalsStatusForSave : function(onStatusOk) {
	  onStatusOk();
	},
	
	/*	    
	 * save method called by Save button
	 */
	saveProcess : function(toRename){
            var module = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.catalog.id); 
	      
            // if the name has been modified this is a creation
             if (this.fclose()) {  
	       
	      if (this.object.isModified('name') || this.object.get('fromPlugin')) {
	            
                // if object already has an id : it's a 'rename' of an existing  
                if (this.object.get('id')){
                    // the context Node is the parent node of current edited one
                    var contextNode = module.linkedNode.parentNode;
                    // link a new node to the TimeTableModule
                    module.createLinkedNode();
                    // set the contextNode
                    module.linkedNode.set('contextNode',contextNode);
                    // create a new object linked
                    module.createObject(this.object.getJsonValues());
                    
                    var obj = module.linkedNode.get('object');                                                    
                    // synchronisation of objects
                    this.object = obj;
                    if (toRename) module.linkedNode.toRename = true;
                } 
                module.linkedNode.create({callback : function() {module.linkedNode.update();}, scope : this});
	      } else {
		  //update
		module.linkedNode.update();
	    }
	    }
	},
	
	/**
	 * Check if changes were made before closing window 
	 * @return true if changes
	 */	
	fclose : function() {
		if (this.status == null)
			return false;
		
		var isDirty = this.formPanel.getForm().isDirty() || (this.status.isModified) || (this.status.nbModified > 0) || (this.status.nbNew > 0);
		return isDirty;
	},

		    
	init : function (config) {
	  
          this.object =   config.object;
	  
	  this.fieldName = new Ext.form.field.Text({
	      fieldLabel: 'Name',
	      allowBlank : false,
	      stripCharsRe: /(^\s+|\s+$)/g,
	      emptyText: 'Please no spaces!',
	      name: 'name',
	      validateOnChange: false,
	      validateOnBlur: false,
	      validFlag: false,
		  validator : function() {
		      return this.validFlag;
		  }
	  });
	  

	this.TTGrid =  Ext.create('Ext.grid.Panel', { 
//	      title: 'Catalog', 
	      height: 530,
	      columns: [
		{ text: '',  dataIndex: '' }
	    
	      ],
	      frame: true,
	      dockedItems: [{
                xtype: 'toolbar', 
                items: [{
                    iconCls: 'icon-add',
                    scope: this,
                    handler: function(){
//                         cellEditing.cancelEdit();
//                         
//                         var selection = this.TTGrid.getView().getSelectionModel().getSelection()[0];
//                         var row = 0;
//                         if (selection)
//                         	row = store.indexOf(selection) + 1;
//                         this.TTGrid.getSelectionModel().deselectAll();
//                         
//                         var me = this;
//                         AmdaAction.addTTCacheInterval({'index' : row}, function (result, e) {
//                         	this.status = result.status;
//                         	this.TTGrid.getStore().reload({
//                         		callback : function(records, options, success) {
//                         			me.TTGrid.getView().bufferedRenderer.scrollTo(row, false, function() {
//                         				me.TTGrid.getView().select(row);
//                         				cellEditing.startEditByPosition({row: row, column: 1});	
//                         			}, me);	
//                         		}
//                         	});
//                         }, this);
                    }
                }, {
                    iconCls: 'icon-delete',
                    disabled: true,
                    itemId: 'delete',
                    scope: this,
                    handler:  function(){
//                         var selection = this.TTGrid.getView().getSelectionModel().getSelection()[0];
//                         if (selection) {
//                         	var rowId = selection.get('cacheId');
//                         	this.TTGrid.getSelectionModel().deselectAll();
//                         	AmdaAction.removeTTCacheIntervalFromId(rowId, function (result, e) {
//                         		this.status = result.status;
//                             	this.TTGrid.getStore().reload();
//                             }, this);
//                         }
                    }
                }]
	      }]
	});
 
	  this.formPanel =  Ext.create('Ext.form.Panel', { 
	      region : 'center',
	      layout:  'hbox', 
	      bodyStyle: {background : '#dfe8f6'},
	      defaults: { border : false, align: 'stretch', bodyStyle: {background : '#dfe8f6'},  padding: '3'},
	      fieldDefaults: { labelWidth: 80, labelAlign : 'top' },
	      items: [ 
		{            
		    xtype: 'form',		            
		    flex: 1,
		    buttonAlign: 'left',
//		    title : 'Information',		   
		    layout: {type: 'vbox', pack: 'start', align: 'stretch'},
		    items : [
		     this.fieldName,
		      {
		      xtype: 'fieldcontainer',
		      layout: 'hbox',		      
		      items: [
			  {
			      xtype:'datefield', fieldLabel:'Creation date',
			      name: 'created', disabled: true, 
			      hideTrigger: true, format: 'Y/m/d H:i:s'
			  },			  
			  { xtype: 'splitter' },			 			 
			  { xtype:'textfield', fieldLabel: 'Intervals', name: 'nbIntervals', disabled: true}
			]                                                                       
		      },
		      {
			  xtype: 'textarea',
			  name: 'description',
			  fieldLabel: 'Description',
			  height: 200
		      },
		      {
			  xtype: 'component',
			  height: 180
		      }
		      ],
		      fbar:[
			  {   
			      type: 'button',
			      text: 'Save',
			      scope : this,
			      handler: function () {
                            	if (this.updateObject()){
				       
                            		var basicForm = this.formPanel.getForm();      
                            		// if there's at least one record in the store of TTGrid
                            		if (this.TTGrid.getStore().getTotalCount() > 0) {
                            			// update TimeTable object which the content of form
                            			basicForm.updateRecord(this.object);

                            			var me = this;
                            			this.checkIntervalsStatusForSave(function () {
						    //Name validation
						    var module = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.catalog.id);	
						    if (!module)
							    return;
						    module.linkedNode.isValidName(me.fieldName.getValue(), function (res) {
							    if (!res)
							    {
								    me.fieldName.validFlag = 'Error during object validation';
								    myDesktopApp.errorMsg(me.fieldName.validFlag);
								    me.fieldName.validate();
								    return;
							    }
									      
							    if (!res.valid)
							    {
								    if (res.error)
								    {
									    if (res.error.search('subtree') != -1) {  							
										    Ext.MessageBox.show({title:'Warning', 
											    msg: res.error+'<br/>Do you want to overwrite it?',
											    width: 300,
											    buttons: Ext.MessageBox.OKCANCEL, 
											    fn : me.overwriteProcess,
											    icon: Ext.MessageBox.WARNING,
											    scope : me
										    });
										    me.fieldName.validFlag = true;
									    }
									    else
										    me.fieldName.validFlag = res.error;
								    }
								    else
								    {
									    me.fieldName.validFlag = 'Invalid object name';
									    myDesktopApp.errorMsg(me.fieldName.validFlag);
								    }
								    me.fieldName.validate();
								    return;
							    }
									      
							    me.fieldName.validFlag = true;
							    me.fieldName.validate();
							    me.saveProcess(false);
						    });
                            			});                            
  				              } else {
  				                // warning:
  				                Ext.Msg.alert('No intervals', 'Your time table is invalid, <br>you must have at least one interval');
  				              }
                                    }
                           } 
			  },{   
			      type: 'button',
			      text: 'Share',
			      disabled: true 
			  },
			  {   
			      type: 'button',
			      text: 'Visualize' 
			  } 
			]
		}, {
		    xtype: 'form',		               
		    bodyStyle: {background : '#dfe8f6'},
//		    padding: '3',
		    flex: 2,
		    items : [
		      this.TTGrid
		    ] 
		}
	    ]  
	  }); 
	 
	 this.TTGrid.getSelectionModel().on('selectionchange', function(selModel,selections){
	        this.TTGrid.down('#delete').setDisabled(selections.length === 0); 
        }, this); 
	
	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'
			      } 
			  }
		    ] 
	      };
	    
	    Ext.apply (this, Ext.apply(arguments, myConf));	
    }
	 
});