/**
 * Project   : AMDA-NG
 * Name      : UploadUI.js
 * @class    amdaUI.UploadUI
 * @extends  Ext.panel.Panel 
 * @brief    Upload Panel UI definition (View)
 * @author 	 Elena
 * @version  $Id: UploadPanelUI.js 2831 2015-03-26 10:33:42Z elena $            
 */

Ext.define('amdaUI.UploadPanelUI', {
        extend: 'Ext.form.Panel',
        alias: 'widget.panelUpload',
        
        requires : [
                'amdaUI.RemoteSearchPlugin'
        ],
        
        isFile : true,        
        tmpNode : null,
                        
        constructor: function(config) {	  
            this.init(config);
            this.callParent(arguments);  		        
        },

        /*
         * create MyData linked node and edit in module MyData
         * update myDataParams info if needed
         */
        getObjectCallback : function(result,remoteEvent)
        {                    
            var t = remoteEvent.getTransaction();
            if (result && !result.error) {
            	// set parameter into node
            	var me = this;
                myDesktopApp.getLoadedModule(this.tmpNode.get('moduleId'), true, function (module) {
                	// myData
                    if (me.tmpNode.get('nodeType') == amdaModel.MyDataParamNode.nodeType) {		       
                            var linkedFile = Ext.create('amdaModel.MyDataNode', {leaf : true, text : me.tmpNode.get('text')});
                            
                            linkedFile.create(result.mask, result.description, result.maskDesc);
                            linkedFile.updateMyDataParam(result.mask,result.maskDesc); 
                            
                            if (!linkedFile.get('id')) 
                                linkedFile.set('id',me.tmpNode.get('text'));   
                   
                            var paramObj = Ext.create(linkedFile.get('objectDataModel'), result);
                            linkedFile.set('object',paramObj);
                            me.tmpNode.set('fileObject',paramObj);
                    }
                    else {
                        // Time Table 
                        var paramObj = Ext.create(me.tmpNode.get('objectDataModel'), result);
                        
                        paramObj.set('fromPlugin',true);
                        if (result.intervals) {
                        	paramObj.set('intervals',result.intervals);
                        	paramObj.set('nbIntervals',result.intervals.length);
                        }
                        me.tmpNode.set('object',paramObj);
                    }	
                    if (module)
                    {
                    	module.setLinkedNode(me.tmpNode); 	      
                    	module.linkedNode.editInModule();  
                    }
                }); 
            } 
            else {	   
                // EXCEPTION : parameter not found !
                myDesktopApp.errorMsg(t.action + "." + t.method + " : No parameter '"
                    +this.tmpNode.get('text')+"' found!");	     
            }
            loadMask.hide();
        },
        
    /*
    *  form validation
    *  TODO markInvalid()?
    */
        validate : function() 
        {
            var values = this.getForm().getValues();

            if (values['filesrc'] == 'LOCAL') {
                var locFile = this.isFile ? this.getForm().findField('localFileName').getValue() :
                                            this.getForm().findField('localTTName').getValue();	 
            
                if (!locFile) {
                myDesktopApp.warningMsg("Select File to Upload");
                return false;
                }
            }
            else {
                if (!values['remoteFile'] && !values['remoteTT']) {
                myDesktopApp.warningMsg("Select File to Upload");
                return false;
                }
            }	     	     
            return true;
        },

        
        //TODO proper parsing
        updateFormat: function(value) 
        {    
            var arrayOfStr = value.split('.');
            //TODO use down method?	  
            if (this.isFile) {
                var radios = Ext.getCmp('filefrmt');
                var user_format_obj = radios.getValue();	  
                var user_format = user_format_obj.filefrmt;
            }
            else {
                var radios = Ext.getCmp('ttfrmt');
                var user_format_obj = radios.getValue();	  
                var user_format = user_format_obj.ttfrmt;
            }
                    
            var auto_format = user_format;
            
            //  auto define format in some special cases 
            //TODO name without extention => ASCII?
            if (arrayOfStr.length == 1) auto_format = 'ASCII'; 
            else  {
                var suffix = arrayOfStr[arrayOfStr.length - 1].toLowerCase();
                if (suffix == 'gz') 
                    suffix = arrayOfStr[arrayOfStr.length - 2].toLowerCase() + '.gz';

                switch (suffix)
                {
                        case 'cdf' :  auto_format = 'CDF'; break;
                        case 'cef.gz' :
                        case 'cef' :  auto_format = 'CEF'; break;
                        case 'xml' :  auto_format = 'VOT';
                        case 'vot' :  auto_format = 'VOT'; break;
                        case 'nc'  :  auto_format = 'NC'; break;
                        case 'asc' :
                        case 'txt' :			 
                        default : auto_format = 'ASCII'; 			   
                }
            }
 
            // set auto format : case when format was not set by user before   
            if (this.isFile && user_format !== auto_format) {
                user_format_obj.filefrmt = auto_format;    
            } else  if (!this.isFile && user_format !== auto_format) {
                user_format_obj.ttfrmt = auto_format;
            }	
                radios.setValue(user_format_obj);
        },
 
        /*
         * 
         */
        forceUpload : function (url,format)
        {
                this.getForm().findField('filesrc').setValue('URL');	
                
                switch (format)
                {
                        case 'votable' :
                                this.getForm().findField('filefrmt').setValue('VOT');
                                break;
                        case 'cdf' :
                                this.getForm().findField('filefrmt').setValue('CDF');
                                break;
                        default :
                                //ToDo Error - unknown format
                                return;
                }                
                this.getForm().findField('remoteFile').setValue(url);
                
                this.postUpload();
        },
        
        /*
         * 
         */
        postUpload : function()
        {
            // 'global' form containing 'partial' forms				      
            var form = this.getForm();
            
            // special validation 	            
            if(this.validate()){						
                form.submit({
                    scope: this,
                    url: 'php/uploadFile.php',
                    waitMsg: 'Uploading your file...',
                    success: function(form, o){                     
                        this.tmpNode = Ext.create(this.nodeType,{leaf : true, text : o.result.file});
                        loadMask.show();
                        AmdaAction.getUploadedObject(o.result.file, o.result.format, this.tmpNode.get('nodeType'), this.getObjectCallback, this);
                    },
                    failure: function(form, o) {                    
                        loadMask.hide();                       
                        myDesktopApp.errorMsg('Error '+o.result.error); 
                    }
                    });
                }		
        },
	
        /*
        *  panel config
        */
        init : function(config) 
        {       
            this.isFile = config.panelType == 'file'? true : false;
            
            // file/time table settings	  
            if (this.isFile) {	    
            var title = 'Upload File';
            var  items  = [
                            { boxLabel: 'ASCII', name: 'filefrmt', inputValue: 'ASCII', checked: true,
                                    listeners: {
                                        change: function (cb, nv, ov) {
                                            if (nv) Ext.getCmp('tf').show();
                                            else Ext.getCmp('tf').hide();	
                                        }
                                        } 
                            }, 
                            { boxLabel:  'netCDF&nbsp;<img amda_clicktip="ncTimeFormat" style="vertical-align:bottom" src="js/resources/images/16x16/info_mini.png"', name: 'filefrmt', inputValue: 'NC' },
                            { boxLabel: 'CDF', name: 'filefrmt', inputValue: 'CDF' },
                            { boxLabel: 'CEF[GZ]', name: 'filefrmt', inputValue: 'CEF' },
                            { boxLabel: 'VOTable', name: 'filefrmt', inputValue: 'VOT' }			    
                        ];
            var timeFormatId = 'tf';
            this.formatId = 'nsf';
            this.localUploadId = 'form-uploadfile';
            var localUploadName ='localFileName';
            var remoteUploadName ='remoteFile';
            this.remoteUploadId = 'form-uploadurl'; 	 
            this.nodeType = 'amdaModel.MyDataParamNode';
            //TODO load XML	   
            var store = Ext.create('Ext.data.Store', {
                fields: ['value', 'name'],
                data : [
                    {"value":"ftp://cdaweb.gsfc.nasa.gov/pub/data/", "name":"CDAWEB/FTP"},		   
                    {"value":"ftp://ftp.ngdc.noaa.gov/STP/SOLAR_DATA/", "name":"Solar Data"}
                ]
            });	   
            }
            else {
            
            var title = 'Upload Time Table';
            var  items  = [
                            {boxLabel: 'ASCII', name: 'ttfrmt', inputValue: 'ASCII', checked: true,
                                    listeners: {
                                        change: function (cb, nv, ov) {
                                            if (nv) Ext.getCmp('tf_tt').show(); 
                                            else Ext.getCmp('tf_tt').hide();  							 						  
                                        }
                                        } 
                                    },
                            {boxLabel: 'VOTable', name: 'ttfrmt', inputValue: 'VOT'}			    
                        ];
                        
            var timeFormatId = 'tf_tt'; 
            this.formatId = 'nsf_tt';
            this.localUploadId = 'form-uploadtt';
            var localUploadName ='localTTName';
            var remoteUploadName ='remoteTT';
            this.remoteUploadId = 'form-uploadtturl'; 
            this.nodeType = 'amdaModel.TimeTableNode';
            //TODO load XML		    
            var store = Ext.create('Ext.data.Store', {
                fields: ['value', 'name'],
                data : []
                });
            }  
            
            var combo = Ext.create('Ext.form.ComboBox', {
                flex : 4, 
                store: store,
                emptyText: 'Enter Remote Site URL (ftp)',
                queryMode: 'local',
                displayField: 'name',
                valueField: 'value' 
            });
	    	  
            var fieldcontainer = { xtype: 'fieldcontainer', 
                                fieldLabel: ' ', labelWidth: 0, labelSeparator : '', labelPad : 0,
                                layout: 'hbox',		
                                items: [
                                    combo,
                                    {
                                    xtype : 'button',
                                    flex : 1,
                                    text: 'Browse It',								   
                                        handler: function(){					      
                                            var form = this.up('form').getForm(); 
                                            var site = form.getFields().getAt(0).getValue(); 					    
                                            if (site) 						   
                                                this.up('form').ownerCt.fireEvent('open', site);
                                            else 
                                                myDesktopApp.warningMsg("Please Enter Remote Site URL");				 
                                        } 
                                    }                     
                                ]
            };
            var radioId = this.isFile ? 'filefrmt' : 'ttfrmt';
            var fileFormat =  Ext.create('Ext.form.FieldSet', { 			      
                                title: 'File Format',			     		     
                                items : [ { 
                                            xtype: 'radiogroup',
                                            id : radioId, 
                                            columns: 3,
                                            cls: 'x-check-group-alt',
                                            items: items				
                                        }
                                        ]
            });
            
            var Sampling = { xtype: 'radiogroup',	
                            fieldLabel: 'Time Sampling',	
                            labelWidth: 90,			  
                            cls: 'x-check-group-alt',
                            hidden : !this.isFile,
                            defaults : {name : 'timesmpl'},
                            items: [ 			
                            {boxLabel: 'constant', inputValue: 'constant', checked: true},
                            {boxLabel: 'variable&nbsp;<img amda_clicktip="variableSampling" style="vertical-align:bottom" src="js/resources/images/16x16/info_mini.png"', inputValue: 'variable'}	  
                            ] 		
            };
	  
            var dayStart = { xtype: 'checkbox',  
                            name : 'doy',
                            hidden : true,
                            fieldLabel: 'DOY starts from 1',
                            inputValue: '1'
            };
            
            var nonStandardFormat = 
            { 
                                    xtype: 'fieldcontainer',
                                    defaultType: 'textfield',
                                    layout: 'anchor',
                                    defaults: {
                                        layout: '100%',
                                        labelWidth : 150					
                                    }, 
                                    id : this.formatId, 
                                    hidden : true,
                                    items: [  
                                    { 
                                        fieldLabel : 'define time format',	
                                        name : 'nonstd',				   
                                        value: 'Y-m-d H:i:s',
                                        enableKeyEvents: true,
                                        listeners : {
                                            keyUp : function() {
                                                    if (this.getValue().indexOf('z') > 0) {
                                                        this.nextSibling().show();
                                                    }                                                 
                                                    if (this.getValue().indexOf('d') > 0) {
                                                        this.nextSibling().hide();
                                                    }                                                 
                                                }
                                            }
                                    },
                                    dayStart,
                                    { 
                                        fieldLabel : 'define max time length',
                                        name : 'timelength',
                                        value: 'auto' 				    
                                    }
                                    ],
                                    listeners : {                                        
                                        hide : function() {
                                                this.items.getAt(1).hide();                                                
                                            }
                                    }
            };	 

            var timeFormat = Ext.create('Ext.form.FieldSet', { 
                        id: timeFormatId, 
                        title: 'Time Settings',			     			       
                        items : [{
                            xtype: 'radiogroup',
                            fieldLabel: 'Time Format',
                            labelWidth: 90,				   
                            cls: 'x-check-group-alt',
                            defaults : { name : 'timefrmt'},
                            items: [						 
                            {boxLabel: 'standard&nbsp;<img amda_clicktip="standardTimeFormat" style="vertical-align:bottom" src="js/resources/images/16x16/info_mini.png"', inputValue: 'standard', checked: true},     			
                            {boxLabel: 'no&nbsp;<img amda_clicktip="userTimeFormat" style="vertical-align:bottom" src="js/resources/images/16x16/info_mini.png"', inputValue: 'user', 
                                listeners: {
                                    scope : this,
                                    change: function (cb, nv, ov) {							
                                    if (nv) 
                                        Ext.getCmp(this.formatId).show();
                                    else    
                                        Ext.getCmp(this.formatId).hide();	
                                    }
                                } 					      
                                }													
                            ] 				      			  	
                            },
                            nonStandardFormat,
                            Sampling
                        ]
                });
      
                var localFile = Ext.create('Ext.form.Panel', {			      
                            id: this.localUploadId,
                            fileUpload: true,
                            hideLabels: true,
                            frame: true,			      
                            items: [{
                                    xtype: 'fileuploadfield',							     
                                    emptyText: 'Select Your File',
                                    width: 300,
                                    name: localUploadName,  
                                    buttonText: 'Browse',
                                    listeners: {
                                        scope : this,
                                        change: function (field, value, e) {							
                                                this.updateFormat(value);	
                                        } 
                                    }
                                },
                                {  
                                    // it is common setting for Local and Remote files
                                    xtype : 'hiddenfield',
                                    name: 'MAX_FILE_SIZE',
                                    value: myDesktopApp.MAX_UPLOADED_FILE_SIZE // 30MB	 			      
                                }
                                ] 
                });      
      
                var remoteFile = Ext.create('Ext.form.Panel', {					 
                                id: this.remoteUploadId,					 
                                hideLabels: true,
                                autoHeight: true,					 
                                frame: true,
                                hidden : true,
                                items: [  fieldcontainer,
                                        { xtype : 'textfield',
                                            name : remoteUploadName, 
                                            emptyText: 'Enter Remote File URL (http or ftp)',
                                            width: 310,
                                            listeners: {
                                            scope : this,
                                            change: function (field, value, e) {							
                                                    this.updateFormat(value);	
                                                } 
                                            }
                                        } 
                                ]
                });
                                        
                var uploadForm = Ext.create('Ext.form.FieldSet',{				    			    
                            title: 'File Source',			     
                            items : [{ xtype: 'radiogroup',					 
                                cls: 'x-check-group-alt',
                                items: [
                                        {boxLabel: 'Local', name: 'filesrc', inputValue: 'LOCAL', checked: true,
                                        listeners: {
                                            scope : this,
                                            change: function (cb, nv, ov) {
                                                if (nv == ov) return;
                                                var local = Ext.getCmp(this.localUploadId);
                                                var remote = Ext.getCmp(this.remoteUploadId);
                                                if (nv) {
                                                    remote.hide();
                                                    local.show();					
                                                }
                                                else  {
                                                    local.hide();
                                                    remote.show();									    
                                                }   
                                            }
                                        } 
                                        },
                                        {boxLabel: 'URL', name: 'filesrc', inputValue: 'URL'},						 
                                    ]}]
                });		      
                                            
                var myConf = {
                            title : title,  
                            layout: {type: 'vbox', align: 'stretch'},
                            bodyStyle: { background : '#dfe8f6'},
                            items : [ 
                                    uploadForm,
                                    localFile, 
                                    remoteFile, 			     
                                    fileFormat,
                                    timeFormat	
                            ],
                            buttons: [
                                        {
                                                text: 'Upload',
                                                handler: function()
                                                {
                                                    this.postUpload();
                                                },
                                                scope : this
                                        },
                                        {
                                                text: 'Reset',
                                                handler: function(){				      
                                                    this.up('form').getForm().reset();  
                                                }
                                        }
                                    ], 
                            plugins: [{ptype: 'remoteSearchPlugin'}],
                            listeners: {
                                click: {
                                element: 'el',
                                fn: function(e,t) {	 		 
                                    var me = t,
                                            text = me.getAttribute('amda_clicktip');
                                        if (text) {
                                                e.preventDefault();
                                                AmdaAction.getInfo({name : text}, function(res,e) {					    					   
                                                            if (res.success) myDesktopApp.infoMsg(res.result);
                                                }); 
                                        }
                                    }
                                }
                            }
                    };
            
                Ext.apply (this, Ext.apply(arguments, myConf));	 	  
        }		 
});