// linked field object
Zymonic.Field.LinkedField = function() {};

// do the inheritance
Zymonic.Field.LinkedField.prototype = new Zymonic.Field.Field();
Zymonic.Field.LinkedField.prototype.constructor = this;

// Accept additional args (including filter)
Zymonic.Field.LinkedField.prototype.addArgs = function(args) {
	for (var key in args) {
		this[key] = args[key];
	}
	
	// if filter is set, set extra param on filter for ajax calls
	if (this.filter) {
		this.filter.addExtraParam('ZZFparent_fap_from_block', 'true');
		this.filter.addExtraParam('ZZignore_search_fields_as_block_params', 'true');
		
		// add and linking field lookups to the filter
		for (var i=0; i<this.linking_field_maps.length; ++i) {
			var lfm = this.linking_field_maps[i];
			this.filter.addFieldLookupParam( lfm.search_field_ident, lfm.source_field_ident );
		}
		
		// flag filter to skip result count and auto_refresh
		this.filter.setAutoCountRefresh(false);
		this.filter.setAutoResultRefresh(true);
	}
	
	// set linking fields on self to send those values so don't need to load up all parent forms
	// server side to use their values, just send them all here
	for (var i=0; i<this.linking_field_maps.length; ++i) {
		var lfm = this.linking_field_maps[i];
		this.addExtraFieldParam( lfm.source_field_zname, lfm.source_field_ident );
		for (var j=0; j<lfm.source_field_dependent_fields.length; ++j) {
			var sfdf = lfm.source_field_dependent_fields[j];
			this.addExtraFieldParam( sfdf.dependent_field_zname, sfdf.dependent_field_ident );
		}
	}
	
	// setup filter aciton handlers when the document is ready
	this.initialiseNewFilterActionHandlers();
};

// sets up handlers for autoselecting LF value from newly opened process
Zymonic.Field.LinkedField.prototype.initialiseNewFilterActionHandlers = function() {
	var lf = this;
	
	// make all filter actions which open a block auto close the LF, so block is not hidden "beneath" LF filter results
	var filter_actions = this.filter.getAllFilterActions();
	for (var i=0; i<filter_actions.length; ++i) {
		filter_actions[i].addBlockAddedCallback(lf.ident+"hide", function(process_xml, process_block_id) {
			lf.setNotInUse();
			lf.showCorrectSection();
		});
		
		// send flag so that if its a report from this LF filter, that the filter shows results for the report
		filter_actions[i].addExtraParam(lf.ident+"force_output_filter_results", "true");
	}
	
	// if there is a new filter action zname find that filter action in the filter
	if (this.new_filter_action_zname && this.new_process_source_field_zname) {
		this.initialiseUpdateFromFilterActionProcess( this.new_filter_action_zname, null, this.new_process_source_field_zname );
	}
	
	// same for editing
	if (this.edit_filter_action_ident && this.edit_process_source_field_zname) {
		this.initialiseUpdateFromFilterActionProcess( null, this.edit_filter_action_ident, this.edit_process_source_field_zname );
	}
};

// Initialise display
Zymonic.Field.LinkedField.prototype.initialiseUpdateFromFilterActionProcess = function(filter_action_zname, filter_action_ident, source_field_zname) {
	
	// if ident lookup directly, otherwise lookup via zname on filter
	var filter_action;
	if (filter_action_ident) {
		filter_action = Zymonic.lookup_object( 'FilterAction', this.ident + "_" + filter_action_ident );
	} else if (filter_action_zname) {
		filter_action = this.filter.getFilterAction(filter_action_zname);
	}
	if (filter_action) {
		
		// make the filter action send a param to force output if block autocloses
		filter_action.addExtraParam('force_output_on_deleted_block', 'true');
		
		// when the filter action has opened a block, find the process which was opened
		var lf = this;
		filter_action.addBlockAddedCallback(lf.ident,  function(process_xml, process_block_id) {
			var process_ident = $(process_xml).find("*[type='Process']").attr('ident');
			var process = Zymonic.lookup_object('Process', process_ident);
			if (process) {
				
				// when that process has a transition run, from the result find the
				// field from source_field_zname and set this value to it
				process.addTransitionRunCallback(lf.ident, function(saved_process_xml, saved_process_id) {
					var source_field_value = $(saved_process_xml).find(source_field_zname + " > Value").text();
					if (source_field_value) {
						lf.selectResult(source_field_value);
					}
				});
			}
		});
	}
}

