// basic JS needed for zymonic manual page

// setups up the filter api manual page form to be able to generate api requests
function setupFilterAPICallForm(filter_details) {
	
	// set default url and system from page url
	$("[name='url']").val(window.location.origin+"/zymonicmp");
	var system = window.location.pathname.match(/\/man\/(.*)\/Filter/);
	if (system && system[1]) {
		$("[name='system']").val(system[1]);
	}
	
	// populate fields
	updateFilterAPICallFields(filter_details)
	
	$("#generate_example").click(function() {
		var request = generateFilterAPICallRequest(filter_details);
		var request_to_send = convertRequestToFormat(request.request, $("[name='api_request_type']").val());
		var example_response = convertRequestToFormat(request.example_response, $("[name='api_response_type']").val());
		
		$("#FilterAPICallRequest pre code").text(censorOutput(request_to_send));
		$("#FilterAPICallResponse pre code").text(censorOutput(example_response));
		
		return false;
	});
	
	$("#send_request").click(function() {
		var request_type = $("[name='api_request_type']").val();
		var response_type = $("[name='api_response_type']").val();
		var request = generateFilterAPICallRequest(filter_details);
		var request_to_send = convertRequestToFormat(request.request, request_type);
		
		$("#FilterAPICallRequest pre code").text(censorOutput(request_to_send));
		$("#FilterAPICallResponse pre code").text("Sending Request ...");

		var data = setupDataForSending(request.request, request_type);
		$("#send_request").prop('disabled', true);
		if(request_type == "json") {
			$.ajax({
				url: $("[name='url']").val(),
				type: "POST",
				data: data,
				datatype: "json",
				contentType: "application/json",
				error: function(xhr, type, error) {
					$("#FilterAPICallResponse pre code").text("ERROR: "+type+"\n"+error);
					$("#send_request").prop('disabled', false);
				},
				success: function(incoming) {
					var response = convertResponseToFormat(incoming, response_type);
					$("#FilterAPICallResponse pre code").text(censorOutput(response));
					$("#send_request").prop('disabled', false);
				}
			});
		} else {
			// Send anything other than JSON using params and assume XML response	
			$.ajax({
				url: $("[name='url']").val(),
				type: "POST",
				data: data,
				error: function(xhr, type, error) {
					$("#FilterAPICallResponse pre code").text("ERROR: "+type+"\n"+error);
					$("#send_request").prop('disabled', false);
				},
				success: function(xml) {
					var response = convertResponseToFormat(xml, response_type);
					$("#FilterAPICallResponse pre code").text(censorOutput(response));
					$("#send_request").prop('disabled', false);
				}
			});
		}
		
		return false;
	});
}

// updates field inputs based on filter search fields
function updateFilterAPICallFields(filter_details) {
	var fields_container = $("#FilterAPICallSearchFields").empty();
	
	var input = buildFilterAPICallFormInput(filter_details);
	fields_container.append(input);
}

// builds a form to capture search fields for a filter
function buildFilterAPICallFormInput(filter_details) {	
	var form_container = $("<fieldset>", { class: "FilterPICallFormInputs", id: "search_fields" });
	form_container.append($("<legend>").text("Search Fields"));
	for (var i=0; i<filter_details.search_fields.length; ++i) {
		var field = filter_details.search_fields[i];
		var input = buildFilterAPICallSearchFieldInput(field);
		form_container.append(input);
	}
	
	return form_container;
}

// updates field inputs based on currently selected state
function buildFilterAPICallSearchFieldInput(field, ) {
	var label_text = field.display_name + " (" + field.zname + ")";
	if (field.label_suffix) {
		label_text += " "+field.label_suffix;
	}
	var label = $("<label>", { for: field.zname, 'class': ( field.required ? 'FilterAPICallFieldRequired' : '' ), title: field.description });
	label.append($("<a>", { href: "../Field/"+field.zname+"_api.html" }).text(label_text));
	if (field.values) {
		var select = $("<select>", { type: "text", name: field.zname } );
		select.append($("<option>", { value: "" } ).text("-- Pick a "+field.display_name+" --"));
		for (var i=0; i<field.values.length; ++i) {
			select.append($("<option>", { value: field.values[i].value } ).text(field.values[i].display_name));
		}
		label.append(select);
	} else {
		label.append($("<input>", { type: "text", name: field.zname }));
	}
	if(field.keyfield) {
		label.append($("<span>").text("Key field"));
	}
	return label;
}

