// setup namespace
Zymonic.Field = {};

// setup cache and lookup
// TODO: replace with Zymonic.add_to_lookup and Zymonic.lookup_object
Zymonic.FieldLookup = {};
function getZymonicField(ident) {
	return Zymonic.FieldLookup[ident];
}

// setup caches on record, so can find fields in filter results
// TODO: replace with Zymonic.add_to_lookup and Zymonic.lookup_object
Zymonic.FieldsInRecord = {};
function getZymonicRecordField(record_id, zname) {
	if (Zymonic.FieldsInRecord[record_id]) {
		return Zymonic.FieldsInRecord[record_id][zname];
	}
	return null;
}
function getZymonicFieldsInRecord(record_id) {
	if (Zymonic.FieldsInRecord[record_id]) {
		var fields = [];
		for (var zname in Zymonic.FieldsInRecord[record_id]) {
			fields.push(Zymonic.FieldsInRecord[record_id][zname])
		}
		return $(fields);
	}
	return $([]);
}


// There is a potential issue here is that if a block refreshes and some
// fields disappear then they will still be in the FieldLookupByBlock 
// cache - TODO consider clearing down on block load.
Zymonic.FieldLookupByWrapperIdent = {};
function getZymonicFieldsByWrapperIdent(wIdent) {
	var fArray = new Array;
	if( Object.prototype.toString.call( Zymonic.FieldLookupByWrapperIdent[wIdent] ) === '[object Object]' )
	{
		for(var i in Zymonic.FieldLookupByWrapperIdent[wIdent])
		{
			if (Zymonic.FieldLookupByWrapperIdent[wIdent][i].onPage()) {
				fArray.push(Zymonic.FieldLookupByWrapperIdent[wIdent][i]);
			} else {
				delete Zymonic.FieldLookupByWrapperIdent[wIdent][i];
			}
		}
	}
	return fArray;
}

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

Zymonic.Field.Field.prototype.errorClass = function() { return ""; };

// add constants
Zymonic.Field.Field.prototype.FIELD_CHANGED_CLASS      = "ZymonicFieldChanged";
Zymonic.Field.Field.prototype.FIELD_CHANGED_SHOW_CLASS = "ZymonicFieldChangedShow";
Zymonic.Field.Field.prototype.FIELD_FORCE_CHANGED      = "ZymonicFieldForceChanged";

// init function
Zymonic.Field.Field.prototype.init = function(args) {
	for (var key in args) {
		this[key] = args[key];
	}
	this.validation_function = "validate_"+this.ident;
	
	// clear validation errors
	this.clearErrors();
	
	// add to the lookups
	if (this.ident != "") {
		Zymonic.FieldLookup[this.ident] = this;
		this.addToWrapperLookup();
	}
	if (this.js_ident && this.js_ident != "") {
		Zymonic.FieldLookup[this.js_ident] = this;
	}
	if (this.record) {
		this.addToRecordLookup(this.record.ident);
	}
	
	// Create a generic DefaultHandler event
	var field = this;
	if(this.ident != '') {
		this.input_elements().each(function(index) {
			field.addDefaultHandler.call(field, this);
		});
	}
	
	// placeholder for = in reload extra_params
	this.equals_placeholder = "ZZEQUALS";
	
	// handlers
	this.handlers = {
		"change": [],
		"change_seen": {},
	};
	
	// field fills
	this.field_fill_calculations = [];
	
	// setup handler for adding on blur
	if (this.add_on_blur && this.parent_form_ident && this.record && this.inPlaceholder()) {
		var parent_form = this.getParentForm();
		if (parent_form && parent_form.canAddRecords()) {
			
			// handler to focus this field on any new records which is added
			var field_zname = this.zname;
			parent_form.onRecordsChange(
				function(event, form, records_changed) {
					// find new placeholder record, find this field on it and focus it
					if (records_changed && records_changed.new_placeholder) {	
						var new_placeholder_field = records_changed.new_placeholder.find("[zname='"+field_zname+"']");
						if (new_placeholder_field) {
							new_placeholder_field.focus();
						} else {
							Zymonic.log("Unable to find field "+field_zname+" in record "+records_changed.new_placeholder.attr('id'));
						}
					}
				},
				this.ident+"_add_on_blur"
			);
			
			// add blur handler to input elements to trigger the add
			var field = this;
			var record_ident = this.record.ident;
			Zymonic.Utils.attach_event(
				this.input_elements().last(),
				"blur",
				this.ident,
				function(event) {
					// don't do anything if its already being added or if there is no value
					if (field.adding_on_blur ||!field.getValue()) {
						return;
					}
					field.adding_on_blur = true;
					
					// disable input so it doesn't accidentally trigger the add again
					// before the result has come back
					field.input_elements().prop( 'disabled', true );
					
					var add_button = parent_form.getAddButton(record_ident);
					if (add_button) {
						add_button.click();
						
						// if the add fails for some reason the input will still be disabled
						// so add a check for that here and re-enable the input
						// if global var is set then adding is happening, nothing to do
						// if not then add failed, enable the input again
						if (!window.adding_record || field.hasErrors()) {
							field.input_elements().prop( 'disabled', false );
						}
					} else {
						Zymonic.log("Unable to find add button for form "+parent_form.ident);
					}
					field.adding_on_blur = false;
					event.preventDefault();
				}
			);
		}
	}
};

// generic function to add settings to a field object
Zymonic.Field.Field.prototype.setExtraArgs = function(args) {
	for (var key in args) {
		this[key] = args[key];
	}
}