// Initialise display
Zymonic.Field.LinkedField.prototype.initialiseDisplay = function() {
    
    // move any input errors to the container
    this.moveContainedValidationErrors();
    
    // Start closed.
    this.filterOpen = false;
    
    // hide the filter or selected fields (depending on state)
    this.showCorrectSection();

    // Attach the result row handlers
    this.attachResultRowHandlers();
    
    // Add click handlers to display fields and a displayfield class
    this.addDisplayFieldClick();

    // initialise parent blocked flag
    this.parentBlocked = false;

    // Add open button handler
    var thislf = this;
    $('#' + this.ident + "open_button").on('click', function(event) {
	event.preventDefault();
	thislf.valBeforeOpen = thislf.getValue();
	thislf.setInUse();
	thislf.showCorrectSection();
    });
    
    // Add the focus/blur behaviour
    getZymonicFieldsByWrapperIdent(this.filter.getIdent()).forEach(function(entry) {
    	entry.input_elements().each(function(index) {
			$(this).focus(function() {
			//    thislf.setInUse();
			});
		});
    });

    Zymonic.Utils.attach_event($('#' + this.ident + '_close_button'), "click", this.ident, function() {
        // re-select since the report results will have been reloaded
        thislf.setNotInUse();
        thislf.showCorrectSection();
    });
    Zymonic.Utils.attach_event($('#' + this.ident + '_clear_button'), "click", this.ident, function() { 
    	thislf.clearSelection(); 
    	thislf.setNotInUse(); 
        thislf.showCorrectSection();
    	return false; 
    });
};

Zymonic.Field.LinkedField.prototype.setInUse = function() {
	this.filterOpen = true;
    // hide any input errors on showing the filter
    var container_div = this.container_div();
    if (container_div.hasClass('hasFocus')) {
        return;
    }
    container_div.children('.inputError').hide();
    container_div.addClass('hasFocus');
    
    // skip js validation here so we don't get js popup errors
    // when the LF is first opened
    this.filter.refresh(null, null, null, null, this.filter.user_request_key, true);
};

Zymonic.Field.LinkedField.prototype.setNotInUse = function() {
	this.filterOpen = false;
    // show any input errors on showing the filter
    var container_div = this.container_div();
    if (!container_div.hasClass('hasFocus')) {
        return;
    }
    container_div.children('.inputError').show();
    container_div.removeClass('hasFocus');
    
    // clear all search fields, so LF opens fresh next time
    var search_fields = this.filter.getSearchFields();
    for (var i=0; i< search_fields.length; ++i) {
        search_fields[i].clearValue();
    }
    
    this.validate(true);
};

Zymonic.Field.LinkedField.prototype.addDisplayFieldClick = function() {
    var thislf = this;
    $('div[id^=' + this.ident + '_sr]').each(function(i, el) {
        // add click event to the div containing the field value
    	Zymonic.Utils.attach_event($(el).find("div[id^='" + thislf.ident + "_sr'][id$='display_only_value_container']"),
    							   "click", thislf.ident, function() {
            thislf.valBeforeOpen = thislf.getValue();
            thislf.setInUse();
            thislf.showCorrectSection();
            
            // find search field zname from the display container id, then find that search field in the filter to focus
            var rf_ident = $(this).attr('id').replace("_display_only_value_container", "");
            if (thislf.report_fields_to_search_fields[rf_ident]) {
                var sf = getZymonicField(thislf.report_fields_to_search_fields[rf_ident]);
                if (sf) {
                    sf.input_elements().focus();
                }
            }
    	});
    	$(el).addClass('LinkedFieldDisplayField');
    });
    
    // if field is required, move the required marker to the first display fields
    if (this.required) {
        // check for first marker which has *, if none then just grab any
        var container_div = this.container_div();
        var required_marker = container_div.find('.RequiredFieldMarker:contains("*"):first');
        if (required_marker.length == 0) {
            required_marker = container_div.find('.RequiredFieldMarker:first');
        }
        
        container_div.find(".LinkedFieldDisplayField:first .FieldLabelDiv label .RequiredFieldMarker").remove();
        container_div.find(".LinkedFieldDisplayField:first .FieldLabelDiv label").prepend(required_marker.clone());
    }
};