//assembles api call request
function generateFilterAPICallRequest(filter_details) {
	var result = {
		request: {
			ZymonicRequest: {
				ZymonicHeader: {
					system: $("[name='system']").val(),
					webservicemode: "filter",
					debug: ( $("[name='debug']").is(':checked') ? 'true' : 'false' ),
					compact_output: ( $("[name='compact_output']").is(':checked') ? 'true' : 'false' ),
					no_display_attributes: "false",
				}
			}
		},
		example_response: { Zymonic: {} },
	};
	
	if ( $("[name='api_response_type']").val() == 'json' ) {
		result.request.ZymonicRequest.ZymonicHeader.json = 'true';
	}
	
	var username = $("[name='username']").val();
	if (username) {
		result.request.ZymonicRequest.Authentication = {
			username: $("[name='username']").val(),
			password: $("[name='password']").val(),
		};
	}
	
	// setup basic filter details
	result.request.ZymonicRequest[filter_details.zname] = {
		search: "Show Results",
	};
	
	// add search fields
	var form_request = generateFilterAPICallFormRequest(filter_details);
	for (var key in form_request) {
		result.request.ZymonicRequest[filter_details.zname][key] = form_request[key];
	}
	
	// add extras
	for (var key in filter_details.extra_header_params) {
		result.request.ZymonicRequest.ZymonicHeader[key] = filter_details.extra_header_params[key];
	}
	for (var key in filter_details.extra_params) {
		result.request.ZymonicRequest[filter_details.zname][key] = filter_details.extra_params[key];
	}
	
	return result;
}

// builds fragment of the request
function generateFilterAPICallFormRequest(filter_details) {
	
	var form_result = {};
	for (var i=0; i<filter_details.search_fields.length; ++i) {
		var field = filter_details.search_fields[i];
		var value = $("[name='"+field.zname+"']").val();
		if (value) {
			form_result[field.zname] = value;
		}
	}
	
	return form_result;
}

// setups up the process api manual page form to be able to generate api requests
function setupProcessAPICallForm(process_details) {
	
	// set default url and system from page url
	$("[name='url']").val(window.location.origin+"/zymonicmp");
	var system = window.location.pathname.match(/\/man\/(.*)\/Process/);
	if (system && system[1]) {
		$("[name='system']").val(system[1]);
	}
	
	// populate states and transitions, trigger transition update on state change
	updateProcessAPICallStates(process_details);
	updateProcessAPICallTransitions(process_details);
	updateProcessAPICallFields(process_details)
	
	$("#generate_example").click(function() {
		var request = generateProcessAPICallRequest(process_details);
		var request_to_send = convertRequestToFormat(request.request, $("[name='api_request_type']").val());
		var example_response = convertRequestToFormat(request.example_response, $("[name='api_response_type']").val());
		
		$("#ProcessAPICallRequest pre code").text(censorOutput(request_to_send));
		$("#ProcessAPICallResponse pre code").text(censorOutput(example_response));
		
		return false;
	});
	
	$("#send_request").click(function() {
		var request_type = $("[name='api_request_type']").val();
		var response_type = $("[name='api_response_type']").val();
		var request = generateProcessAPICallRequest(process_details);
		var request_to_send = convertRequestToFormat(request.request, request_type);
		
		$("#ProcessAPICallRequest pre code").text(censorOutput(request_to_send));
		$("#ProcessAPICallResponse pre code").text("Sending Request ...");

		var data = setupDataForSending(request.request, request_type);
		$("#send_request").prop('disabled', true);
		if(request_type == "json") {
		     $.ajax({
				url: $("[name='url']").val(),
		        type: "POST",
		        data: data,
		        datatype: "json",
		        contentType: "application/json",
				error: function(xhr, type, error) {
					$("#ProcessAPICallResponse pre code").text("ERROR: "+type+"\n"+error);
					$("#send_request").prop('disabled', false);
				},
				success: function(incoming) {
					var response = convertResponseToFormat(incoming, response_type);
					$("#ProcessAPICallResponse pre code").text(censorOutput(response));
					$("#send_request").prop('disabled', false);
				}
		     }
			);
		}
		else {
			// Send anything other than JSON using params and assume XML response	
			$.ajax({
				url: $("[name='url']").val(),
				type: "POST",
				data: data,
				error: function(xhr, type, error) {
					$("#ProcessAPICallResponse pre code").text("ERROR: "+type+"\n"+error);
					$("#send_request").prop('disabled', false);
				},
				success: function(xml) {
					var response = convertResponseToFormat(xml, response_type);
					$("#ProcessAPICallResponse pre code").text(censorOutput(response));
					$("#send_request").prop('disabled', false);
				}
			});
		}
		
		return false;
	});
	
	/*
* populate state/transition list with options and Js that changes transitions when state changes
* default state to the initial state
* handler on state change to add inputs for all forms on that state
* checkbox to include empty fields in the request or not
* ensure there is an option for no transition (to view the process) and no state (to lookup all details from a pid)
	 */
}