// return true if this field is still on the current page
Zymonic.Field.Field.prototype.onPage = function() {
	return this.container_div().length > 0;
}

Zymonic.Field.Field.prototype.addDefaultHandler = function(element) {
	var field_container = this.container_div();
	var ident = this.getIdent();
	var jquery_element = $(element);
	jquery_element.bind(this.defaultHandler, {}, function(event) {
		$(Zymonic).trigger(ident + 'defaultHandler', [event]);
	});
	jquery_element.focus(function() {
		field_container.addClass('hasFocus');
	});
	jquery_element.blur(function() {
		field_container.removeClass('hasFocus');
	});
};

Zymonic.Field.Field.prototype.getZName = function() {
	return this.zname;
};

Zymonic.Field.Field.prototype.getIdent = function() {
	return this.ident;
};

Zymonic.Field.Field.prototype.getClass = function() {
	return this.class_name;
};

Zymonic.Field.Field.prototype.addToWrapperLookup = function(ident) {
	if( !Zymonic.FieldLookupByWrapperIdent[this.parent_form_ident] || 
			!(Object.prototype.toString.call( Zymonic.FieldLookupByWrapperIdent[this.parent_form_ident] ) === '[object Object]') )
		Zymonic.FieldLookupByWrapperIdent[this.parent_form_ident] = new Object;
	Zymonic.FieldLookupByWrapperIdent[this.parent_form_ident][this.ident] = this;
};

Zymonic.Field.Field.prototype.getValueFromInputs = function() {
    var value;
    if (!this.hidden && (this.display_only || this.report_mode == "true")) {
		value = this.display_only_element().text();
	} else {
		value = this.jquery().val();
	}
    return value;
}

Zymonic.Field.Field.prototype.getValue = function(raw) {
	var value = this.getValueFromInputs();
	
    // Trim field of any leading/trailing whitespace
    if ( value && typeof(value) == 'string' )
    {
        value = value.replace(/^\s+/, "").replace(/\s+$/, "");
    }
	
	// for numeric types, strip any commas
	if ( value && this.field_type && this.field_type.match(/int|float|double|decimal/) ) {
		value = value.replace(/,/g, "");
	}
	
	// apply any field fills
	var ffc_value = this.runFieldFillCalculations(value);

	// if value has changed then
	// set the changed value on the field itself so the user can see it
	if (ffc_value != null && ffc_value != value) {
		value = ffc_value;
		this.setValue(value, true);
	}
	
	// if raw value wanted then see if any comma stripping is needed
	if ( raw && value && this.field_type && this.field_type.match(/int|float|double|decimal/) ) {
		value = value.replace(/,/g, "");
	}
	
	return value;
};

Zymonic.Field.Field.prototype.runFieldFillCalculations = function(value) {

	var ret_value = null;
	var ffc_set = false;

	for (var i=0; i< this.field_fill_calculations.length; ++i) {
		var ffc = this.field_fill_calculations[i];
		var ffc_value = ffc.getValue(value);
		if ( ffc_value != null && ( ffc_value !== '' || ffc.allowEmpty() ) )
		{
			ffc_value = this.roundValue(ffc_value);
			ret_value = ffc_value;
			
			// stop now, we got a value
			break;
		}
	}

	return ret_value;
};

Zymonic.Field.Field.prototype.getValueURIEncoded = function() {
	return encodeURI(this.getValue());
};

Zymonic.Field.Field.prototype.setValue = function(value, not_as_changed) {
	
	// be careful firing change event here
	// see linked field reverse fill for example of it
	var changed = false;
	if (!this.hidden && (this.display_only || this.report_mode == "true")) {
		if ( this.display_only_element().text() != value )
		{
			this.display_only_element().text(value);
			changed = true;
		}
	} else {
		if ( this.jquery().val() != value )
		{
			this.jquery().val(value);
			changed = true;
		}
	}
	
	// do value changed checks
	this.setValueAsChanged(value, not_as_changed);
	
	// track when value is changed
	if ( !this.last_value || value != this.last_value ) {
		this.last_value = value;
		this.value_last_changed_timestamp = Zymonic.Utils.current_timestamp();
	}
};

Zymonic.Field.Field.prototype.clearValue = function() {
	this.setValue('');
};

// set a field as having its value changed
// for hidden/readonly fields ensure they are never marked as changed
Zymonic.Field.Field.prototype.setValueAsChanged = function(value, not_as_changed, force) {

	// use flag to ensure we don't recurse through this
	if (this.setting_value_as_changed) {
		return;
	}
	this.setting_value_as_changed = true;
	
	if (!not_as_changed) {
		if (
		  !force && (
		       this.hidden
		    || this.display_only
		    || this.report_mode == "true"
		    || ( !this.any_change && this.original_value != null && this.original_value == (value || this.getValue()) )
		  )
		) {
			this.container_div().removeClass(this.FIELD_CHANGED_CLASS);
		} else {
			this.container_div().addClass(this.FIELD_CHANGED_CLASS);
		}
	}
	
	// if forcing then set an extra param to make it use this value server side
	if (force) {
		this.addExtraFormData(this.ident+"_force_get_user_value", "true");
		this.input_elements().addClass(this.FIELD_FORCE_CHANGED);
	}

	// call handlers, regardless of status of the field itself
	if ( this.any_change || this.original_value == null || this.original_value != (value || this.getValue()) ) {
		for (var i=0; i< this.handlers.change.length; ++i) {
			this.handlers.change[i]();
		}
	}
	
	this.setting_value_as_changed = false;
};

