/**
 * 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: 'Units',

								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));

		}
	});