// updates states list with allowed states
function updateProcessAPICallStates(process_details) {
	var state_select = $("[name='state']");
	
	// always add an option for no state
	var option = $("<option>").attr('value', "").text("No State, i.e. load current state");
	state_select.append(option);
	
	// add rest of the states
	for (var i=0; i<process_details.states.length; ++i) {
		var state = process_details.states[i];
		var option = $("<option>", { value: state.zname }).text(state.display_name);
		if (process_details.initial_state == state.zname) {
			option.attr("selected", true)
		}
		state_select.append(option);
	}
	
	// trigger transition/fields update on state change
	state_select.change(function(){
		updateProcessAPICallTransitions(process_details);
		updateProcessAPICallFields(process_details);
	});
}

// updates transition list based on currently selected state
function updateProcessAPICallTransitions(process_details) {
	var state = $("[name='state']").val();

	var transition_select = $("[name='transition']").empty();
	
	// always add an option for no transition
	var option = $("<option>").attr('value', "").text("No Transition, i.e. load only");
	transition_select.append(option)
	
	// add rest of the transitions
	for (var i=0; i<process_details.transitions.length; ++i) {
		var transition = process_details.transitions[i];
		for (var j=0; j<transition.before_states.length; ++j) {
			if (state == transition.before_states[j]) {
				var option = $("<option>", { value: transition.zname}).text(transition.display_name);
				transition_select.append(option);
			}
		}
	}
}

// updates field inputs based on currently selected state
function updateProcessAPICallFields(process_details) {
	var fields_container = $("#ProcessAPICallFields").empty();
	
	var state = $("[name='state']").val();
	if (state) {
		var state_details;
		for (var i=0; i<process_details.states.length; ++i) {
			if (state == process_details.states[i].zname) {
				state_details = process_details.states[i];
				break;
			}
		}
		if (state_details && state_details.form) {
			var input = buildProcessAPICallFormInput(state_details.form);
			fields_container.append(input);
		}
	}
}

//updates field inputs based on currently selected state
function buildProcessAPICallFormInput(form, position) {
	if (!position) {
		position = 1;
	}
	
	var form_container = $("<fieldset>", { class: "ProcessAPICallFormInputs", id: form.zname+"_"+position });
	form_container.append($("<legend>").text(form.display_name));
	for (var i=0; i<form.fields.length; ++i) {
		var field = form.fields[i];
		var input = buildProcessAPICallFieldInput(field, position);
		form_container.append(input);
	}
	
	// Add a record id input
	var reclabel = $("<label>", { for: 'ZZrecord_'+position, title: 'Record ID' });
	reclabel.append($("<a>").text("Record ID"));
	reclabel.append($("<input>", { type: "text", name: "ZZrecord_"+position, value: "ZZNEW"+(form.multiple_records ? position : '') }));
	reclabel.append($("<span>").text("Replace ZZNEW[NUMBER] with the correct ID if using an existing process or nothing if using 'Key fields'"));
	form_container.append(reclabel);
	
	// if multiple records add a button to generate another record
	if (form.multiple_records) {
		var new_record = $("<button>").text("Another Record").click(function(){
			var input = buildProcessAPICallFormInput(form, position+1);
			form_container.parent().append(input);
			new_record.detach();
			return false;
		});
		form_container.append(new_record);
	}
	
	return form_container;
}

// updates field inputs based on currently selected state
function buildProcessAPICallFieldInput(field, position) {
	if (field.form) {
		return buildProcessAPICallFormInput(field.form);
	} else {
		var label_text = field.display_name + " (" + field.zname + ")";
		if (field.label_suffix) {
			label_text += " "+field.label_suffix;
		}
		var label = $("<label>", { for: field.zname+"_"+position, 'class': ( field.required ? 'ProcessAPICallFieldRequired' : '' ), title: field.description });
		label.append($("<a>", { href: "../Field/"+field.zname+"_api.html" }).text(label_text));
		if (field.values) {
			var select = $("<select>", { type: "text", name: field.zname+"_"+position } );
			for (var i=0; i<field.values.length; ++i) {
				select.append($("<option>", { value: field.values[i].value } ).text(field.values[i].display_name));
			}
			label.append(select);
		} else {
			label.append($("<input>", { type: "text", name: field.zname+"_"+position }));
		}
		if(field.keyfield) {
			label.append($("<span>").text("Key field"));
		}
		return label;
	}
}