// has a field had its value changed
Zymonic.Field.Field.prototype.hasValueChanged = function(value) {
	if (this.container_div().hasClass(this.FIELD_CHANGED_CLASS)) {
		return true;
	} else if ( ( this.original_value == null && this.getValue() ) || ( this.original_value != null && this.original_value != this.getValue() ) ) {
		// this can be called before other handlers which set the CSS class set above
		// so add this as a sanity check
		return true;
	}
	else if ( this.search_field == "true" && (( this.check_empty == "Y" && !this.isCheckEmptySet() ) || ( this.check_empty != "Y" && this.isCheckEmptySet() )) ) {
		this.check_empty = this.isCheckEmptySet() ? "Y" : "N";
		return true;
	}
	else {
		return false;
	}
};

// checks whether a field has a block value saved which differs from the original
Zymonic.Field.Field.prototype.hasUnsavedBlockValue = function() {
	if (
	    this.block_value == null
	    || ( this.block_value != null && this.original_value != null && this.original_value == this.block_value )
	) {
		return false;
	} else {
		return true;
	}
};

// updates original and block values
Zymonic.Field.Field.prototype.setOriginalValue = function(value) {
	this.setOriginalValue = value;
};
Zymonic.Field.Field.prototype.setBlockValue = function(value) {
	this.block_value = value;
};

// checks if this field is in a placeholder record
Zymonic.Field.Field.prototype.inPlaceholder = function() 
{
	if (this.record && this.record.is_placeholder) {
		return true;
	}
	return false;
};

//checks if this field is in a record on a multiple record form
Zymonic.Field.Field.prototype.onMultipleRecordForm = function() 
{
	if (this.record && this.record.on_multiple_record_form) {
		return true;
	}
	return false;
};

//checks if this field is in a placeholder record
Zymonic.Field.Field.prototype.isBeingAdded = function() 
{
	if (this.record && this.record.being_added) {
		return true;
	}
	return false;
};

// returns if this field needs validation as part of a submit
Zymonic.Field.Field.prototype.needsValidationOnSubmit = function() 
{
	if ( this.onMultipleRecordForm() && this.inPlaceholder() ) {
		if  ( Zymonic.transition_being_run && Zymonic.transition_being_run.add_on_save ) {
				var form = this.getParentForm();
				var fields_to_check = Zymonic.transition_being_run.add_on_save[form["zname"]]
				if (form && form["zname"] && fields_to_check) {
					var record = form.getRecord(this.record.ident, true);
					if (record) {
						for (var i=0; i<record.fields.length; ++i) {
							if ( fields_to_check.includes(record.fields[i]["zname"]) && record.fields[i].hasValueChanged()) {
								return true;
							}
						}
					} else {
						Zymonic.log_error("Unable to find record: "+this.record.ident);
					}
				}
			}
		return false;
	}
	return true;
};

/* Returns the input elements unless 'extra' is passed in,
 * in which case will return elements that have an id of
 *  ident + extra */
Zymonic.Field.Field.prototype.jquery = function(extra) {
	extra = extra || "";
	return $("#"+this.ident+extra);
};

Zymonic.Field.Field.prototype.input_elements = function() {
	return this.jquery();
};

Zymonic.Field.Field.prototype.display_only_element = function() {
	return this.jquery("_display_only_value");
};

Zymonic.Field.Field.prototype.check_empty_element = function() {
	return this.jquery("_check_empty");
};

Zymonic.Field.Field.prototype.container_div = function() {
	return this.jquery("_div");
};

Zymonic.Field.Field.prototype.clearErrors = function() {
	this.errors = [];
	this.unique_errors = {};
	this.has_errors = false;
};
Zymonic.Field.Field.prototype.hasErrors = function() {
	return this.has_errors;
};
Zymonic.Field.Field.prototype.setError = function(error) {
	if (!this.unique_errors[error]) {
		this.unique_errors[error] = true;
		this.errors.push(error);
		this.has_errors = true;
	}
};
Zymonic.Field.Field.prototype.getError = function() {
	return this.errors.join(" ");
};
Zymonic.Field.Field.prototype.validate = function(validOnly) {
	// call the validation function made by XSL
	if (window[this.validation_function]) {
		return window[this.validation_function]("field_validation", validOnly);
	}
	return true;
};

Zymonic.Field.Field.prototype.addToRecordLookup = function(record_id) {
	if (!Zymonic.FieldsInRecord[record_id]) {
		Zymonic.FieldsInRecord[record_id] = {};
	}
	
	Zymonic.FieldsInRecord[record_id][this.zname] = this;
	
	// also add to record on parent form
	var field = this;
	$(document).ready(function() {
		var form = field.getParentForm();
		if (form) {
			form.addFieldToRecord(record_id, field);
		}
	});
};