Zymonic.Field.LinkedField.prototype.clearSelection = function() {
    this.unselected = true;
    this.row = undefined;
    $('#' + this.ident + '_not_selected').attr('checked','checked');
    this.setValueAsChanged();

    // Clear the display fields
    $('[id^=' + this.ident + '].LinkedFieldDisplayField > span').html('');

    if(this.search_field == "true") {
        // Only bother sending to server if we are a search field
    	// This will clear the block param...
        // skip unsaved changes checks as we know the field value has changed
        this.skip_unsaved_changes_checks = true;
        this.reloadInPlace('', true, false, true, true, true, this.getFieldGroupContainer(true));
        this.skip_unsaved_changes_checks = false;
    }
    else
    {
    	this.showCorrectSection();
    }
};

// Ensure all fields get blocked
Zymonic.Field.LinkedField.prototype.getBlock = function(ident) {
	return loading_gui_element($("#" + ident), true);
};

// Linked Field needs to handle all of the returned fields. 
Zymonic.Field.LinkedField.prototype.replaceWithTransformedXML = function(ident, xml, wrapper_mode) {
    if(this.jquery('_div').parent().is('td.HorizontalFormTableCell')) {
        $(xml).find('Zymonic > *[type="Field"]').attr('horizontal','true');
    }
	
	// transform the result
	var zt = new Zymonic.Transformer.Transformer();
	var result = zt.TransformXML(xml);

    // Pick out the top-level field divs and replace them individually
	// IE gets different elements using childNodes, but children is ok in all browsers
	var thislf = this;
	var result_nodes = $(result).children();
    result_nodes.each(function(){
        if(this.nodeName == 'DIV') {
            var id = $(this).attr('id');
        	if($('#'+id).length) {
        	    $('#'+id).replaceWith(this);
        	} else {
        		thislf.container_div().append(this);
        	}
        	$('#' + id).addClass("partof_" + thislf.getFieldGroupIdent());
        	Zymonic.Utils.reRunJS($('#' + id));
        }
    });
    
    this.addDisplayFieldClick();
    
    // This seems to be needed when LFs are used as search fields.
    this.showCorrectSection();

}

// Show the correct section based on the 'unselected' attribute 
Zymonic.Field.LinkedField.prototype.showCorrectSection = function() {
	if(this.filterOpen) {
		// Show filter
	        $('#' + this.ident + '_LFF').show();

		// Focus first field
		var zFields = getZymonicFieldsByWrapperIdent(this.filter.getIdent());
		var zInputs = zFields[0].input_elements();
		$(zInputs[0]).focus();
		
		// Hide fields
 	        $('div[id^=' + this.ident + '_sr].ZymonicField').hide();

	} else {
	      // Hide filter 
  	      $('#' + this.ident + '_LFF').hide();
		
	      // Show fields
              $('div[id^=' + this.ident + '_sr].ZymonicField').show();

	}

	this.afterShowCorrectSection();
};

Zymonic.Field.LinkedField.prototype.afterShowCorrectSection = function() {
	return;
}

// Add handlers to the filters XML updated events
Zymonic.Field.LinkedField.prototype.addFilterEventHandlers = function() {
	var thislf = this;
	$(this.filter).bind('xmlReceived', function() {
		thislf.addOurAttibutesToFilterXML();
	});
	
    $(this.filter).bind('xmlTransformed', function() {
    	thislf.attachResultRowHandlers();
		thislf.initialiseNewFilterActionHandlers();
    });
};

