/**
 * Project   : AMDA-NG
 * Name      : ParameterUI.js
 * @class 	 amdaUI.ParameterUI
 * @extends  Ext.container.Container
 * @brief	 Parameter  Module UI definition (View)
 * @author 	  
 * @version  $Id: ParameterUI.js 2257 2014-04-02 12:21:27Z elena $             
 */

Ext.define('amdaUI.ParameterUI',
	{
		extend: 'Ext.container.Container',

		alias: 'widget.panelParam',

		requires: [
			'amdaUI.AliasUI',
			'amdaUI.CalculatorUI',
			'amdaUI.DescriptionField',
			'extensions.SelectableTextArea',
			'amdaUI.ParamArgumentsPlug',
			'amdaModel.RequestParamObject',
			'amdaUI.StatusModalWindow',
			'amdaUI.CodeArea'
		],

		constructor: function (config) {
			this.init(config);
			this.callParent(arguments);
			// load object into form
			this.formPanel.getForm().loadRecord(this.object);
			var paramArgsPlug = this.getPlugin('derived-param-arguments-plugin');
			if (paramArgsPlug)
				paramArgsPlug.onApply = this.onApplyParameterArgs;
		},

		addParamInEditor: function (param) {
			var selection = this.constructionField.getSelection();
			this.constructionField.setValue(selection.beforeText + param + selection.afterText);
			this.constructionField.focus();
			if (this.constructionField.getValue()[(selection.beforeText + param).length] == ',') {
				this.constructionField.setCaretPosition((selection.beforeText + param).length + 1);
			}
			else {
				this.constructionField.setCaretPosition(this.constructionField.getValue().length);
			}
		},

		onApplyParameterArgs: function (uiScope, paramRequestObject) {
			var fullParam = paramRequestObject.getParamFullName();
			uiScope.addParamInEditor(fullParam);
		},

		addParam: function (newParamName, isLeaf, needArgs, components) {
			//if (!isLeaf || needArgs || components)
			if (needArgs)
				this.editParameterArgs(newParamName, components);
			else
				this.addParamInEditor(newParamName);
		},

		editParameterArgs: function (name, components) {
			var paramObj = amdaModel.RequestParamObject.getEmptyObj();
			paramObj.paramid = name;

			if (components) {
				if (components['index1']) {
					paramObj['dim1-index'] = components['index1'];
					++paramObj['type'];
				}

				if (components['index2']) {
					paramObj['dim2-index'] = components['index2'];
					++paramObj['type'];
				}
			}

			var paramArgsPlug = this.getPlugin('derived-param-arguments-plugin');
			if (paramArgsPlug) {
				var workinRequestParamObject = Ext.create('amdaModel.RequestParamObject', paramObj);
				paramArgsPlug.show('derived-param-arguments-plugin', workinRequestParamObject);
			}
		},

		setObject: function (object) {
			this.object = object;
			// load object into form
			this.formPanel.getForm().loadRecord(this.object);
		},

		/**
		* 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;
		},

		updateConstruct: function (oldval, newval) {
			// update constructionField (Construct parameter) in window parameter
			var expression = this.constructionField.value;
			oldval = oldval.replace(/[(]/g, "\\(");
			oldval = oldval.replace(/[)]/g, "\\)");
			var reg = new RegExp(oldval, "g");
			expression = expression.replace(reg, newval);
			this.constructionField.setValue(expression);
		},


		/** 
		* Generate info for parameter desplay
		 */
		generateParamInfo: function (onSuccess) {
			var me = this;
			var paramModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.param.id);

			var obj = {
				paramId: 'ws_' + this.object.get('name'),
				buildchain: this.object.get('buildchain'),
				timestep: this.object.get('timestep'),
				reference_param: this.object.get('reference_param'),
				sampling_mode: this.object.get('sampling_mode')
			};
			loadMask.show();
			AmdaAction.generateParamInfo(obj, function (result, e) {
				if (!result || !result.success) {
					loadMask.hide();
					if (result.message)
						myDesktopApp.warningMsg(result.message);
					else
						myDesktopApp.warningMsg('Unknown error during parameter compilation');
					return;
				}
				loadMask.hide();
				paramModule.linkedNode.get('object').set('dim_1', parseInt(result.dimensions.dim_1));
				paramModule.linkedNode.get('object').set('dim_2', parseInt(result.dimensions.dim_2));
				if (onSuccess)
					onSuccess();
				/*                    paramModule.linkedNode.update({scope : me, 
										failure: function(record, operation) {
										    
										},
										callback: function() {
																   }
									});
					*/
			});
		},

		/**
		* save method called by Save button
		*/
		saveProcess: function (toRename) {
			if (this.object.dirty) {
				// Parameter Module
				var paramModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.param.id);
				// if the name has been modified this is a creation
				if (this.object.isModified('name')) {
					// if object already has an id : it's a 'rename' of an existing TimeTable
					if (this.object.get('id')) {
						// the context Node is the parent node of current edited one
						var contextNode = paramModule.linkedNode.parentNode;
						// link a new node to the TimeTableModule
						paramModule.createLinkedNode();
						// set the contextNode
						paramModule.linkedNode.set('contextNode', contextNode);
						// create a new object linked		   		  
						paramModule.createObject(this.object.getJsonValues());
						var paramobj = paramModule.linkedNode.get('object');
						//synchronize objects
						this.object = paramobj;
						if (toRename) paramModule.linkedNode.toRename = true;
					}
					this.generateParamInfo(function () {
						paramModule.linkedNode.set('isParameter', true);
						paramModule.linkedNode.create({
							scope: this, callback: function () {
							}
						});
					});
				} else {
					paramModule.linkedNode.set('contextNode', paramModule.contextNode);
					this.generateParamInfo(function () {
						paramModule.linkedNode.update({
							scope: this, callback: function () {
							}
						});
					});
				}
			}
		},

		/**
		* overwrite metod called by Save button
		*/
		overwriteProcess: function (btn) {
			if (btn == 'cancel') return;

			this.fieldName.clearInvalid();
			this.saveProcess(true);
		},

		/**
		*   Check if brackets are balanced
		*/
		isBalanced: function (str) {
			str = ("" + str).replace(/[^()\[\]{}]/g, "");
			var bracket = {
				"]": "[",
				"}": "{",
				")": "("
			},
				openBrackets = [],
				isClean = true,
				i = 0,
				len = str.length;

			for (; isClean && i < len; i++) {
				if (bracket[str[i]]) {
					isClean = (openBrackets.pop() === bracket[str[i]]);
				} else {
					openBrackets.push(str[i]);
				}
			}
			if (!(isClean && !openBrackets.length)) return 'Brackets are not balanced';

			return true;
		},

		/**
		 * Check if changes were made before closing window 
		 * @return true if changes
		 */
		fclose: function () {
			var isDirty = this.formPanel.getForm().isDirty();
			return isDirty;
		},

		init: function (config) {
			this.fieldName = new Ext.form.field.Text({
				labelAlign: 'top', itemId: 'formParamName',
				labelPad: 0,
				fieldLabel: 'Parameter Name',
				name: 'name',
				allowBlank: false, //blankText : 'Name is required',
				emptyText: 'Please only low case!',
				width: 150,
				validateOnChange: false,
				validateOnBlur: false,
				enableKeyEvents: true,
				validFlag: false,
				validator: function () {
					return this.validFlag;
				},
				stripCharsRe: /(^\s+|\s+$)/g,
				listeners:
				{
					keyUp: function (field, e, opt) {
						this.setValue(this.getValue().toLowerCase());
					}
				}
			});
			
			this.constructionField = Ext.create('amdaUI.CodeArea',{type:"parameter"});

			var samplingmode_store = new Ext.data.ArrayStore({
				fields: ['id', 'name'],
				data: [
					['timestep', 'Time Step'],
					['refparam', 'Ref. Parameter']
				]
			});

			this.timeStepField = new Ext.form.NumberField({
				fieldLabel: '<img amda_clicktip="resamplingStep" src="js/resources/images/16x16/info_mini.png"/>&nbsp;Time Step (sec)',
				labelAlign: 'top',
				labelPad: 0,
				blankText: 'Time Step is required',
				name: 'timestep',
				minValue: 0.001,
				decimalPrecision: 10,
				hideTrigger: true,
				width: 150,
				validateOnBlur: false,
				allowBlank: false,
				isValid: function () {
					var me = this,
						disabled = me.disabled,
						validate = me.forceValidation || !disabled;

					if (!me.isVisible()) {
						return true;
					}

					return validate ? me.validateValue(me.processRawValue(me.getRawValue())) : disabled;
				}
			});

			this.refParamField = new Ext.form.TextField({
				fieldLabel: '<img amda_clicktip="resamplingRefParam" src="js/resources/images/16x16/info_mini.png"/>&nbsp;Reference Param.',
				labelAlign: 'top',
				labelPad: 0,
				name: 'reference_param',
				width: 150,
				hidden: true,
				allowBlank: false,
				listeners: {
					afterrender: function (field, eOpts) {
						var paramTarget = new Ext.dd.DropTarget(field.el.dom,
							{
								ddGroup: 'explorerTree',
								notifyEnter: function (ddSource, e, data) {
								},
								notifyDrop: function (ddSource, e, data) {
									var selectedRecord = ddSource.dragData.records[0];
									switch (selectedRecord.$className) {
										case 'amdaModel.LocalParamNode':
										case 'amdaModel.RemoteParamNode':
										case 'amdaModel.RemoteSimuParamNode':
											if (!selectedRecord.get('isParameter') || selectedRecord.get('disable'))
												return false;
											if (selectedRecord.get('alias') != "")
												field.setValue("#" + selectedRecord.get('alias'));
											else
												field.setValue(selectedRecord.get('id'));
											return true;
										case 'amdaModel.AliasNode':
											if (!selectedRecord.isLeaf())
												return false;
											field.setValue("#" + selectedRecord.get('text'));
											return true;
										case 'amdaModel.DerivedParamNode':
											if (!selectedRecord.isLeaf())
												return false;
											field.setValue("ws_" + selectedRecord.get('text'));
											return true;
										case 'amdaModel.MyDataParamNode':
											if (!selectedRecord.isLeaf())
												return false;
											field.setValue("wsd_" + selectedRecord.get('text'));
											return true;
										default:
											return false;
									}
									return true;
								}
							}
						);
					},
					scope: this
				},
				isValid: function () {
					var me = this,
						disabled = me.disabled,
						validate = me.forceValidation || !disabled;

					if (!me.isVisible()) {
						return true;
					}

					return validate ? me.validateValue(me.processRawValue(me.getRawValue())) : disabled;
				}
			});

			this.samplingDefContainer = new Ext.container.Container({
				border: false,
				items: [
					this.timeStepField,
					this.refParamField
				],
				width: 150
			});

			this.formPanel = new Ext.form.Panel({
				id: 'vbox-paramForm',
				bodyStyle: { background: '#dfe8f6' },
				border: false,
				buttonAlign: 'left',
				region: 'center',
				trackResetOnLoad: true, //reset to the last loaded record
				layout: {
					type: 'vbox',
					defaultMargins: { top: 5, left: 5, bottom: 10, right: 10 },
					align: 'stretch'
				},
				defaults: {
					border: false
				},
				items: [
					{
						flex: 1,
						xtype: 'container',
						border: false,
						layout: {
							type: 'table',
							columns: 3
						},
						defaultType: 'textfield',
						defaults: {
							labelAlign: 'top',
							labelPad: 0
						},
						items: [
							this.fieldName,
							{
								xtype: 'component', width: 20
							},
							{
								fieldLabel: 'Last modification',
								xtype: 'displayfield',
								name: 'last_update',
								width: 150,
								renderer: function (value, field) {
									var tpl = new Ext.XTemplate('<p style="font-style:italic;color:gray;margin:0;">{date}</>');
									var mod_date = 'Not saved';
									if (value > 0)
										mod_date = Ext.Date.format(new Date(value * 1000), "Y-m-d\\TH:i:s");
									return tpl.apply({ date: mod_date });
								},
							},
							{
								xtype: 'combo',
								fieldLabel: 'Sampling mode',
								name: 'sampling_mode',
								queryMode: 'local',
								editable: false,
								valueField: 'id',
								displayField: 'name',
								store: samplingmode_store,
								value: samplingmode_store.first(),
								listeners: {
									change: function (field, value) {
										this.timeStepField.setVisible(value != 'refparam');
										this.refParamField.setVisible(value == 'refparam');
									},
									scope: this
								}
							},
							{
								xtype: 'component', width: 20
							},
							this.samplingDefContainer,
							{
								itemId: 'formParamUnit',
								fieldLabel: 'Unit',
								name: 'units',
								width: 150
							},
							{
								xtype: 'component', width: 20
							},
							{
								itemId: 'formParamYTitle',
								fieldLabel: 'Y Title for Plot',
								name: 'ytitle',
								width: 150
							},
							{
								itemId: 'formParamDescription',
								name: 'description',
								xtype: 'descriptionfield',
								width: 320, height: 75,
								colspan: 3
							}]
					},
					this.constructionField
				],
				fbar: [
					{
						text: 'Save',
						scope: this,
						handler: function () {
							if (this.updateObject()) {
								var paramModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.param.id);
								if (!paramModule)
									return;
								var me = this;
								paramModule.linkedNode.isValidName(this.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);
								});
							}
						}
					},
					{
						text: 'Reset',
						scope: this,
						handler: function () {
							var paramModule = myDesktopApp.getLoadedModule(myDesktopApp.dynamicModules.param.id);
							paramModule.createLinkedNode();
							paramModule.createObject();
							this.setObject(paramModule.getLinkedNode().get('object'));
							/* reset with keeping old object
							this.formPanel.getForm().reset();
							*/
						}
					}, '->',
					{
						text: 'Edit Status',
						scope:this,
						handler: function(item,e) {
							Ext.create('amdaUI.StatusModalWindow', {object : this.object, type:'create',status : this.object.data.status}).show();
						}
					}
				]
			});

			var myConf = {
				layout: 'border',
				border: false,
				defaults: { layout: 'fit', border: false },
				items: [
					this.formPanel,
					{
						xtype: 'panel', region: 'south',
						title: 'Information',
						collapsible: true,
						collapseMode: 'header',
						height: 100,
						autoHide: false,
						iconCls: 'icon-information',
						bodyStyle: 'padding:5px',
						loader: {
							autoLoad: true,
							url: helpDir + 'myParameterHOWTO'
						}
					}],
				plugins: [
					{ ptype: 'calculator', myBtns: [], context: 'Parameter' },
					{ ptype: 'paramArgumentsPlugin', pluginId: 'derived-param-arguments-plugin' }
				],
				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));
		}
	});