// reloads the current field via call to the server and puts it inplace of the existing fields
// Params as per reload except ident which gives the html element to block and replace.
Zymonic.Field.Field.prototype.reloadInPlace = function(extra_params, use_parent_form, save, validate, save_block_params, get_block_params, ident, success_cb, subform_ident, subform_record_ident, handle_record_replacement, record_replacement_element, add_new_placeholder) 
{
	var wrapper_mode = true;
	if(!ident) {
		ident = this.ident+"_div";
		wrapper_mode = false;
	}
	
	var subform, subform_record;
	if (subform_ident && subform_record_ident) {
		subform = Zymonic.lookup_object('Form', subform_ident);
		if (subform) {
			subform_record = subform.getRecord(subform_record_ident);
			if (subform_record) {
				var subform_record_id_str = "";
				if (subform_record.id) {
					for (var field in subform_record.id) {
						// can't use = in here due to how extra params are assembled
						// use a placeholder for now
						subform_record_id_str += field + this.equals_placeholder + subform_record.id[field] + "|";
					}
					subform_record_id_str = subform_record_id_str.slice(0,-1);
				}
				if (!extra_params) { extra_params = [ ]; }
				extra_params.push("ZZFsubform_rec_id="+subform_record_id_str);
			} else {
				Zymonic.log("Unable to find subform record: "+subform_record_ident);
			}
		} else {
			Zymonic.log("Unable to find subform: "+subform_ident);
		}
		
	}
    
	// Add the parent form record id if present
	var form, record;
	if(this.parent_form_ident && this.record && this.record.ident) {
		form = Zymonic.lookup_object('Form',this.parent_form_ident);
		if(form && form.idfieldmaponly) {
			record = form.getRecord(this.record.ident);
			if(record) {
				var parentform_record_id_str = '';
				for (var field in record.id) {
					// can't use = in here due to how extra params are assembled
					// use a placeholder for now
					parentform_record_id_str += field + this.equals_placeholder + record.id[field] + "|";
				}
				parentform_record_id_str = parentform_record_id_str.slice(0,-1);
				if (!extra_params) { extra_params = [ ]; }
				extra_params.push("ZZFparentform_rec_id="+parentform_record_id_str);
			} else {
				Zymonic.log("Unable to find parent record: "+ this.record.ident);
			}
		} else if (form.idfieldmaponly) {
			Zymonic.log("Unable to find parent form: " + this.parent_form_ident);
		}
		
	}
	
	// reload with callbacks to trigger the XML
	var field = this;
	var record_container = ( record_replacement_element ? record_replacement_element() : $("#"+( subform_record ? subform_record.record_ident : ident )) );
	var unblock = Zymonic.Utils.block_gui_element(record_container);
	return this.reload(
		
		// error handler
		function(field, type, error) {
			// just unlock the process and log the error
			unblock();
			Zymonic.log_error("Error relogin field "+field.type+": "+type+" - "+error);
		},
		
		// success handler
		function(field, can_continue, xml) {
			unblock();

			// can continue, replace the XML in place and unblock the GUI
			if (can_continue) {
				if (subform_record) {
					field.replaceRecordwithTransformedXML(subform, subform_record, xml, wrapper_mode, handle_record_replacement, record_replacement_element);
				} else {
					field.replaceWithTransformedXML(ident, xml, wrapper_mode);
				}
				
				// trigger callback
				if (success_cb) {
					success_cb();
				}
                
				// If we're a search field then we probably need to refresh the results.
		                if(field.search_field == 'true') {
                			$(Zymonic).trigger(field.getIdent() + 'defaultHandler', []);
                		}
				
				// Resize the parent block
				if(field.block_id) {
					var block = Zymonic.lookup_object("Block", field.block_id);
					if(block) {
						block.autolength();
					}
				}
			}
		},
		
		// reload params
		extra_params, use_parent_form, save, validate, save_block_params, get_block_params,
		( handle_record_replacement ? false : true ),
		function() { return Zymonic.Utils.block_gui_element( record_replacement_element ? record_replacement_element() : "#"+( subform_record ? subform_record.record_ident : ident ) ) },
		( record_replacement_element ? subform_record : null ),
		( record_replacement_element ? add_new_placeholder : null ),
		( record_replacement_element ? record_container : null )
	); 
}

//This exists so that fields that need to do more complex processing of XML don't need to 
//override reloadInPlace.
Zymonic.Field.Field.prototype.getBlock = function(ident) {
	return loading_gui_element(ident);
};

// This exists so that fields that need to do more complex processing of XML don't need to 
// override reloadInPlace.
Zymonic.Field.Field.prototype.replaceWithTransformedXML = function(ident, xml, wrapper_mode) {
	Zymonic.Utils.replaceWithTransformedXML($("#"+ident), xml, true, wrapper_mode);
};

// used to replace just a reloading record with the updated record output
Zymonic.Field.Field.prototype.replaceRecordwithTransformedXML = function(form, form_record, xml, wrapper_mode, handle_record_replacement, record_replacement_element_fn) {
	
	// get the replacements element, default replacement position to the current record
	var record_replacement_element;
	if (record_replacement_element_fn) {
		record_replacement_element = record_replacement_element_fn();
	} else {
		record_replacement_element = $("#"+form_record.record_ident);
	}
	
	// transform the xml and run js on it setup objects, e.g. to add any new records to form object
	var full_html_result = Zymonic.Utils.transformXML(xml);
	
	// for some reason need to look in children, looking at top level doesn't work
	var full_html = $(full_html_result).children();

	// need to run the form setup Js to ensure new records are added to existing form objects
	Zymonic.Utils.reRunJS(full_html.find("script.ZymonicFormObjectSetup"), true);
	
	// handle_record_replacement
	// R = replace existing record
	// D = delete existing record
	// A = replace existing record with all incoming, don't match
	if (handle_record_replacement == "R" || handle_record_replacement == "A") {
		var record_html;
		if (handle_record_replacement == "R") {
			// find the record in the transformation
			record_html = full_html.find("#"+form_record.record_ident);
			if (!record_html || record_html.length != 1) {
				Zymonic.log("Unable to find record in result: "+form_record.record_ident);
				return;
			}
		} else if ( handle_record_replacement == "A") {
			// find all records on the page, ignore any placeholder and LF records
			record_html = full_html.find(".record:not(.ZymonicPlaceholderRecord):not(.FilterSearchForm .record)");
			if (!record_html || record_html.length < 1) {
				Zymonic.log("Unable to find any non-placeholder records in result");
				return;
			}
		}
		
		// replace the record on the page
		// for some reason the replace with call does not add script tags to the page
		// so we send through the force flag to ensure scripts are run
		// this makes debugging harder, but its more of a reason to take script tags
		// out of the XSL/HTML and into Js objects
		record_replacement_element.replaceWith(record_html);
		Zymonic.Utils.reRunJS($("#"+form_record.record_ident), true);
		
		// if placeholder record append it after the record
		if (handle_record_replacement == "R") {
			full_html.find("."+form.zname+".ZymonicPlaceholderRecord").insertAfter($("#"+form_record.record_ident));
			Zymonic.Utils.reRunJS($("."+form.zname+".ZymonicPlaceholderRecord"));
		}
		
		// explicitly trigger the records changes action on the form
		form.triggerRecordsChanged({ new_placeholder: $("#"+form_record.record_ident).siblings(".ZymonicPlaceholderRecord") });
	} else if (handle_record_replacement == "D") {
		// ensure record didn't come back, i.e. it was deleted
		var record_html = full_html.find("#"+form_record.record_ident);
		if (!record_html || record_html.length > 0) {
			Zymonic.log("Found deleted record in result: "+form_record.record_ident);
			return;
		}
		
		// remove it from the form object
		form.removeRecord(form_record);
		
		// remove the existing record
		record_replacement_element.remove();

	} else {
		Zymonic.log("Invalid handle_record_replacement: "+handle_record_replacement);
	}
};