// Add Linked Field attributes/elements to top-level results in filter XML
Zymonic.Field.LinkedField.prototype.addOurAttibutesToFilterXML = function() {
	var xmlDoc = this.filter.getXML();
    var thislf = this;
	
	// For each result in top level report
	$(xmlDoc).find("report:first > result").each(function(i, el) {
		// Add Linked field attribute
		// Unless they are already present
		if(!$(el).attr('LinkedFieldEntry')) {
			$(el).attr('LinkedFieldEntry', thislf.ident);
			$(el).attr('LinkedFieldType', thislf.type);
			$(el).attr('LinkedFieldSelected', '');
			$(el).attr('LinkedFieldValue', $(el).find(thislf.source_field_zname + " > Value").text());
		}
		
	});
	
	this.filter.setXML(xmlDoc);
};

//getValueFromInputs mechanism
Zymonic.Field.LinkedField.prototype.getValueFromInputs = function() {
       // if field is hidden or read only, then call super as there won't be a filter
       if (this.hidden || this.display_only ) {
           return Zymonic.Field.Field.prototype.getValueFromInputs.call(this);
       }
       var chkd = $('input[name="' + this.ident + '"]:checked');
       if(chkd.length) {
    	   return $(chkd).val();
       }
       else
       {
    	   if( $('input[name="' + this.ident + '"][type!="radio"]:hidden').val())
      	   return  $('input[name="' + this.ident + '"][type!="radio"]:hidden').val();
    	   return '';
       }
};

// setValue mechanism
Zymonic.Field.LinkedField.prototype.setValue = function(value, set_from_ffc) {
	
    // use flag to ensure we don't recurse through this
	if (this.setting_value) {
        Zymonic.log("Recursion prevented on setValue for LinkedField" + this.zname);
		return;
	}
    
	// if field is hidden or read only, then call super as there won't be a filter
	if (this.hidden || this.display_only ) {
		return Zymonic.Field.Field.prototype.setValue.call(this, value);
	}
	
	// check if it's already checked and stop if so
	var currently_selected_checkbox = $('input[name="' + this.ident + '"]:checked');
	if (currently_selected_checkbox.length && currently_selected_checkbox.val() == value) {
		return;
	}

    this.setting_value = true;

	// clear any checked values and mark value as changed
	currently_selected_checkbox.attr('checked','');
	
	// check if there is a checkbox for the desired value, create a new one if not found
	var desired_checkbox = $('input[name="' + this.ident + '"][value="' + value + '"]');
	if (desired_checkbox.length == 0) {
		desired_checkbox = $("<input />").attr('type', 'checkbox').attr('name', this.ident).val(value);
		$('input[name="' + this.ident + '"]').last().append(desired_checkbox);
	}
	
	// set the desired checkbox value to set the field value
	desired_checkbox.attr('checked','checked');
    
    // reload in-place to handle cases where a LF's value is changed from a FFC
    if (set_from_ffc) {
        var thislf = this;
        this.reloadInPlace([this.ident + '=' + value], true, false, true, true, true, this.getFieldGroupContainer(true), function() {
            var row = $('#' + thislf.filter.getIdent() + 'reportresults > table > tbody > tr')[0];
            if (row) {
                thislf.selectResult(value, row);
                thislf.setValueAsChanged();
            }
            else
            {
                thislf.clearSelection();
                Zymonic.log("Unable to find selected row on reload from FieldFillCalculation on LinkedField " + thislf.zname);
            }
        });
    }
    // flag value as updated, should trigger any FFCs or other event handlers on the LF
    // don't need to run if set_from_ffc as it's already called AFTER we do a reloadInPlace
    // to retrieve the actual value, doing it here too would trigger any handlers too early
    else {
        this.setValueAsChanged();
    }
    
    this.setting_value = false;
};


// Act on filter result clicked.
Zymonic.Field.LinkedField.prototype.selectResult = function(value, row) {
	
    this.row = row;
	this.setValue(value);
	
	// Ensure the unselected flag is cleared
	this.unselected = false;

	this.setNotInUse();

	// Unblock and reset the zindex
	if(this.parentBlocked) {
		this.unblockParentBlock();
		$('#' + this.ident + '_LFF').css('z-index', this.originalLFFz);
	}

	// Hide the Filter since it jumps around before the reload
	$('#' + this.ident + '_LFF').hide();

	// do the field reload, on success validate again with the new values to trigger any dependent validations
	// skip unsaved changes checks as we know the field value has changed
	var lf = this;
	var fieldgroupcontainer = this.getFieldGroupContainer(true);
	this.skip_unsaved_changes_checks = true;
	this.reloadInPlace('', true, false, true, true, true, fieldgroupcontainer, function() {
		lf.validate(true);
		$('#' + fieldgroupcontainer).css('position', 'initial');
	});
	this.skip_unsaved_changes_checks = true;
};

