// setup namespace
Zymonic.FieldFillCalculation = {};

// base form format
// don't do anything here, makes it easy to establish inheritance
Zymonic.FieldFillCalculation.FieldFillCalculation = function() {};

// init function
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.init = function(args) {
	for (var key in args) {
		this[key] = args[key];
	}
	
	if (this.ident != "") {
		Zymonic.add_to_lookup('FieldFillCalculation', this.ident, this);
	}
	
	if (this.parent_field) {
		this.parent_field.addFieldFillCalculation(this);
		
		// do this after a small timeout to allow everything load up
		// had tried to use event handlers for this but ended up being too complex
		var ffc = this;
		setTimeout(function(){ ffc.bindHandlers(); }, 1);
	}
};

// binds all handlers needed to trigger this field fill
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.bindHandlers = function() {
	if (this.parent_field) {
		// add change handlers to all dependent fields to trigger the checking of value on parent field
		// checking value on parent field will trigger this field fill calculation
		var self = this;
		var dependent_fields = this.getDependentFields();
		for (var i=0; i<dependent_fields.length; ++i) {
			var dependent_field_ident = dependent_fields[i];
			var dependent_field = getZymonicField(dependent_field_ident);
			
			// if field is already loaded then attach the handler
			if (dependent_field) {
				dependent_field.onChange(
					function() {
						self.parent_field.getValue.call(self.parent_field);
					},
					true,
					1000,
					self.ident+"bind_handlers"
				);
			} else {
				// otherwise attched the change handler when the field is loaded
				Zymonic.Utils.attach_event(
					document, 'loaded_'+dependent_field_ident, "ffc_dependent_field_"+this.ident,
					function(event, field) {
						field.onChange(
							function() {
								self.parent_field.getValue.call(self.parent_field);
							},
							true,
							250,
							self.ident+"bind_handlers"
						);
					},
					true
				);
			}
		}
		
		// add recalculate button handlers
		for (var i=0; i<this.recalculate_buttons.length; ++i) {
			this.bindRecalculateButtonHandler(this.recalculate_buttons[i]);
		}
		
		// add a default handler to parent field to detect user input
		// TODO: this should be refactored to use attach/trigger_event eventually
		// not done now as its triggered by the old, pre-OO, JS code which is still in use
		if (this.use_unless_user_value) {
			$(Zymonic).bind(
				this.parent_field.getIdent() + 'defaultHandler',
				{},
				function(event, origEvent) {
					self.user_changed_value = true;
				}
			);
		}
	}
};

// callback for when a recalculate button is clicked
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.bindRecalculateButtonHandler = function(recalculate_button) {
	
	
	// reload the parent field, with param set for the recalculate
	var dependent_fields = this.getDependentFields();
	var self = this;
	Zymonic.Utils.attach_event(
		$("#"+recalculate_button.ident),
		"click",
		recalculate_button.ident,
		function(event) {
			// add dependent fields as extra params so they are available for the reload
			var params = [recalculate_button.ident+"=true"];
			for (var i=0; i<dependent_fields.length; ++i) {
				var dependent_field_ident = dependent_fields[i];
				var dependent_field = getZymonicField(dependent_field_ident);
				if (dependent_field) {
					self.parent_field.addExtraFieldParam(dependent_field.zname, dependent_field.ident);
					self.parent_field.addFieldLookupParam(dependent_field.ident, dependent_field.ident);
				}
			}
			
			// on success set the field value
			self.parent_field.reloadInPlace.call(
				self.parent_field, params,
				true,              false,
				false,             false,
				false,             null,
				function() {
					// the value is already set, mark it as changed on the new field object
					var field = getZymonicField(self.parent_field.ident);
					if (field) {
						field.setValueAsChanged(field.getValue(), false, true);
					}
				}
			);
		}
	);
};

// gets all the dependent field idents on this field fill
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.getDependentFields = function() {
	var dependent_fields = {};
	
	for (var i=0; i<this.dependent_field_idents.length; ++i) {
		dependent_fields[this.dependent_field_idents[i]] = true;
	}
	
	if ( this.from_other ) {
		for (var i=0; i<this.from_other.fields.length; ++i) {
			if (this.parent_field && this.from_other.fields[i].zname == this.parent_field.zname) {
				// can't be dependent on ourself
			} else {
				dependent_fields[this.from_other.fields[i].ident] = true;
			}
		}
	}
	
	if (this.calculation) {
		for (var i=0; i<this.calculation.fields.length; ++i) {
			if (this.parent_field && this.calculation.fields[i].zname == this.parent_field.zname) {
				// can't be dependent on ourself
			} else {
				dependent_fields[this.calculation.fields[i].ident] = true;
			}
		}
	}
	
	return Object.keys(dependent_fields);
};

// get preferred value
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.getPreffered = function() {
	return this.preffered;
};

// get allow empty value
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.allowEmpty = function() {
	return this.allow_empty;
};