// Append to form data
Zymonic.Field.Field.prototype.appendToForm = function(form_data, search) {
    var val = this.getValue();
    // Send empty string instead of null
    if(!val) {
        val = '';
    }
    
    if(search) {
    	if(this.jquery('_check_empty').is(':checked')) {
    		form_data.append(this.getIdent() + '_check_empty', this.jquery('_check_empty').val());
    	} else {
    		form_data.append(this.getIdent() + '_check_empty', '');
    	}
    }
    
    if(!search || val !== null) {
    	form_data.append(this.getIdent(), val);
    }
    
    this.appendOtherFieldsToForm(form_data, search);
    
    this.setExtraFormParams(form_data);
};

 // Append other fields to form data
 Zymonic.Field.Field.prototype.appendOtherFieldsToForm = function(form_data, search) {
    
    // need to add any contained field values which have changed
    this.getFields().forEach(function(field) {
        if (field.hasValueChanged()){
            field.appendToForm(form_data, search);
        }
    });
};

// Add a mechanism to force a record ident - initially added so that subfilter
// fields can be give a record ident to allow reload to work
Zymonic.Field.Field.prototype.setForceParentIdents = function(form_ident, record_ident) {
	this.force_record_ident = record_ident;
	this.force_parent_form_ident = form_ident;
}

// reloads the current field via call to the server and put the results in callbacks
Zymonic.Field.Field.prototype.reload = function(error_cb, success_cb, extra_params, use_parent_form, save, validate, save_block_params, get_block_params, full_update, loading_function, record_being_added, add_new_placeholder, placeholder_to_copy) 
{
	// if not saving, check for unsaved changes before continuing
	if (!save && !this.skip_unsaved_changes_checks) {
		if (this.checkForUnsavedChanges()) {
			// get confirmation before proceeding
			var cont = confirm("There are unsaved changes here, which will be highlighted. Do you wish to leave them unsaved?");
			if (!cont) {
				// success, but without the can_continue flag
				success_cb(this, false);
				return false;
			}
		}
	}
	
	// build list of params
	var form_data = Zymonic.new_form_data();
	form_data.record_being_added = record_being_added || null;
	this.appendToForm(form_data);
	
	// add field reload values
	form_data.append("ZZwebservicemode",       "field");
	form_data.append("ZZno_display_attributes","false");
	form_data.append("ZZBzname",                this.zname);
	form_data.append("ZZFident",                this.ident);
	form_data.append("ZZFblock_id",             this.block_id);
	form_data.append("ZZFparent_fap_from_block", 'true');
	form_data.append("ZZFpage_id",              this.page_id);
	form_data.append("ZZBprocess_id",           this.process_id);
	form_data.append("ZZFform",                 this.parent_form_zname);
	if(this.force_parent_form_ident) {
		form_data.append("ZZFform_ident",           this.force_parent_form_ident);
	} else {
		form_data.append("ZZFform_ident",           this.parent_form_ident);
	}
	if(this.force_record_ident) {
		form_data.append("ZZFrecord_ident", this.zymoforce_record_ident);
	} else if (this.record) {
		form_data.append("ZZFrecord_ident", this.record.ident);
	}
	if (this.field_group_ident) {
		form_data.append("ZZFfield_group_ident", this.field_group_ident);
	}
	if (this.report_mode == 'true') {
		form_data.append("ZZFsubtype", "Report");
	} else if (this.search_field == 'true') {
		form_data.append("ZZFsubtype", "Search");
	}
	
	// set flags
	if (use_parent_form && !this.no_parent_form) {
		form_data.append("ZZFuse_parent_form", "true");
	}
	if (save) {
		form_data.append("ZZFsave", "true");
	}
	if (validate) {
		form_data.append("ZZFvalidate", "true");
	}
	if (save_block_params) {
		form_data.append("ZZFsave_block_params","true");
	}
	if (get_block_params) {
		form_data.append("ZZFget_block_params","true");
	}
	
	// add any extra params on the object itself
	// same for lookup fields and extra fields
	this.setExtraParams(form_data);
	this.setFieldLookupParams(form_data);
	this.setExtraFieldsParam(form_data);
	
	// add extra params
	if (extra_params) {
		for (var i=0; i<extra_params.length; ++i) {
			var url_param = extra_params[i].split("=");
			
			// replace any placeholder strings
			var key = url_param[0];
			var value = url_param[1].replace(this.equals_placeholder, "=");
			form_data.append(key, value);
		}
/*		for (var key in extra_params) {
			form_data.append(key, extra_params[key]);
		} 
Have commented out this version - I can't find anything that passes
extra_params in as an object/keyed array... 
		*/
	}

	// Split base URL 
	var url_split = split_baseurl(base_url);
	var url_params = get_url_params([]).concat(url_split[1].split('&'));
	
	// assemble all urls params into form data to send
	for (var i=0; i<url_params.length; ++i) {
		var url_param = url_params[i].split("=");
		form_data.append(url_param[0], url_param[1]);
	}
	
	// keep context for callbacks
	var field = this;
	
	// trigger ajax refresh	and callbacks
	Zymonic.request(
		"POST", form_data, true, null, null,
		function(xml) {
			// check for errors, and setup redo of function if can continue
			var zt = new Zymonic.Transformer.Transformer();
			var can_continue = zt.XMLErrHandle(function(dxml) {
				success_cb(field, true, dxml);
			}, undefined, xml, field.block_id);
			
			success_cb(field, can_continue, xml);
		},
		function(type, error) {
			error_cb(field, type, error);
		},
		null, loading_function
	);
	
	return true;
};