// assembles api call request
function generateProcessAPICallRequest(process_details) {
	var result = {
		request: {
			ZymonicRequest: {
				ZymonicHeader: {
					system: $("[name='system']").val(),
					webservicemode: "process",
					debug: ( $("[name='debug']").is(':checked') ? 'true' : 'false' ),
					compact_output: ( $("[name='compact_output']").is(':checked') ? 'true' : 'false' ),
				}
			}
		},
		example_response: { Zymonic: {} },
	};
	
	if ( $("[name='api_response_type']").val() == 'json' ) {
		result.request.ZymonicRequest.ZymonicHeader.json = 'true';
	}
	
	var username = $("[name='username']").val();
	if (username) {
		result.request.ZymonicRequest.Authentication = {
			username: $("[name='username']").val(),
			password: $("[name='password']").val(),
		};
	}
	
	result.request.ZymonicRequest[process_details.zname] = {};
	var process_id = $("[name='process_id']").val();
	if (process_id) {
		result.request.ZymonicRequest[process_details.zname].ZymonicHeader = { process_id: process_id };
	}
	
	var transition = $("[name='transition']").val();
	if (transition) {
		result.request.ZymonicRequest[process_details.zname].Transition = transition;
	}
	
	var state = $("[name='state']").val();
	if (state) {
		var state_details;
		for (var i=0; i<process_details.states.length; ++i) {
			if (state == process_details.states[i].zname) {
				state_details = process_details.states[i];
				break;
			}
		}
		if (state_details && state_details.form) {
			var form_request = generateProcessAPICallFormRequest(state_details.form);
			for (var key in form_request) {
				result.request.ZymonicRequest[process_details.zname][key] = form_request[key];
			}
		}
	}
	
	return result;
}

// converts a request to the desired type
function generateProcessAPICallFormRequest(form, position, result) {
	if (!position) {
		position = 1;
	}
	if (!result) {
		result = {};
		result[form.zname] = [];
	}
	
	// check for this position form
	var form_container = $("#"+form.zname+"_"+position);
	if (!form_container.length) {
		return result;
	}
	
	// Record ID
	var recordid =  $("[name='ZZrecord_"+position+"']").val()
	var form_result = {};
	if(recordid) {
		form_result['attributes'] = {};
		form_result['attributes']['record'] = recordid;
	}
	
	for (var i=0; i<form.fields.length; ++i) {
		var field = form.fields[i];
		if (field.form) {
			var field_form_result = generateProcessAPICallFormRequest(field.form);
			form_result[field.zname] = {};
			form_result[field.zname][field.form.zname] = field_form_result;
		} else {
			var value = $("[name='"+field.zname+"_"+position+"']").val();
			if (value) {
				form_result[field.zname] = value;
			}
		}
	}

	
	if (form.multiple_records) {
		result[form.zname].push(form_result);
		result = generateProcessAPICallFormRequest(form, position+1, result);
	} else {
		result[form.zname] = form_result;
	}
	
	return result;
}

// converts a request to the desired type
function convertRequestToFormat(request, type) {
	if (type == "xml") {
		return convertToXML(request);
	} else if ( type == "json" ) {
		return JSON.stringify(request.ZymonicRequest);
	} else if ( type == "http" ) {
		return convertToHTTPParams(request);
	} else if ( type == "raw" ) {
		return request.toString();
	} else {
		throw new Error("Unknown format: "+type);
	}
	
	return null;
}

// converts a request to the desired type and assembles it as a hash to send in a request
function setupDataForSending(request, type) {
	var data = {};
	if (type == "xml") {
		data.xmldata = convertRequestToFormat(request, type);
	} else if ( type == "json" ) {
		data = JSON.stringify(request.ZymonicRequest);
	} else if ( type == "http" ) {
		// split on & into params
		var all_params = convertRequestToFormat(request, type);
		var params = all_params.split('&');
		for (var i=0; i<params.length; ++i) {
			var key_value = params[i].split('=');
			data[key_value[0]] = key_value[1];
		}
	} else {
		throw new Error("Unknown format: "+type);
	}
	
	return data;
}

