// grouped form format object
Zymonic.FormFormat.Grouped = function() {};

// do the inheritance
Zymonic.FormFormat.Grouped.prototype = new Zymonic.FormFormat.FormFormat();
Zymonic.FormFormat.Grouped.prototype.constructor = this;

// setters
Zymonic.FormFormat.Grouped.prototype.addGroupByField = function(group_by_field) {
	if (!this.group_by_fields) {
		this.group_by_fields = [];
	}
	
	// keep it sorted
	this.group_by_fields.push(group_by_field);
	this.group_by_fields.sort()
};

Zymonic.FormFormat.Grouped.prototype.setShowHideConditions = function(conditions, condition_combination, show_message, hide_message) {
	this.show_hide_conditions            = conditions;
	this.show_hide_condition_combination = condition_combination;
	this.show_message                    = show_message;
	this.hide_message                    = hide_message;
	
	// lookup unique condition lookup fields
	this.show_hide_condition_lookup_fields = [];
	var unique_condition_fields = {};
	for (var i=0; i<this.show_hide_conditions.length; ++i) {
		var condition_fields = this.show_hide_conditions[i].getLookupFields();
		for (var j=0; j<condition_fields.length; ++j) {
			unique_condition_fields[condition_fields[j]] = 1;
		}
	}
	for (var field_zname in unique_condition_fields) {
		this.show_hide_condition_lookup_fields.push(field_zname);
	}
};

Zymonic.FormFormat.Grouped.prototype.addAggregation = function(display_field_zname, type, expression, expression_default, expression_eval, other_expression, other_expression_default, other_expression_eval, expression_fields) {
	if (!this.aggregations) {
		this.aggregations = [];
		this.existing_aggregations = {};
	}
	
	var aggregation = {
		display_field_zname:      display_field_zname,
		type:                     type,
		expression:               expression,
		expression_default:       expression_default,
		expression_eval:          expression_eval,
		other_expression:         other_expression,
		other_expression_default: other_expression_default,
		other_expression_eval:    other_expression_eval,
		expression_fields:        expression_fields,
		group_display_field:      {},
	};

	
	// add if unique, otherwise overwrite existing
	if (display_field_zname in this.existing_aggregations) {
		// overwrite in list
		var existing_index = this.existing_aggregations[display_field_zname];
		this.aggregations[existing_index] = aggregation;
	} else {
		this.aggregations.push(aggregation);
		
		// track position in list
		this.existing_aggregations[display_field_zname] = this.aggregations.length-1;
	}
};

Zymonic.FormFormat.Grouped.prototype.addFieldFill = function(field_zname, expression, expression_default, expression_eval, expression_fields, conditions, condition_combination) {
	if (!this.field_fills) {
		this.field_fills = [];
		this.existing_field_fills = {};
	}
	
	var field_fill = {
		field_zname:             field_zname,
		expression:              expression,
		expression_default:      expression_default,
		expression_eval:         expression_eval,
		expression_fields:       expression_fields,
		conditions:              conditions,
		condition_combination:   condition_combination,
		condition_lookup_fields: [],
	};
	
	// lookup unique condition lookup fields
	var unique_condition_fields = {};
	for (var i=0; i<field_fill.conditions.length; ++i) {
		var condition_fields = field_fill.conditions[i].getLookupFields();
		for (var j=0; j<condition_fields.length; ++j) {
			unique_condition_fields[condition_fields[j]] = 1;
		}
	}
	for (var field_zname in unique_condition_fields) {
		field_fill.condition_lookup_fields.push(field_zname);
	}
	
	// add if unique, otherwise overwrite existing
	if (field_zname in this.existing_field_fills) {
		// overwrite in list
		var existing_index = this.existing_field_fills[field_zname];
		this.field_fills[existing_index] = field_fill;
	} else {
		this.field_fills.push(field_fill);
		
		// track position in list
		this.existing_field_fills[field_zname] = this.field_fills.length-1;
	}
};

