/**
 * Project   : AMDA-NG
 * Name      : PlotSpectroForm.js
 * @class   amdaPlotComp.PlotSpectroForm
 * @extends amdaPlotComp.PlotStandardForm
 * @brief   Form to define specifics spectro options
 * @author  Benjamin Renard
 * @version $Id: PlotSpectroForm.js benjamin $
 */

Ext.define('amdaPlotComp.PlotSpectroForm', {
	extend: 'amdaPlotComp.PlotStandardForm',

	requires: [
		'amdaUI.ParamArgumentsUI'
	],
	setObject: function (object) {
		this.data = object.data;
		this.object = object.get('param-drawing-object');

		this.loadRecord(this.object);
	},

	getValuesRangeItems: function () {
		return [
			this.addStandardFloat2('spectro-value-min', 'Min value', -Number.MAX_VALUE, Number.MAX_VALUE, true),
			this.addStandardFloat2('spectro-value-max', 'Max value', -Number.MAX_VALUE, Number.MAX_VALUE, true)
		];
	},
	getFilteringItems: function () {
		return [
			this.addStandardCombo('filtering-level', 'Level', amdaPlotObj.PlotObjectConfig.availableFilteringLevel)
		];
	},


	populateComboBoxValue: (ref, index) => {
		const valueType = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key).getValue();

		if (amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[valueType] === undefined) {
			console.warn("Undefined value : ", valueType);
			return;
		}

		const newValue = amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[valueType];

		const comboBoxV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key);
		const textInputV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputkey);

		comboBoxV.setValue(null);
		comboBoxV.setVisible(false);

		textInputV.setVisible(false);
		textInputV.setValue(null);

		if (newValue === amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values.bychannel) {
			if (ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index].variable)
				return;

			comboBoxV.setVisible(true);

			const channelsData = ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index]
			[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableChannels];

			const keyTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.key;
			const valueTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.value;

			const newDataForStore = [];
			//Loop through the channels
			for (channelIndex in channelsData) {
				const channelData = channelsData[channelIndex];
				let item = {};
				item[keyTemp] = channelIndex;
				item[valueTemp] = channelIndex + " : [" + channelData.min + " , " + channelData.max + "]";
				newDataForStore.push(item);
			}

			//Update the label of the field
			comboBoxV.setFieldLabel(ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index]["name"]
				+ " (" + ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][index]["units"] + ") ");

			comboBoxV.store.loadData(newDataForStore);
		}
		else if (newValue === amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values.fixedvalue) {
			textInputV.setVisible(true);
		}
		else {
			console.warn("Unknown value : ", valueType, newValue);
		}
	},


	populateComboBoxDim: (ref) => {
		const comboBoxDim = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);
		comboBoxDim.setValue(null);

		const keyTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.key;
		const valueTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.value;

		const newDataForStore = [];
		for (indexTable in ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName]) {
			const table = ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName][indexTable];
			let item = {};
			item[keyTemp] = indexTable;
			item[valueTemp] = table[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableRelatedDim];
			newDataForStore.push(item);
		}

		//Set the new store
		comboBoxDim.store.loadData(newDataForStore);
	},


	addTextInput: (ref) => {
		return ref.addStandardFloat2(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputkey,
			amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputlabel, 0
			, Number.MAX_VALUE, true, true, (name, newValue, oldValue) => {
				if (oldValue !== newValue) {
					ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
						newValue);
				}
			});
	},

	resetValues: (ref) => {
		const comboBoxV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key);
		comboBoxV.setVisible(false);
		comboBoxV.setValue(null);

		const textInputV = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.textinputkey);
		textInputV.setVisible(false);
		textInputV.setValue(null);
	},

	emptyComboBoxDim: (ref) => {
		const comboBoxDim = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);
		comboBoxDim.setValue(null);
		comboBoxDim.store.loadData([]);

		ref.resetValues(ref);
	},

	/**
	 * Add the first comboBox (Background Substraction type)
	 * @param {*} ref ref to this class
	 * @returns StandardCombo
	 */
	addComboBoxBgSType: (ref) => {
		const data = [];
		for (value in amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values) {
			const keyTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.key;
			const valueTemp = amdaPlotObj.PlotObjectConfig.fieldComboBox.value;
			let item = {};
			item[keyTemp] = value;
			item[valueTemp] = amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[value];
			data.push(item);
		}

		const comboBoxType = ref.addStandardCombo(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key,
			amdaPlotObj.PlotObjectConfig.bgSubstraction.type.label, data,
			(name, newKey, oldKey) => {
				if (newKey !== oldKey) {

					if (newKey === null || amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[newKey] === undefined) {
						ref.emptyComboBoxDim(ref);
						return;
					}

					ref.populateComboBoxDim(ref);

					const comboBoxDim = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);

					if (ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName].length === 1) {
						comboBoxDim.setValue(0);
						comboBoxDim.setVisible(false);
						return;
					}



					if (amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values.fixedvalue ===
						amdaPlotObj.PlotObjectConfig.bgSubstraction.type.values[newKey]) {
						comboBoxDim.setValue(0);
						comboBoxDim.setVisible(false);
					} else {
						comboBoxDim.setVisible(true);
					}


				}
			});

		return comboBoxType;
	},

	/**
	 * Add the second comboBox (Background Substraction value)
	 * @param {*} ref ref to this class
	 * @returns StandardCombo
	 */
	addComboBoxBgSValue: (ref) => {
		const comboBoxValue = ref.addStandardCombo(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
			"", [],
			(name, newKey, oldKey) => {
				if (newKey !== oldKey) {
					ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.key,
						newKey);
					console.log(newKey);
				}
			});

		return comboBoxValue;
	},

	addComboBoxBgSDim: (ref) => {
		const comboBoxDim = ref.addStandardCombo(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey,
			amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimlabel, [],
			(name, newKey, oldKey) => {
				if (newKey !== null && newKey !== undefined)
					ref.populateComboBoxValue(ref, newKey);
				else if (newKey === null) {
					ref.resetValues(ref);
				}
				ref.object.set(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey,
					newKey);

				console.log(newKey);
			});

		return comboBoxDim;
	},

	/**
	 * Add Background Substraction field which contains the two comboBoxes
	 * @returns StandardFieldSet
	 */
	getBgSubstractionItems: function () {
		return [
			this.addComboBoxBgSType(this),
			this.addComboBoxBgSDim(this),
			this.addComboBoxBgSValue(this),
			this.addTextInput(this)
		];
	},

	getFormItems: function () {
		const ref = this;
		const field = this.addStandardFieldSet(amdaPlotObj.PlotObjectConfig.bgSubstraction.name,
			amdaPlotObj.PlotObjectConfig.bgSubstraction.name, this.getBgSubstractionItems(),
			function (name, newKey, oldKey) {
				if (newKey !== oldKey) {
					const comboBoxType = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.type.key);
					comboBoxType.setValue(null);

					const nbDims = ref.data[amdaPlotObj.PlotObjectConfig.bgSubstraction.tableName].length
					if (nbDims === 1) {
						const comboBoxDim = ref.getForm().findField(amdaPlotObj.PlotObjectConfig.bgSubstraction.value.dimkey);
						comboBoxDim.setValue(0);
						comboBoxDim.setVisible(false);
					}
				}
			});

		return [
			this.addStandardCombo('spectro-resolution', 'Points per plot', amdaPlotObj.PlotObjectConfig.availableResolutions, function (name, value, oldValue) {
				ref.object.set('spectro-resolution', value);
			}),
			this.addStandardCombo('spectro-yaxis', 'Y axis', amdaPlotObj.PlotObjectConfig.availableYAxes, function (name, value, oldValue) {
				ref.object.set('spectro-yaxis', value);
				ref.crtTree.refresh();
			}),
			myDesktopApp.addAmdaInfo('MinMaxThreshold', 'vertical-align:bottom'),
			this.addStandardFieldSet('Min/Max thresholds', '', this.getValuesRangeItems()),
			this.addStandardCheck('spectro-log0-as-min', 'Show 0 values as Min Values in log scale', function (name, value, oldValue) {
				ref.object.set('spectro-log0-as-min', value);
			}),
			this.addStandardCombo('spectro-normalization', 'Normalization', amdaPlotObj.PlotObjectConfig.availableSpectroNormalization, function (name, value, oldValue) {
				if (ref.object.get('spectro-normalization') != value) {
					ref.object.set('spectro-normalization', value);
				}
			}),
			this.addStandardFieldSet('Spike Filtering ( ! Experimental ! )', 'filtering-activated', this.getFilteringItems()),
			field
		];
	}
});