// Attach handlers to the filter's top-level result rows
Zymonic.Field.LinkedField.prototype.attachResultRowHandlers = function() {
        var thislf = this;
        
        this.beforeAttachResultRowHandlers();

        // Hide the linked field selector header.
        $('#' + this.filter.getIdent() + 'reportresults .LinkedFieldSelectorHeader').hide();

        // Loop through the table rows that have a td with class FilterLinkedFieldCell
        $('#' + this.filter.getIdent() + 'reportresults > table > tbody > tr').each(function() {
        	thislf.initialiseUnselectedResultRow(this);
        });
};

// Stub
Zymonic.Field.LinkedField.prototype.beforeAttachResultRowHandlers = function() {
	return;
};

Zymonic.Field.LinkedField.prototype.initialiseUnselectedResultRow = function(row) {
	var thislf = this;
    var FLFC = $(row).find('.FilterLinkedFieldCell');

    if(FLFC.length) {
            // Hide the FilterLinkedFieldCell td
            $(FLFC).hide();

            // For each td that contains a ReportField class div add an onclick handler to the div  
	    /*
            $(row).find('.ReportField').each(function() {
                	$(this).unbind('click');
                	Zymonic.Utils.attach_event($(this), "click", this.ident, function() {
                            thislf.selectResult($(FLFC).find('input').val(), row);
                    });
                    $(this).addClass('LFSelectable');
            });
	    */
	   // Full row selection variant
	   $(row).unbind('click');
	   Zymonic.Utils.attach_event($(row), "click", this.ident, function() {
		thislf.selectResult($(FLFC).find('input').val(), row);
	   });
	   $(row).addClass('LFSelectable');
            
            this.unselectedRowFound(FLFC);
    }
	
};

// Stub function only used by MCLF
Zymonic.Field.LinkedField.prototype.unselectedRowFound = function(FLFC) {
	return;
};


// Return correct div
Zymonic.Field.LinkedField.prototype.container_div = function() {
	return this.getFieldGroupContainer();
};

Zymonic.Field.LinkedField.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.LinkedField.prototype.validationErrorsSet = function() {
	// copy errors to the container div
	var container_div = this.container_div();
	container_div.addClass('FieldContainsError').removeClass('FieldIsValid').children('.inputError').remove();
	this.moveContainedValidationErrors();
};
Zymonic.Field.LinkedField.prototype.validationErrorsCleared = function() {
	// clear errors on parent field group
	this.container_div().addClass('FieldIsValid').removeClass('FieldContainsError').children('.inputError').remove();
};
Zymonic.Field.LinkedField.prototype.moveContainedValidationErrors = function() {
	// copy errors to the container div
	var container_div = this.container_div();
	container_div.find('.inputError').detach().appendTo(container_div);
};

Zymonic.Field.LinkedField.prototype.getFields = function() {
	var super_fields = Zymonic.Field.Field.prototype.getFields.call(this);
	var search_fields = (this.filter ? this.filter.getSearchFields() : []);
	return super_fields.concat(search_fields);
};

Zymonic.Field.LinkedField.prototype.getFieldValue = function(field_zname) {
	var fieldLookup = '';
    	if (this.row)
    	{
        	var fieldContainer = $(this.row).find("." + field_zname);
		if(fieldContainer.length == 0) {
			Zymonic.log_error("ZYMONIC DEVELOPER WARNING: Unable to find ReportField " + field_zname + " on LinkedField " + this.zname + " - check your field fill and linked fields are correctly defined.");
		}
		else
		{
			fieldLookup = $(fieldContainer).find("span.ReadOnlyFieldValue").text();
			if(!fieldLookup) {
				fieldLookup = $(fieldContainer).find("input").val();
			}
   		}
    	}
    	else
    	{
        	Zymonic.log("No row selected on LinkedField " + this.zname);
    	}
        return fieldLookup;
};