// initial the GUI for grouped form formatting
Zymonic.FormFormat.Grouped.prototype.initGUI = function() {
	// clear all caches so we init GUI from scratch and not using
	// any previously cached data which may now be incorrect
	this.clearCaches();
	
	var unblock = this.blockFormAllRecords();

	var groups = this.assembleGroups();
	for (var group_ident in groups) {
		var group_div = this.buildGroupDiv(groups[group_ident]);
		this.getFormAllRecordsContainerDiv().append(group_div);
	}
	
	// if horizontal then remove the original records table, since all
	// records will have been moved above into the per group records
	if (this.isFormHorizontal()) {
		// emptying this first as done in moveDisplayField, is slower
		this.getFormHorizontalTable().remove();
	}
	
	// finally calculate the aggregation fields for all groups
	// do this here so all fields are now on screen so jquery lookups
	// can find the correct fields
	for (var group_ident in groups) {
		for (var i=0; i<this.aggregations.length; ++i) {
			this.calculateAggregation(this.aggregations[i], groups[group_ident]);
		}
		
		// after aggregation values are set, setup show/hide conditions
		this.initShowHideConditions(groups[group_ident]);
		
		// setup field fills
		this.initFieldFills(groups[group_ident]);
	}

	unblock();
};

// setup field fill condition triggers and run it the first time
Zymonic.FormFormat.Grouped.prototype.initFieldFills = function(group) {
	if (this.field_fills && this.field_fills.length > 0) {
		for (var i=0; i<this.field_fills.length; ++i) {
			var field_fill = this.field_fills[i];

			// get all the fields and add change triggers to each
			for (var j=0; j<field_fill.condition_lookup_fields.length; ++j) {
				this.initFieldFillConditionField(group, field_fill, field_fill.condition_lookup_fields[j]);
			}
			
			// trigger the field fill now to set default value
			this.updateFieldFill(group, field_fill);
		}
	}
};

//setup field fill condition triggers and run it the first time
Zymonic.FormFormat.Grouped.prototype.initFieldFillConditionField = function(group, field_fill, field_zname) {
	var display_field = group.display_fields[field_zname];
	if (display_field) {
		var grouped_ff = this;
		var df_input_elements = display_field.input_elements();
		df_input_elements.change(function() { grouped_ff.updateFieldFill(group, field_fill); });
		df_input_elements.keyup( function() { grouped_ff.updateFieldFill(group, field_fill); });
		Zymonic.Utils.attach_event( df_input_elements, 'click', this.ident, function() { grouped_ff.updateFieldFill(group, field_fill); });
	}
};

// check the field fill conditions and fill any field accordingly accordingly
Zymonic.FormFormat.Grouped.prototype.updateFieldFill = function(group, field_fill) {
	var result = null;
	if (field_fill.conditions && field_fill.conditions.length != 0) {
		var display_field_values = this.getGroupDisplayFieldValues(group, field_fill.condition_lookup_fields);
		result = Zymonic.Condition.check_conditions(field_fill.conditions, field_fill.condition_combination, display_field_values);
	}
	if (result && result.condition_passed) {
		// fill the field with the expression for each record in the group
		for (var i=0; i<group.records.length; ++i) {
			var record = group.records[i];
			var expression_value = this.calculateExpressionValue(field_fill.expression, field_fill.expression_default, field_fill.expression_eval, field_fill.expression_fields, record);
			var field = getZymonicRecordField(record.record_ident, field_fill.field_zname);
			field.setValue(expression_value);
		}
	}
};

// setup show/hide condition triggers and run it the first time
Zymonic.FormFormat.Grouped.prototype.initShowHideConditions = function(group) {
	if (this.show_hide_conditions && this.show_hide_conditions.length != 0) {
		
		// add change triggers to each fields
		for (var i=0; i<this.show_hide_condition_lookup_fields.length; ++i) {
			this.initShowHideConditionField(group, this.show_hide_condition_lookup_fields[i]);
		}
		
		// run the check to show/hide by default
		this.checkShowHideConditions(group);
	}
};

//setup field fill condition triggers and run it the first time
Zymonic.FormFormat.Grouped.prototype.initShowHideConditionField = function(group, field_zname) {
	var display_field = group.display_fields[field_zname];
	if (display_field) {
		var grouped_ff = this;
		var df_input_elements = display_field.input_elements();
		df_input_elements.change(function() { grouped_ff.checkShowHideConditions(group); });
		df_input_elements.keyup( function() { grouped_ff.checkShowHideConditions(group); });
		Zymonic.Utils.attach_event( df_input_elements, 'click', this.ident, function() { grouped_ff.checkShowHideConditions(group); });
	}
};

// returns hash of group display field znames mapping to their current values
Zymonic.FormFormat.Grouped.prototype.getGroupDisplayFieldValues = function(group, fields) {
	// only check for values which are group display fields
	var display_field_values = {};
	for (var i=0; i<fields.length; ++i) {
		var zname = fields[i];
		if (group.display_fields[zname]) {
			display_field_values[zname] = group.display_fields[zname].getValue();
		}
	}
	return display_field_values;
};

