// subform field fill calculation object
Zymonic.FieldFillCalculation.SubForm = function() {};

// do the inheritance
Zymonic.FieldFillCalculation.SubForm.prototype = new Zymonic.FieldFillCalculation.FieldFillCalculation();
Zymonic.FieldFillCalculation.SubForm.prototype.constructor = this;

//binds all handlers needed to trigger this field fill
Zymonic.FieldFillCalculation.SubForm.prototype.bindHandlers = function() {
	
	// call super to set the handlers
	Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.bindHandlers.call(this);
	
	// if there is a form, add handlers to recalculate handlers if any records on that form change
	var form = this.getForm();
	if (form) {
		// catch record changed event on that form to redo handlers
		// as changed records may have changed fields
		var self = this;
		form.onRecordsChange(
			function(event, form, extras) {
				self.bindHandlers.call(self);
				if (extras && extras.recalculation_needed && self.parent_field) {
					self.parent_field.getValue();
				}
			},
			"subform_ffc_records_changed_handlers_"+this.ident
		);
		
	}
};

//gets all the dependent field idents on this field fill
Zymonic.FieldFillCalculation.SubForm.prototype.getDependentFields = function() {
	var dependent_fields_list = Zymonic.FieldFillCalculation.FieldFillCalculation.prototype.getDependentFields.call(this);
	
	var dependent_fields = {};
	for (var i=0; i<dependent_fields_list.length; ++i) {
		dependent_fields[dependent_fields_list[i]] = true;
	}
	
	// add lookup fields from all the form records
	if (this.aggregation) {
		var form = this.getForm();
		if (form) {
			var records = form.getRecords(true);
			for (var i=0; i<records.length; ++i) {
				for (var j=0; j<records[i].fields.length; ++j) {
					for (var k=0; k<this.aggregation.fields.length; ++k) {
						if (records[i].fields[j].zname == this.aggregation.fields[k]) {
							dependent_fields[records[i].fields[j].ident] = true;
						}
					}
				}
			}
		}
	}

	return Object.keys(dependent_fields);
};

// gets the form object for the subform to use for this
Zymonic.FieldFillCalculation.SubForm.prototype.getForm = function() {
	return Zymonic.lookup_object('Form', this.form_ident);
};

// calculate the subform field fill
Zymonic.FieldFillCalculation.SubForm.prototype.fillValue = function(value) {
	
	if (!this.aggregation || !this.aggregation.aggregation) {
		return null;
	}

	// taken from Zymonic::FieldFillCalculation::SubForm::fill_value
	var form = this.getForm();
	if (!form) {
		return null;
	}
	var form_records = form.getRecords(true);
	var records = [];
	for (var i=0; i<form_records.length; ++i) {
		if ( !form_records[i].is_placeholder ) {
			records.push(form_records[i]);
		}
	}
	
	var final_agg_value = null;
	if (this.aggregation.aggregation == "sum") {
		final_agg_value = 0;
		for (var i=0; i<records.length; ++i) {
			final_agg_value += parseFloat(this.record_aggregation_value(records[i]));
		}
	} else if (this.aggregation.aggregation == "count") {
		final_agg_value = 0;
		var values_seen = {};
		for (var i=0; i<records.length; ++i) {
			var value = this.record_aggregation_value(records[i]);
			if ((value != undefined) && !(value in values_seen)) {
				values_seen[value] = true;
				++final_agg_value;
			}
		}
	} else if (this.aggregation.aggregation == "average") {
		final_agg_value = 0;
		var total = 0;
		var count = 0;
		var values_seen = {};
		for (var i=0; i<records.length; ++i) {
			var value = this.record_aggregation_value(records[i]);
			var count = (
				  this.aggregation.other_expression
				? this.record_aggregation_value(records[i], this.aggregation.other_expression)
				: value
			);
			if ( value != null ) {
				total += parseFloat(value);
			}
			if ( count != null && !(count in values_seen) ) {
				values_seen[count] = true;
				++count;
			}
		}
		final_agg_value = ( count == 0 ? 0 : ( total / count ) );
	} else if (this.aggregation.aggregation == "first") {
		if (records && records[0]) {
			final_agg_value = this.record_aggregation_value(records[0]);
		}
	} else if (this.aggregation.aggregation == "last") {
		if (records && records[records.length-1]) {
			final_agg_value = this.record_aggregation_value(records[records.length-1]);
		}
	} else if (this.aggregation.aggregation == "concatenate") {
		var values = [];
		for (var i=0; i<records.length; ++i) {
			var value = this.record_aggregation_value(records[i]);
			if (value != null) {
				values.push(value);
			}
		}
		final_agg_value = values.join(this.aggregation.other_expression || ',');
	} else {
		Zymonic.log_error("FieldFillCalculation "+this.zname+": unknown aggregation "+this.aggregation.aggregation);
	}
	
	return String(final_agg_value);
};

// calculate aggregation value for a given record
Zymonic.FieldFillCalculation.SubForm.prototype.record_aggregation_value = function(record, expression) {
	// taken from Zymonic::FieldFillCalculation::SubForm::record_aggregation_value
	
	// populate field values into expression
	var calc_expression = expression || this.aggregation.expression;
	for (var i=0; i<record.fields.length; ++i) {
		for (var j=0; j<this.aggregation.fields.length; ++j) {
			if (record.fields[i].zname == this.aggregation.fields[j]) {
				var field_value = record.fields[i].getValue();
				
				// escape any ' to allow the string to be eval'ed
				field_value = field_value.toString().replace("'", "\\'");
				
				// if this is a numeric value, remove and thousands separators
				// so it can be parsed as a number
				if (/^[\d\,\.]+$/.test(field_value)) {
					field_value = field_value.toString().replace(",", "");
				}

				calc_expression = calc_expression.replace(
					new RegExp("\\[" + record.fields[i].zname + "\\]", "g"),
					"'" + field_value + "'"
				);
			}
		}
	}
	
	// replace and ZZNULLs
	calc_expression = calc_expression.replace("ZZNULL", "null");
	
	var result = eval(calc_expression);
	return result;
}