Zymonic.Field.Field.prototype.noBasicValidation = function() {
	return false;
};

// function called on setting/clearing validation errors
// used by subclasses to do additional work on the validation errors
Zymonic.Field.Field.prototype.validationErrorsSet = function() {
	return false;
};
Zymonic.Field.Field.prototype.validationErrorsCleared = function() {
	return false;
};

// get list of contained fields
Zymonic.Field.Field.prototype.getFields = function() {
	return [];
};

// method to add extra params for any form calls
Zymonic.Field.Field.prototype.addExtraFormData = function(key, value) {
	if (!this.extra_form_params) {
		this.extra_form_params = {};
	}
	
	this.extra_form_params[key] = value;
};

// sets extra form param values on form_data
Zymonic.Field.Field.prototype.setExtraFormParams = function(form_data) {
	if (this.extra_form_params) {
		for (var key in this.extra_form_params) {
			form_data.append(key, this.extra_form_params[key]);
		} 
	}
	
	// add any extra fields of contained fields
	this.getFields().forEach(function(field) {
		field.setExtraFormParams(form_data);
	});
};

// method to add extra params for any reload calls
Zymonic.Field.Field.prototype.addExtraParam = function(key, value) {
	if (!this.extra_params) {
		this.extra_params = {};
	}
	
	this.extra_params[key] = value;
};

// method to add extra params, which use field values, for any reload calls
Zymonic.Field.Field.prototype.addFieldLookupParam = function(key, ident) {
	if (!this.field_lookup_params) {
		this.field_lookup_params = {};
	}
	
	this.field_lookup_params[key] = ident;
};

// method to add extra fields, for any reload calls
Zymonic.Field.Field.prototype.addExtraFieldParam = function(field_zname, field_ident) {
	if (!this.extra_fields) {
		this.extra_fields = [];
		this.extra_fields_exists = {};
	}
	
	// check for case where we need the same extra field with a different ident
	if (this.extra_fields_exists[field_zname]) {
		if (this.extra_fields_exists[field_zname] != field_ident) {
			throw new Error(  "Cannot have same extra field with different idents: "
			                + "\nfield=" + field_zname + ", "
			                + "\nincoming_ident=" + field_ident + ", "
			                + "\nexisting_ident=" + this.extra_fields_exists[field_zname] + ", "
			);
		} else {
			// return here as we've already done this extra param
			return;
		}
	}
	
	this.extra_fields_exists[field_zname] = field_ident;
	this.extra_fields.push(field_zname);
	this.addFieldLookupParam( field_ident, field_ident );
	
	// need to send through ident for extra fields so if they are returned
	// as dependent fields the idents still match and it can be looked up
	this.addExtraParam("ZZFextra_field_"+field_zname+"_ident", field_ident);
};

// method to get list extra fields
Zymonic.Field.Field.prototype.getExtraFields = function() {
	var extra_fields = this.extra_fields || [];
	
	// add any extra fields of contained fields
    this.getFields().forEach(function(field) {
    	extra_fields = extra_fields.concat(field.getExtraFields());
    });
    
    return extra_fields;	
};

// sets extra param values on form_data
Zymonic.Field.Field.prototype.setExtraParams = function(form_data) {
	if (this.extra_params) {
		for (var key in this.extra_params) {
			form_data.append(key, this.extra_params[key]);
		} 
	}
	
	// add any extra fields of contained fields
    this.getFields().forEach(function(field) {
    	field.setExtraParams(form_data);
    });
};

//sets extra param values on form_data
Zymonic.Field.Field.prototype.setFieldLookupParams = function(form_data) {
	if (this.field_lookup_params) {
		for (var key in this.field_lookup_params) {
			var field = getZymonicField(this.field_lookup_params[key]);
			form_data.append(key, field.getValue());
		}
	}
	
	// add any extra fields of contained fields
    this.getFields().forEach(function(field) {
    	field.setFieldLookupParams(form_data)
    });
};

//sets extra param values on form_data
Zymonic.Field.Field.prototype.setExtraFieldsParam = function(form_data) {
	var extra_fields = this.getExtraFields();
	if (extra_fields && extra_fields.length > 0) {
		form_data.append('ZZFextra_fields', extra_fields.join(","));
	}
};