// check the show_hide condition and show/hide the record accordingly
Zymonic.FormFormat.Grouped.prototype.checkShowHideConditions = function(group) {
	var result = null;
	if (this.show_hide_conditions) {
		var display_field_values = this.getGroupDisplayFieldValues(group, this.show_hide_condition_lookup_fields);
		result = Zymonic.Condition.check_conditions(this.show_hide_conditions, this.show_hide_condition_combination, display_field_values);
	}
	if (result && result.condition_passed) {
		group.records_container.show();
		group.show_hide_button.html(this.hide_text);
		if (this.show_message) {
			group.message_container.text(this.show_message);
		} else {
			group.message_container.text('');
		}
	} else {
		group.records_container.hide();
		group.show_hide_button.html(this.show_text);
		if (this.hide_message) {
			group.message_container.text(this.hide_message);
		} else {
			group.message_container.text('');
		}
	}
};

// parse records from parent forms into groups
Zymonic.FormFormat.Grouped.prototype.assembleGroups = function() {
	
	// build groups for forms records
	var groups = {};
	var records = this.getFormRecords();
	for (var i=0; i<records.length; ++i) {
		var group_ident = this.getGroupIdent(records[i]);
		if (!groups[group_ident]) {
			groups[group_ident] = {
				ident:   group_ident,
				records: [],
			}
		}
		groups[group_ident].records.push(records[i]);
	}
	
	return groups;
};

// parse records from parent forms into groups
Zymonic.FormFormat.Grouped.prototype.getGroupIdent = function(record) {
	
	// build ident from record values of the group by fields
	var group_ident = '';
	for (var i=0; i<this.group_by_fields.length; ++i) {
		var zname = this.group_by_fields[i];
		var field = getZymonicRecordField(record.record_ident, zname);
		if (i != 0) {
			group_ident += "_";
		}
		group_ident += field.getValue();
	}
	
	return group_ident;
};

// builds a div GUI for a group
Zymonic.FormFormat.Grouped.prototype.buildGroupDiv = function(group) {
	// TODO: can we setup HTML template in the XSL for this?
	var div = $("<div />");
	div.attr("id", this.ident+"_"+group.ident);
	div.addClass("GroupedFormFormatGroup");
	group.container = div;
	
	var display_fields_container = $("<div />");
	display_fields_container.addClass("GroupedFormFormatGroupDisplayFields");
	div.append(display_fields_container);
	
	var message_container = $("<p />");
	message_container.addClass("GroupedFormFormatGroupMessage");
	div.append(message_container);
	
	var records_container = $("<div />");
	records_container.addClass("GroupedFormFormatGroupRecords");
	div.append(records_container);
	
	// if horizontal form then create table to put the display fields/records in
	if (this.isFormHorizontal()) {
		var records_table = $("<table />");
		records_table.addClass("HorizontalFormTable");
		var records_header_row = this.buildRecordsDivHeaders();
		records_table.append(records_header_row);
		records_container.append(records_table);
		records_container = records_table;

		// TODO: may only want the header row for the first group
		var display_fields_table = $("<table />");
		display_fields_table.addClass("HorizontalFormTable");
		var display_fields_header_row = this.buildDisplayFieldsDivHeaders(); 
		display_fields_table.append(display_fields_header_row);
		display_fields_container.append(display_fields_table);
		display_fields_container = display_fields_table;
	}

	// move display fields for first record, then move all other records into the container
	for (var i=0; i<group.records.length; ++i) {
		if (i==0) {
			group.display_fields = this.moveGroupDisplayFields(group, display_fields_container, group.records[i]);
		} else {
			this.removeGroupDisplayFields(group, group.records[i]);
		}
		this.moveGroupRecord(records_container, group.records[i]);
	}
	
	// add show hide button to the display
	this.addShowHideButton(group, display_fields_container, records_container);
	
	// set containers on group for easy access
	group.records_container        = records_container;
	group.display_fields_container = display_fields_container;
	group.message_container        = message_container;

	return div;
};

// moves record from record into div
Zymonic.FormFormat.Grouped.prototype.moveGroupRecord = function(container, record) {
	var record_container = this.getFormSingleRecordsContainerDiv(record.record_ident);
	Zymonic.Utils.moveElement(record_container, container);
};

// removes display fields from record
Zymonic.FormFormat.Grouped.prototype.removeGroupDisplayFields = function(group, record) {
	for (var i=0; i<this.aggregations.length; ++i) {
		var aggregation = this.aggregations[i];
		this.removeDisplayField(aggregation.display_field_zname, record);
	}
};