// get the value for this field fill
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.getValue = function(value) {
	
	if (!this.needsRecalculation()) {
		return value;
	}
	
	// use flag to ensure we don't recurse through this
	// doesn't matter what we return as this is runnign elsewhere
	// so when it finished it will set a new value
	if (this.getting_value) {
		return value;
	}
	this.getting_value = true;
	
	// check conditions
	if (this.conditions) {
		var conditions_result = check_conditions(this.conditions, this.condition_combination);
		if (!conditions_result.condition_passed)
		{
			// condition failed, return empty value
			this.getting_value = false;
			return null;
		}
	}
	
	// this is taken from Zymonic::FieldFillCalculation::value
	var return_value = null;
	if (this.use_unless_user_value) {

		// check for a value and the flag to say user changed the value
		if ( ( value || value == "0" ) && this.user_changed_value ) {
			return_value = value;
		} else {
			return_value = this.fillValue(value);
		}
	} else if ( this.cache_in_table && this.view_only ) {
		// stored in DB when the first created or when result changes
		if ( this.parent_field && this.parent_field.original_value && this.parent_field.original_value == value ) {
			return_value = value;
		} else {
			var fill_value = this.fillValue(value);
			if ( ( value || value == "0" ) && value == fill_value ) {
				return_value = value;
			} else {
				return_value = fill_value;
			}
		}
	} else if ( !this.cache_in_table && this.view_only ) {
		// calculated whenever the field is displayed, but not stored in db
		if ( value || value == "0" ) {
			return_value = value;
		} else {
			return_value = this.fillValue(value);
		}
	} else if ( !this.cache_in_table && !this.view_only ) {
		// calculated when first created or user requested
		// TODO: add why for user to trigger recalculation
		if ( ( value || value == "0" ) && !this.recalculate ) {
			return_value = value;
		} else {
			return_value = this.fillValue(value);
		}
	} else if ( this.cache_in_table && !this.view_only ) {
		// always use fiell value
		return_value = this.fillValue(value);
	}
	
	if (this.js_field_fill_format) {
		var value_to_transform = return_value;
		var transformed_value = eval(this.js_field_fill_format);
		return_value = transformed_value;
	}
	
	this.last_calculated_timestamp = Zymonic.Utils.current_timestamp();
	this.getting_value = false;
	
	return return_value;
};

// whether this field fill needs recalculating, depending when it was last run
// and whether dependent fields have changed since then
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.needsRecalculation = function(value) {
	var needs_running = false;
	
	// put into its own function so when other fill values are implemented
	// they can be added here, i.e. ones without dependent fields, e.g. system options
	
	// currently nothing to check in the base class, so always recalculate
	needs_running = true;
	
	return needs_running;
};

// get the specific value for this field fill
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.fillValue = function(value) {
	// taken from Zymonic::FieldFillCalculation::fill_value
	if ( "static_value" in this ) {
		return this.static_value;
	} else if ( this.from_other ) {
		var values = [];
		for (var i=0; i<this.from_other.fields.length; ++i) {
			var field = getZymonicField(this.from_other.fields[i].ident);

			var return_value = "";
			if (this.from_other.prefix_with_name) {
				return_value += this.from_other.fields[i].display_name + ": ";
			}
			
			if (this.use_display_value) {
				var display_value = field.getDisplayValue();
				return_value += ( display_value != null ? display_value : "" );
			}
			else
			{
				var display_value = field.getValue();
				return_value += ( display_value != null ? display_value : "" );
			}
			
			values.push(return_value);
		}
		
		if (this.multiple_value_fill) {
			return values;
		} else {
			return values.join(this.separator);
		}
	} else if ( this.calculation ) {
		return this.getCalculationValue(value)
	}
	// TODO: from param and system option when implemented
};

// get the calculation value for this field fill
Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.getCalculationValue = function(value) {
	// taken from Zymonic::FieldFillCalculation::calculation
	
	if (!this.calculation || !this.calculation.string) {
		return null;
	}
	
	// lookup all the values of fields
	var znames = {};
	for (var i=0; i<this.calculation.fields.length; ++i) {
        var field_value;
		if (this.parent_field && this.calculation.fields[i].zname == this.parent_field.zname) {
			field_value = ( value ? value : 0 );
		} else {
			var field = getZymonicField(this.calculation.fields[i].ident);
			field_value = field.getValue(true);
			// A bit hacky, but anything formatted as a time should be converted
			// to a number of hours that can be used in numeric calculations
			if(field_value && (matches = field_value.match(/^(\d+):(\d+)$/))) {
				field_value = (1*matches[1]) + (matches[2]/60);
			} else if(field_value && (matches = field_value.match(/^(\d+):(\d+):(\d+)$/))) {
				field_value = (1*matches[1]) + (matches[2]/60) + (matches[3]/3600);
			}
		}
        // known issue where numbers with leading zeroes like "010" are treated as octal values instead of decimal, using Number() to convert them handles any leading zeroes automatically
        // if number conversion is NaN, leave it as a string
        if (isNaN(Number(field_value)) == false) {
            field_value = Number(field_value)
        }
        znames[this.calculation.fields[i].zname] = ( field_value ? field_value : 0 )
	}
	
	// copy the values of the fields into the calculation string
	// values are of the format $zname{ZNAME} so can eval via hash in perl
	// so we just replace those instances with the values
	var calc_string = this.calculation.string;
	for (var zname in znames) {
		// handle dot notation by checking for any replacements with zname after a .
		calc_string = calc_string.replace(
			new RegExp("\\$znames\\{([^{}]*\\.)?" + zname + "\\}", "g"),
			znames[zname]
		);
	}
	
	var result = String(eval(calc_string));
	
	// TODO: do we need to round to max field length as is done in Zymonic::FieldFillCalculation::calculation
	return result;
};