// converts a a response to the desired type
function convertResponseToFormat(response, type) {
	
	// send back error if one is found
	if (typeof(response) == "string" && response.indexOf("Unfortunately a fault has occurred") != -1) {
		return response;
	}	
	
	if (type == "xml" || response instanceof XMLDocument ) {
		return new XMLSerializer().serializeToString(response);
	} else if ( type == "json" ) {
		if (response.json_mode) {
			return JSON.stringify(response);
		} else {
			return response;
		}
	} else if ( type == "raw" ) {
		return response;
	} else {
		throw new Error("Unknown format: "+type);
	}
	
	return null;
}

// converts an object to XML
function convertToXML(obj, indent) {
	if (!indent) { indent = ""; }
	
	var xml = "";
	for (var key in obj) {
		if (key == 'attributes') {
			// attributes dealt with earlier
		} else if (Array.isArray(obj[key])) {
			for (var i=0; i<obj[key].length; ++i) {
				var tmp_xml = {};
				tmp_xml[key] = obj[key][i];
				xml += convertToXML(tmp_xml, indent);
			}
		} else {
			xml += indent + "<" + key;
			
			if (typeof(obj[key]) == 'string') {
				xml += ">" + obj[key] + "</" + key + ">\n";
			} else {
				
				// check for any attributes
				if (obj[key].attributes) {
					for (name in obj[key].attributes) {
						xml += " "+name+"='"+obj[key].attributes[name]+"'";
					}
				}
				
				xml += ">\n";
				xml += convertToXML(obj[key], indent+"  ");
				xml += indent + "</" + key + ">\n";
			}
		}
	}
	
	return xml;
}

// converts an object to HTTP params
function convertToHTTPParams(obj, prefix, zname_set) {
	if (!prefix) { prefix = "_"; }
	
	var params = "";
	for (var key in obj) {
		if (key == 'attributes') {
			// attributes dealt with earlier
		} else if (key == 'Transition') {
			params += prefix+"_transition="+obj[key]+"&";
		} else if (Array.isArray(obj[key])) {
			for (var i=0; i<obj[key].length; ++i) {
				var tmp = {};
				tmp[key] = obj[key][i];
				params += convertToHTTPParams(tmp, prefix, zname_set)+"&";
			}
		} else {
			if (typeof(obj[key]) == 'string') {
				params += prefix+key+"="+obj[key]+"&";
			} else {
				var new_prefix = getHTTPParamPrefix(key, prefix);
				
				// the first thing we encounter which doesn't have a unique prefix
				// will be zname, so set that explictly
				if (!zname_set && new_prefix.indexOf(key) != -1) {
					params += "ZZBzname="+key+"&";
					zname_set = true;
				}
				
				// check for any attributes
				if (obj[key].attributes) {
					for (name in obj[key].attributes) {
						
						if (name == 'record') {
							params += new_prefix+"_ZZRECORD="+obj[key].attributes[name]+"&";
							
							// add record id to the prefix
							var record_keys = obj[key].attributes[name].split(',');
							for (var i=0; i<record_keys.length; ++i) {
								// TODO: convert record id to UTF8, e.g. perl is unpack( 'U*', $_ )
							}
						} else {
							params += new_prefix+name+"="+obj[key].attributes[name]+"&";
						}
					}
				}
				
				params += convertToHTTPParams(obj[key], new_prefix, zname_set)+"&";
			}
		}
	}
	
	// the above will add ZymonicRequest to idents, remove that
	params = params.replace(/ZymonicRequest/g, '');
	
	// ZymonicHeader is ZZ
	params = params.replace(/ZymonicHeader/g, 'ZZ');
	
	
	// strip trailing & before returning
	params = params.slice(0, -1);
	return params;
}

// converts a key to the prefix to use in a HTTP Param
function getHTTPParamPrefix(key, prefix) {
	if (key == 'ZymonicRequest') {
		return prefix;
	} else if (key == 'Authentication') {
		return 'ZA';
	} else if (key == 'ZymonicHeader') {
		return 'ZZ';
	} else {
		return prefix+key+"_";
	}
}

// censors any passwords
function censorOutput(incoming) {
	var outgoing = incoming;

	var password = $("[name='password']").val();
	if (password && outgoing) {
		outgoing = outgoing.replace(password, "CENSORED");
	}
	
	return outgoing;
}