// removes a record field
Zymonic.FormFormat.Grouped.prototype.removeDisplayField = function(zname, record) {

	// remove field from other record (removing table cell for horizontal forms)
	var field = getZymonicRecordField(record.record_ident, zname);
	var field_container = field.container_div();
	if (this.isFormHorizontal()) {
		field_container = field_container.parent("td");
	}
	
	// do this before remove otherwise remove is slow as it removes all children
	// we don't need it to be too careful so just clear the whole thing then remove
	// also, this was quicker than doing .empty()
	field_container.html(""); 
	field_container.remove();
};

// moves display fields from record into div
Zymonic.FormFormat.Grouped.prototype.moveGroupDisplayFields = function(group, container, record) {
	// if horizontal form then create table row to put fields in
	if (this.isFormHorizontal()) {
		var row = $("<tr />");
		row.addClass("record");
		container.append(row);
		container = row;
	}
	
	var display_fields = {};	
	for (var i=0; i<this.aggregations.length; ++i) {
		var aggregation = this.aggregations[i];
		var field = this.moveDisplayField(aggregation.display_field_zname, record, container);
		aggregation.group_display_field[group.ident] = field;
		display_fields[aggregation.display_field_zname] = field;
	}
	
	return display_fields;
};

// removes a record field and moves to container if flag set
Zymonic.FormFormat.Grouped.prototype.moveDisplayField = function(zname, record, container) {
	var field = getZymonicRecordField(record.record_ident, zname);

	// get container field (table cell for horizontal forms)
	var field_container = field.container_div();
	field_container.addClass("ZymonicClientSideField"); // set class to not send this value back to server
	if (this.isFormHorizontal()) {
		field_container = field_container.parent("td");
	}
	
	// copy field div into container if present
	Zymonic.Utils.moveElement(field_container, container);
	
	// return field moved
	return field;
};

// builds a table row containing headers for the records
//only for horizontal forms
Zymonic.FormFormat.Grouped.prototype.buildRecordsDivHeaders = function() {
	// clone the original and remove the display fields
	var header_row = this.getFormHorizontalTable().find(".HorizontalFormTableHeader").parent("tr").clone();
	
	// remove any display field labels
	for (var i=0; i<this.aggregations.length; ++i) {
		var aggregation = this.aggregations[i];

		// emptying this first as done in moveDisplayField, is slower
		header_row.find(".HorizontalFormTableHeaderFor"+aggregation.display_field_zname).remove();
	}
	
	return header_row;
};

// builds a table row containing headers for the display fields
// only for horizontal forms
Zymonic.FormFormat.Grouped.prototype.buildDisplayFieldsDivHeaders = function() {
	// start a new row and add clones of the display fields
	var original_header_row = this.getFormHorizontalTable().find(".HorizontalFormTableHeader").parent("tr");
	var header_row = $("<tr />");
	
	// add any display field labels
	for (var i=0; i<this.aggregations.length; ++i) {
		var aggregation = this.aggregations[i];
		var header = original_header_row.find(".HorizontalFormTableHeaderFor"+aggregation.display_field_zname).clone();
		header_row.append(header);
	}
	
	return header_row;
};

// adds the show/hide button to the display container
// and also handles the show_hide_field setup
Zymonic.FormFormat.Grouped.prototype.addShowHideButton = function(group, display_fields_container, records_container) {
	var button = $("<button />");
	button.addClass("GroupedFormFormatGroupShowHideButton");

	var show_text = this.show_text;
	var hide_text = this.hide_text;
	button.html(show_text);
	Zymonic.Utils.attach_event(button, "click", this.ident, function() {
		if (records_container.is(":visible")) {
			button.html(show_text);
			records_container.hide();
		} else {
			button.html(hide_text);
			records_container.show();
		}
		
		// return false so it does not submit the form
		return false;
	});
	if (this.isFormHorizontal()) {
		// if in horizontal form add as last cell
		var display_fields_row = display_fields_container.find("tr.record");
		var cell = $("<td />");
		cell.append(button);
		display_fields_row.append(cell);
	} else {
		display_fields_container.append(button);
	}
	
	// hide by default, once aggregations are set the show_hide condition 
	// will be run to display if the condition passes
	records_container.hide();
	
	// keep track of the button so can change the text easily
	group.show_hide_button = button;
};