//attach UI tab event to field object
Zymonic.Field.Field.prototype.setLastInFieldGroup = function(field_group_ident){
	var field = this;
	var inputs = field.input_elements();
	inputs.last().bind('keydown',function(e){
		if((e.which||e.keyCode)==9 && !e.shiftKey){
			var form = Zymonic.lookup_object('Form', field.parent_form_ident);
			form.nextFieldGroup(field.record.ident);
			
			// prevent the default tab behaviour
			e.preventDefault();
		}
	});
}
Zymonic.Field.Field.prototype.setFirstInFieldGroup = function(field_group_ident){
	var field = this;
	var inputs = field.input_elements();
	inputs.first().bind('keydown',function(e){	
		if((e.which||e.keyCode)==9 && e.shiftKey){
			var form = Zymonic.lookup_object('Form', field.parent_form_ident);			
			form.prevFieldGroup(field.record.ident);
			
			// prevent the default tab behaviour
			e.preventDefault();
		}
	});
}

Zymonic.Field.Field.prototype.basicValidation = function(display_name, min_length, lls)
{

 	if(this.noBasicValidation())
 		return 'OK';
	
 	this.clearErrors();

	var field = getFieldValue(this.ident);
	var type_ok = false;
	var required_ok = false;
	var length_ok = false;
	var duplicates_ok = false;

	// Check for correct type
	var digit_type = false;
	if ( ! field )
	{
		// need to check if type is a digit
		var re = new RegExp('int|float|double',"i");
		if ( this.field_type.match(re) ) {
			digit_type = true;
		}
		
		type_ok = true;
	}
	else
	{
		var re = new RegExp('char|text|blob|enum',"i");
		if ( this.field_type.match(re) )
		{
			// most things are ok here
			type_ok = true;
		}
		else
		{
			var re = new RegExp('int',"i");
			if ( this.field_type.match(re) )
			{
				digit_type = true;
				var re = new RegExp("^-?[\\d]*(?:e[-+]?\\d+)?$");
				if(field.match(re))
					type_ok = true;
			}
			else
			{
				var re = new RegExp('float|double',"i");
				if ( this.field_type.match(re) )
				{
					digit_type = true;
					var re = new RegExp('^-?[\\d,]*\\.{0,1}[\\d]*(?:e[-+]?\\d+)?$');
					if(field.match(re))
						type_ok = true;
				}
				else
				{
					if ( this.field_type.toLowerCase == 'datetime' )
					{
						var re = new RegExp('(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d) (\\d\\d):(\\d\\d):(\\d\\d)');
						if(field.match(re))
							type_ok = true;
					}
					else
					{
						type_ok = true;
					}
				}
			}
		}
	}

	// Check if required field
	if ( !this.required || field )
	{
		required_ok = true;
	}
	
	// Check length
	if ( (!field) || field.length >= min_length )
	{
		length_ok = true;
	}
	
	// if flag set for duplicates check on other records on the form
	// can only do this if we have parent form and a record
	if ( this.no_duplicate_on_form && this.parent_form_ident && this.record && this.record.ident ) {
		var form = this.getParentForm();
		if (form) {
			var found_duplicate = false;
			var value = this.getValue();
			var records = form.getRecords(true);
			for (var i=0; i < records.length; ++i) {
				// skip this record
				if ( this.record.ident == records[i].record_ident ) {
					continue;
				}
				for (var j=0; j<records[i].fields.length; ++j) {
					var field = records[i].fields[j];
					if ( this.zname == field.zname ) {
                        if ( value == '' && this.no_duplicate_on_form_ignore_empty ) {
                            Zymonic.log("Skipping duplicate check");
                        }
                        else {
                            if ( value == field.getValue() ) {
                                this.setError("Duplicate value found");
                                field.setError("Duplicate value found");
                                found_duplicate = true;
                            }
                        }
						// can stop now, we found this field
						break;
					}
				}
			}
			if (!found_duplicate) {
				duplicates_ok = true;
			}
		} else {
			Zymonic.log("Unable to find form: "+this.parent_form_ident);
		}
		
	} else {
		duplicates_ok = true;
	}

	if ( required_ok && type_ok && length_ok && duplicates_ok )
	{
		return 'OK';
	}
	else
	{
		var errors = new Array();
      var Parameters = new Object;
      Parameters.display_name = display_name;
		if ( ! type_ok )
		{
      Parameters.type = this.field_type;
      errors.push(sub_ll(lls[0], Parameters));
		}

		if (! required_ok )
		{
	    errors.push(sub_ll(lls[1], Parameters))
		}
		
		if (! length_ok)
		{
      Parameters.min_length = min_length;
      Parameters.d_or_c = (digit_type ? lls[3] : lls[4]);
      errors.push(sub_ll(lls[2], Parameters))
		}
		
		if (!duplicates_ok)
		{
			errors.push(sub_ll(lls[5]));
		}

		return errors.join(" ");
	}

}