// sets the text to use on show/hide button
Zymonic.FormFormat.Grouped.prototype.setShowHideButtonText = function(show_text, hide_text) {
	this.show_text = show_text || 'Show Records';
	this.hide_text = hide_text || 'Hide Records';
};

// find aggregation display field and move it to the display fields container, also remove it from all records
Zymonic.FormFormat.Grouped.prototype.calculateAggregation = function(aggregation, group) {
	var aggregation_value = this.calculateAggregationValue(aggregation, group.records);
	aggregation.group_display_field[group.ident].setValue(aggregation_value);
};

//calculate the aggregation value over the incoming records
Zymonic.FormFormat.Grouped.prototype.calculateAggregationValue = function(aggregation, records) {
	var aggregation_value = null;
	switch (aggregation.type) {
		case 'first':
			aggregation_value = this.calculateExpressionValue(aggregation.expression, aggregation.expression_default, aggregation.expression_eval, aggregation.expression_fields, records[0]);
			break;
		case 'last':
			aggregation_value = this.calculateExpressionValue(aggregation.expression, aggregation.expression_default, aggregation.expression_eval, aggregation.expression_fields, records[records.length-1]);
			break;
		case 'count':
			aggregation_value = 0;
			for (var i=0; i<records.length; ++i) {
				var value = this.calculateExpressionValue(aggregation.expression, aggregation.expression_default, aggregation.expression_eval, aggregation.expression_fields, records[i]);
				if (value) {
					++aggregation_value;
				}
			}
			break;
		case 'sum':
			aggregation_value = 0;
			for (var i=0; i<records.length; ++i) {
				var value = this.calculateExpressionValue(aggregation.expression, aggregation.expression_default, aggregation.expression_eval, aggregation.expression_fields, records[i]);
				if (value) {
					aggregation_value += value;
				}
			}
			break;
		case 'concatenate':
			var aggregation_values = [];
			for (var i=0; i<records.length; ++i) {
				var value = this.calculateExpressionValue(aggregation.expression, aggregation.expression_default, aggregation.expression_eval, aggregation.expression_fields, records[i]);
				if (value) {
					aggregation_values.push(value);
				}
			}
			var separator = ",";
			if (aggregation.other_expression) {
				separator = this.calculateExpressionValue(aggregation.other_expression, aggregation.other_expression_default, aggregation.other_expression_eval, aggregation.expression_fields, records[0]);
			}
			aggregation_value = aggregation_values.join(separator);
			break;
		default:
			throw new Error("Unknown aggregation type: "+aggregation.type);
	};
	
	return aggregation_value;
};

// calculate the expression value for the incoming record
Zymonic.FormFormat.Grouped.prototype.calculateExpressionValue = function(expression, expression_default, expression_eval, expression_fields, record) {
	// if no fields then just return the expression
	if (expression.indexOf('[') == -1) {
		return expression;
	}
	
	// grab values from each expression field
	var expression_field_values = {};
	for (var i=0; i<expression_fields.length; ++i) {
		var zname = expression_fields[i];
		var field = getZymonicRecordField(record.record_ident, zname);
		expression_field_values[zname] = field.getValue();
	}
	expression_value = Zymonic.Utils.znameReplacement(expression, expression_field_values, '\\[', '\\]');
	
	// set default
	if (!expression_value && expression_default) {
		expression_value = expression_default;
	}
	
	// eval if needed, treat as number if looks like one
	if (expression_eval == 'true') {
		return eval(expression_value);
	} else if (expression_value.match(/^\d+$/)) {
		return parseInt(expression_value);
	} else if (expression_value.match(/^\d+\.\d+$/)) {
		return parseFloat(expression_value);
	} else  {
		return expression_value;
	}
};

// runs the given js condition string
// NOTE: NO LONGER USED - this was only used when using eval to run conditions
// performance was not goos with that so now conditions are run via JS functions
// built in the XSL, leaving this function here as it may be useful, or me used somewhere else
Zymonic.FormFormat.Grouped.prototype.runConditionJS = function(group, conditions, condition_combination) {	
	if (conditions.length == 0) {
		return {
			condition_passed: true
		};
	}
	
	// build js to eval for each condition
	var condition_js_to_eval = [];
	for (var i=0; i<conditions.length; ++i) {
		var display_field_values = this.getGroupDisplayFieldValues(group, conditions[i].fields);
		condition_js_to_eval.push(Zymonic.Utils.znameReplacement(conditions[i].js, display_field_values, '\\[\\[', '\\]\\]'));
	}

	// call check conditions with all the condition js
	return check_conditions(condition_js_to_eval, condition_combination);
};