// callback to run when this field value changes
Zymonic.Field.Field.prototype.onChange = function(cb, use_default_handler, default_handler_delay, caller_ident) {
	if (caller_ident && this.handlers.change_seen[caller_ident]) {
		// already have this handler
		return;
	}
	this.handlers.change.push(cb);
	if (caller_ident) {
		this.handlers.change_seen[caller_ident] = true;
	}
	
	// also add to the inputs
	this.input_elements().each(function() { Zymonic.Utils.attach_event($(this), 'change', this.ident+"_onchange"+(caller_ident ? caller_ident : ""), cb) });;
	if (use_default_handler && this.defaultHandler) {
		var ident = this.ident;
		var default_handler = this.defaultHandler;
		if (!default_handler_delay) { 
			default_handler_delay = 1;
		}
		this.input_elements().each(function() {
			Zymonic.Utils.attach_event(
				$(this), default_handler, this.ident+"_onchange"+(caller_ident ? caller_ident : ""),
				function() {
					Zymonic.Utils.delayedRunNoRace(ident + caller_ident, default_handler_delay, cb);
				}
			);
		});
	}
	
};

// is this a hidden field
Zymonic.Field.Field.prototype.isHidden = function() {
	return this.hidden;
};

//is this a disable_change_detection field
Zymonic.Field.Field.prototype.disableChangeDetection = function() {
	return this.disable_change_detection == 'true';
};

// is the check empty flag set for this field
Zymonic.Field.Field.prototype.isCheckEmptySet = function() {
	return this.check_empty_element().is(':checked');
};

// registers a FFC with this field
Zymonic.Field.Field.prototype.addFieldFillCalculation = function(ffc) {
	this.field_fill_calculations.push(ffc);
	this.field_fill_calculations.sort(function(a,b) {
		return a.getPreffered() - b.getPreffered();
	});
};

// get display value for a field, used by subclasses
Zymonic.Field.Field.prototype.getDisplayValue = function() {
	return this.getValue();
}

// rounds the incoming value as needed
Zymonic.Field.Field.prototype.roundValue = function(value) {
	var rounding = null;
	if (this.rounding_dp) {
		rounding = this.rounding_dp;
	}
	if (this.rounding_dp_field_ident) {
		var field = getZymonicField(this.rounding_dp_field_ident);
		rounding = field.getValue();
	}
	if ( rounding != null ) {
		if ( rounding.match(/^\d+$/) ) {
			return Zymonic.Utils.round_number(value, rounding).toFixed(rounding);
		} else {
			Zymonic.log_error("Invalid rounding value ("+rounding+") for field "+this.zname+" ("+this.ident+")");
		}
	}
	
	return value;
}

// get field group ident
Zymonic.Field.Field.prototype.getFieldGroupIdent = function() {
	return this.field_group_ident;
};

// get field group container
Zymonic.Field.Field.prototype.getFieldGroupContainer = function(ident_only) {
	if (this.field_group_ident) {
		if (ident_only) {
			return this.field_group_ident+"_inner_div";
		} else {
			return $("#"+this.field_group_ident+"_inner_div");
		}
	}

	if (ident_only) {
		return null;
	} else {
		return $([]);
	}
};

// get field group container
Zymonic.Field.Field.prototype.getFieldGroupContainer = function(ident_only) {
	if (this.field_group_ident) {
		if (ident_only) {
			return this.field_group_ident+"_inner_div";
		} else {
			return $("#"+this.field_group_ident+"_inner_div");
		}
	}

	if (ident_only) {
		return null;
	} else {
		return $([]);
	}
};

// get tab field group container
Zymonic.Field.Field.prototype.getParentFieldGroups = function() {
	var field_groups = [];
	this.input_elements().parents(".FieldGroupSetContainer").each(function() {
		field_groups.push({
			container: $(this),
			tab:       $(".FieldGroupHeader[ident="+$(this).attr('id')+"]")
		});
	});
	return field_groups;
};

//gets all the dependent field idents on this field
Zymonic.Field.Field.prototype.getDependentFields = function() {
	var dependent_fields = [];
	
	for (var i=0; i< this.field_fill_calculations.length; ++i) {
		var ffc = this.field_fill_calculations[i];
		dependent_fields = dependent_fields.concat(ffc.getDependentFields());
	}
	
	return dependent_fields;
};

// have any values changed since the incoming timestamp
Zymonic.Field.Field.prototype.hasValueChangedSince = function(timestamp) {
	
	// if we've not had a value set yet, or the value was set after the timestamp
	if ( !this.value_last_changed_timestamp || this.value_last_changed_timestamp > timestamp ) {
		return true;
	}

	return false;
};


// returns the parent form this field is on
Zymonic.Field.Field.prototype.getParentForm = function() {
	if (this.parent_form_ident) {
		return Zymonic.lookup_object('Form', this.parent_form_ident);
	}
	
	return null;
};

// sets whether this field is required or not
Zymonic.Field.Field.prototype.setRequired = function(required) {
	this.required = required;
};

// checks for any unsaved changes in this field and highlights them
Zymonic.Field.Field.prototype.checkForUnsavedChanges = function() {
	if (   this.container_div().hasClass(this.FIELD_CHANGED_CLASS)
		|| ( !this.disableChangeDetection() && this.hasUnsavedBlockValue() )
	) {
		this.highlightUnsavedChanges();
		return true;
	}
	
	return false;
};

// highlights this field as having unsaved changes
Zymonic.Field.Field.prototype.highlightUnsavedChanges = function() {
	this.input_elements().addClass(this.FIELD_CHANGED_SHOW_CLASS);
	
	// higlight fieldgroups also
	var field_changed_show_class = this.FIELD_CHANGED_SHOW_CLASS
	this.getParentFieldGroups().forEach(function(fg) {
		// if there is a tab, highlight that
		if (fg.tab.length) {
			fg.tab.addClass(field_changed_show_class);
		} else {
			// if there is no matching tab, and the field group is nested, then highlight the whole group
			if (fg.container.parents('.FieldGroupSetContainer').length) {
				fg.container.addClass(field_changed_show_class);
			}
		}
	});
};