// datetime field object
Zymonic.Field.DateTime = function() {};

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

// generic function to add settings to a field object
Zymonic.Field.DateTime.prototype.setExtraArgs = function(args) {
	
	// call super to set the args
	Zymonic.Field.Field.prototype.setExtraArgs.call(this, args);
	
	// if any of the field map source fields change, clear our caches to lookup dates again
	var field = this;
	if (this.exclude_dates_field_maps) {
		for (var i=0; i<this.exclude_dates_field_maps.length; ++i) {
			var source_field = getZymonicField(this.exclude_dates_field_maps[i].source_field_ident);
			source_field.onChange(function() { field.clearExcludedDatesCache.call(field); });
		}
	}
}

// function to setup date_time_inputs
// This appears to be a mechanism which is being superceded by getDateTimeInputs which 
// uses the date time string. For the moment take care that neither method overwrites
// this.date_time_inputs (add to it instead)
Zymonic.Field.DateTime.prototype.addDateTimeInput = function(format, ident) {
	this.use_date_time_inputs = true;
	if (!this.date_time_inputs) {
		this.date_time_inputs = {};
	}
	
	if(!this.date_time_inputs[format]) {
		this.date_time_inputs[format] = {};
	}
	
	this.date_time_inputs[format]["ident"] = ident;

	this.addDefaultHandler($("#"+ident));
};

// function to setup date capture
Zymonic.Field.DateTime.prototype.setDateCapture = function(ident) {
	this.date_capture = true;
	this.date_capture_ident = ident;
	this.addDefaultHandler($("#"+ident));
};

// function to set up a JQuery datepicker using appropriate date format
Zymonic.Field.DateTime.prototype.setDatepicker = function(jqueryDateFormat) {
	var field = this;
	($("#"+this.date_capture_ident)).datepicker({
		dateFormat: jqueryDateFormat,
        changeMonth: true,
        changeYear: true,
		onChangeMonthYear: function(year, month) { field.fetchExcludedDates.call(field, ( month < 10 ? "0"+month : month ), year); },
		beforeShowDay: function(date) { return [ field.isValidDate.call(field, date), '', '' ]; },
		
		// onChangeMonthYear doesn't trigger when first showing a month
		// so call it from here to ensure excluded dates are looked up if needed
		beforeShow: function(input, date_picker) {
			var datetime = field.getDateTime() || new Date();
			var year = datetime.getFullYear();
			var month = datetime.getMonth()+1;
			field.fetchExcludedDates.call(
				field,
				( month < 10 ? "0"+month : month ), year,
				
				// if no valid dates for this first month then show next month
				function() {
					if (!field.getDateTime() && field.excluded_dates_by_month[year+"/"+( month < 10 ? "0"+month : month )]) {
						var excluded_dates = field.excluded_dates_by_month[year+"/"+( month < 10 ? "0"+month : month )];
						var days_in_month = new Date(year, month, 0).getDate();
						var has_valid_date = false;
						for (var day=1; day<=days_in_month; ++day) {
							if (field.isValidDate(new Date(year, month-1, day))){
								has_valid_date = true;
								break;
							}
						}
						if (!has_valid_date) {
							// no valid dates, hit the button for the next month to show
							// use settimeout to give the picker time to show so the next button can be "clicked"
							setTimeout(function(){ field.jquery("_date").datepicker("widget").find(".ui-datepicker-next").click(); }, 1);
						}
					}
				}
			);
		},
		
		// validate the date on selection, so we can correct any invalid dates and the error goes away
		// bug in this causes change handler not to run on the underlying input
		// so we have to explicitly trigger it
		onSelect: function(date) { field.validate.call(field); $(this).change(); }
	});
};

// function to setup time capture
Zymonic.Field.DateTime.prototype.setTimeCapture = function(ident) {
	this.time_capture = true;
	this.time_capture_ident = ident;
	this.addDefaultHandler($("#"+ident));
};

// get input elements 
Zymonic.Field.DateTime.prototype.input_elements = function() {
	// (Try and) Make sure date_time_inputs is populated
	this.getDateTimeInputs();
	var inputs = $();
	if (this.use_date_time_inputs) {
		for (var format in this.date_time_inputs) {
			inputs = inputs.add($("#"+this.date_time_inputs[format].ident));
		}
	} else {
		if (this.date_capture) {
			inputs = inputs.add($("#"+this.date_capture_ident));
		}
		if (this.time_capture) {
			inputs = inputs.add($("#"+this.time_capture_ident));
		}
	}
	
	return inputs;
};

// no basic validation, we have our own custom js validation
Zymonic.Field.DateTime.prototype.noBasicValidation = function() {
	return true;
};

// overwrite to add multiple values to the form
Zymonic.Field.DateTime.prototype.appendToForm = function(form_data, search) {
	var timestamp = this.getFullDateValue(true);
	
	// if we didn't get a timstamp then we've not got a valid date value
	// make suyre to send back empty values
	// otherwise, its a valid time, assemble the parts
	var value = "";
	if (this.use_date_time_inputs) {
		for (var format in this.date_time_inputs) {
			form_data.append(this.date_time_inputs[format].ident, ( timestamp ? $("#"+this.date_time_inputs[format].ident).val() : "" ));
		}
	} else {
		if (this.date_capture) {
			form_data.append(this.date_capture_ident, ( timestamp ? $("#"+this.date_capture_ident).val() : "" ));
		}
		if (this.time_capture) {
			form_data.append(this.time_capture_ident, ( timestamp ? $("#"+this.time_capture_ident).val() : "" ));
		}
	}
	
	// call super to handle the rest, e.g. check empty search flag
	Zymonic.Field.Field.prototype.appendToForm.call(this, form_data, search);
};

// get formats
Zymonic.Field.DateTime.prototype.getDateFormat = function() {
	var format = this.date_format;
	format = format.replace(/m/g,"M");
	return format
}
Zymonic.Field.DateTime.prototype.getTimeFormat = function() {
	var format = this.time_format;
	format = format.replace(/M/g,"m");
	format = format.replace(/S/g,"s");
	return format
}

Zymonic.Field.DateTime.prototype.clearValue = function() {
	// Set the inputs
	var inputs = this.getDateTimeInputs();
	if (inputs) {
		for (var input in inputs) {
			if(input == 'Month') {
				// Check the month format before setting the input
				if(inputs[input]["names"] && !inputs[input]["options"]) {
					this.jquery("_"+inputs[input]["format"]).val("");
				}
				else
				{
					this.jquery("_"+inputs[input]["format"]).val("");
				}
			} else {
				this.jquery("_"+inputs[input]["format"]).val("");
			}
		}
		
	} else {
		if (this.capture_date) {
			this.jquery("_date").val("");
		}
		if (this.capture_time) {
			this.jquery("_time").val("");
		}
	}

	// do value changed checks
	var value = "";
	this.setValueAsChanged(value, null);
	
	// 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();
	}
}

// setValue implementation for date
Zymonic.Field.DateTime.prototype.setValue = function(value, not_as_changed) {
	var inputs = this.getDateTimeInputs();

	var dateObj = Date.parse(value);

	var dateStr = dateObj.toString(this.getDateFormat());
	var timeStr = dateObj.toString(this.getTimeFormat());
	var input_values = new Array();
	input_values["H"] = dateObj.getHours();
	input_values["M"] = dateObj.getMinutes();
	input_values["d"] = dateObj.getDate();
	input_values["m"] = dateObj.getMonth(); // This returns 0-11 not sure if that is correct for 'input values')
	input_values["y"] = dateObj.getFullYear();
	input_values["duration"] = timeStr;

	const monthNames = ["January", "February", "March", "April", "May", "June",
  				"July", "August", "September", "October", "November", "December"];

	input_values["monthName"] = monthNames[dateObj.getMonth()];
	
	// Set the inputs
	if (inputs) {

		for (var input in inputs) {
			if(input == 'Month') {
				// Check the month format before setting the input
				if(inputs[input]["names"] && !inputs[input]["options"]) {
					this.jquery("_"+inputs[input]["format"]).val(input_values["monthName"]);
				}
				else
				{
					this.jquery("_"+inputs[input]["format"]).val(1*(input_values["m"])+1);
				}
			} else {
				this.jquery("_"+inputs[input]["format"]).val(input_values[inputs[input]["format"]]);
			}
		}
		
	} else {
		if (this.capture_date) {
			this.jquery("_date").val(dateStr);
		}
		if (this.capture_time) {
			this.jquery("_time").val(timeStr);
		}
	}

	// 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();
	}

}

// calculate the current date value as a timestamp
Zymonic.Field.DateTime.prototype.getFullDateValue = function(as_timestamp, as_datetime) {
	var inputs = this.getDateTimeInputs();
	var date;
	var time;
	var value_set = false;
	if (inputs) {
		var values_set = 0;
		var has_duration = false;
		var input_values = new Array();
		input_values["H"] = 0;
		input_values["M"] = 0;
		input_values["d"] = 0;
		input_values["m"] = 0;
		input_values["y"] = 0;
		input_values["duration"] = "";
		for (var input in inputs) {
			var field_val = this.jquery("_"+inputs[input]["format"]).val();
			if (field_val != "") {
				input_values[inputs[input]["format"]] = field_val;
				++values_set;
			}
			if(inputs[input]["format"] == "duration") {
				// split the input into hours and minutes
				var durationParts = field_val.split(":");
				input_values["H"] = durationParts[0];
				input_values["M"] = durationParts[1];
			}
		}
		
		// Only return if all inputs have been set
		if (values_set < size(inputs)) {
			return false;
		} else {
			value_set = true;
		}
		
		if (value_set) {
			if (this.capture_date) {
				date = new Date(input_values["y"], input_values["m"], input_values["d"], 0, 0, 0, 0);
			}
			if (this.capture_time) {
				time = new Date(0, 0, 0, input_values["H"], input_values["M"], 0, 0);
			}
		}
	} else {
		if (this.capture_date) {
			var date_val = this.jquery("_date").val();
			if (date_val) {
				var date_format_string = this.jquery("_date").datepicker('option', 'dateFormat');
				date_format_string = date_format_string.replace(/y/g,"yy");
				date_format_string = date_format_string.replace(/m/g,"M");
				date = new Date.parseExact(date_val, date_format_string);
				value_set = true;
				if (isNaN(date)) {
					date = new Date("Invalid");
				}
			}
		}
		if (this.capture_time) {
			var time_val = this.jquery("_time").val();
			if (time_val) {
				// use any date so it parses, only need the time of it
				time = new Date("01/01/01 "+time_val);
				value_set = true;
				if (isNaN(time.getTime()) || (this.capture_date && !date)) {
					time = new Date("Invalid");
				}
			}
		}
	}
	
	if (value_set) {
		if (as_timestamp) {
			return new Date(
				(date ? date.getFullYear() : 0),
				(date ? date.getMonth()    : 0), 
				(date ? date.getDate()     : 0),
				(time ? time.getHours()    : 0),
				(time ? time.getMinutes()  : 0),
				0, 0
			).getTime() / 1000;
		} else if (as_datetime) {
			return new Date(
				(date ? date.getFullYear() : 0),
				(date ? date.getMonth()    : 0), 
				(date ? date.getDate()     : 0),
				(time ? time.getHours()    : 0),
				(time ? time.getMinutes()  : 0),
				0, 0
			);
		}else {
			var datetime = 
			      ( date ? date.toString(this.getDateFormat()) : "" )
			    + ( time ? ( date ? " " : "") + time.toString(this.getTimeFormat()) : "" )
			;
			return datetime;
		}
	} else {
		if(this.jquery().val()) {
			// Return the 'raw' hidden input in read-only mode.
			if (as_timestamp) {
				return new Date(		
					this.jquery().val()
				).getTime() / 1000;
			} else if (as_datetime) {
				return new Date(
					this.jquery().val()
				);
			} else {
				return this.jquery().val();
			}
		}
		else
		{
			return false;
		}
	}
}

// assembles list of inputs used by this datetime fields
Zymonic.Field.DateTime.prototype.getDateTimeInputs = function ()
{
	if (this.date_time_inputs_cached) return this.date_time_inputs;

	// datetime inputs can be set-up by the XSL, but appear to be incomplete
	// therefore we only use those (which will be in this.date_time_inputs)
	// if there is no datetime_input_string to use
	if (!this.datetime_input_string) {
		if(this.date_time_inputs) {
			return this.date_time_inputs;
		} else {
			return false;
		}
	}
	
	this.use_date_time_inputs = true;

	this.date_time_inputs_cached = true;
	
	this.date_time_inputs = new Array();
	
	var inputs = this.datetime_input_string.split(",");
	for (var i = 0; i < inputs.length; i++) {
		var matches;
		var current;
		if (matches = inputs[i].match(/^H(\+?)$/)) {
			current = "Hour";
			this.date_time_inputs["Hour"] = new Array();
			this.date_time_inputs["Hour"]["position"] = i;
			this.date_time_inputs["Hour"]["format"] = "H";
			if (matches[1]) {
				this.date_time_inputs["Hour"]["options"] = true;
			} else {
				this.date_time_inputs["Hour"]["options"] = false;
			}
		} else if (matches = inputs[i].match(/^M(\+?)$/)) {
			current = "Minute";
			this.date_time_inputs["Minute"] = new Array();
			this.date_time_inputs["Minute"]["position"] = i;
			this.date_time_inputs["Minute"]["format"] = "M";
			if (matches[1]) {
				this.date_time_inputs["Minute"]["options"] = true;
			} else {
				this.date_time_inputs["Minute"]["options"] = false;
			}
		} else if (matches = inputs[i].match(/^d(\+?)$/)) {
			current = "Day";
			this.date_time_inputs["Day"] = new Array();
			this.date_time_inputs["Day"]["position"] = i;
			this.date_time_inputs["Day"]["format"] = "d";
			if (matches[1]) {
				this.date_time_inputs["Day"]["options"] = true;
			} else {
				this.date_time_inputs["Day"]["options"] = false;
			}
		} else if (matches = inputs[i].match(/^([mn])(\+?)$/)) {
			current = "Month";
			this.date_time_inputs["Month"] = new Array();
			this.date_time_inputs["Month"]["position"] = i;
			this.date_time_inputs["Month"]["format"] = "m";
			if (matches[1] == 'n') {
				this.date_time_inputs["Month"]["names"] = true;
			} else {
				this.date_time_inputs["Month"]["numbers"] = true;
			}
			if (matches[2]) {
				this.date_time_inputs["Month"]["options"] = true;
			} else {
				this.date_time_inputs["Month"]["options"] = false;
			}
		} else if (matches = inputs[i].match(/^DU\.(\d+).(\d+).(\d+)$/)) {
			current = "duration";
			this.date_time_inputs["duration"] = new Array();
			this.date_time_inputs["duration"]["position"] = i;
			this.date_time_inputs["duration"]["format"] = "duration";
			this.date_time_inputs["duration"]["options"] = true;
		} else if (matches = inputs[i].match(/^y(?:(\+)(\d*))?(?:(\-)(\d*))?$/)) {
			current = "Year";
			this.date_time_inputs["Year"] = new Array();
			this.date_time_inputs["Year"]["position"] = i;
			this.date_time_inputs["Year"]["format"] = "y";
			
			var start = new Date().getFullYear();
			var end = start
			if (matches[4]) start -= matches[4];
			if (matches[2]) end   += matches[2];
			
			if (matches[1] || matches[3]) {
				this.date_time_inputs["Year"]["options"] = true;
				this.date_time_inputs["Year"]["from"] = start;
				this.date_time_inputs["Year"]["to"] = end;
			} else {
				this.date_time_inputs["Year"]["options"] = false;
			}
		}

		// Set the ident
		this.date_time_inputs[current]["ident"] = this.ident + "_" + this.date_time_inputs[current]["format"];
	}
	return this.date_time_inputs;
}

Zymonic.Field.DateTime.prototype.getValue = function() {

	// apply any field fills
	var ffc_value = this.runFieldFillCalculations();

	// 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);
	}
	
	return this.getFullDateValue();
}

// returns a DateTime object
Zymonic.Field.DateTime.prototype.getDateTime = function() {
	return this.getFullDateValue(false, true);
}

Zymonic.Field.DateTime.prototype.fetchExcludedDates = function(month, year, cb) {
	
	if (!this.exclude_dates_filter_zname) {
		if (cb) { cb(); }
		return;
	}
	
	// if we have them or they are being fetched then nothing to do
	var year_month = year+"/"+month;
	if ( this.excluded_dates_by_month[year_month] || this.fetching_excluded_dates == year_month ) {
		if (cb) { cb(); }
		return;
	}
	
	// if fetching another month then abort it was user has moved on
	var request_key = this.ident+"_fetch_exclude_dates";
	if ( this.fetching_excluded_dates ) {
		Zymonic.abort_ajax_request(request_key, Zymonic.ajax_request_type.FILTER);
	}
	
	// make an ajax request to the exclude_date_filter for the incoming month and year
	this.fetching_excluded_dates = year_month;
	var search_fields = {};
	var format = this.exclude_dates_search_date_format.replace(/m/g,"M");
	search_fields[this.exclude_dates_search_date_zname] = new Date(year, month-1, 1, 12).toString(format);
	for (var i=0; i<this.exclude_dates_field_maps.length; ++i) {
		var field = getZymonicField(this.exclude_dates_field_maps[i].source_field_ident);
		if (field) {
			search_fields[this.exclude_dates_field_maps[i].destination_field] = field.getValue();
		}
	}
	
	// block date picker, do this in timeout as some kind of rendering order which
	// means it doesn't block if called directly
	// we block just the calendar within so can still navigate months
	var unblock = null;
	var field = this;
	setTimeout(
		function () {
			unblock = loading_gui_element( field.jquery("_date").datepicker("widget").find(".ui-datepicker-calendar"), true );
		},
		1
	);
	
	Zymonic.filter_request(
		this.exclude_dates_filter_zname,
		search_fields,
		true,
		request_key,
		function( xml, results ) {
			field.fetching_excluded_dates = null;
			field.parseExcludeDatesResult(month, year, results);
			if (cb) { cb(); }
			
			// when unblocking reload the picker for that month to pick up the new dates
			field.jquery("_date").datepicker("refresh")
			unblock();
		},
		function(type, error) {
			field.fetching_excluded_dates = null;
			unblock();
			 
			// log any errors
			Zymonic.log("Error fetching exclude dates: "+type+" - "+error);
		}
	)
};

Zymonic.Field.DateTime.prototype.parseExcludeDatesResult = function(month, year, results) {
	
	// add empty result first
	var year_month = year+"/"+month;
	this.excluded_dates_by_month[year_month] = {};
	
	// add dates from the first report
	var report = results[0];
	if (!report) {
		return;
	}
	for (var i=0; i<report.results.length; ++i) {
		if ( report.results[i].fields[this.exclude_dates_date_zname] ) {
			// TODO: how to do something like strptime to parse this correctly?
			var date = new Date(report.results[i].fields[this.exclude_dates_date_zname]);
			var date_value = date.toString( this.getDateFormat() )
			this.excluded_dates_by_month[year_month][date_value] = true; 
		}
	}
};

Zymonic.Field.DateTime.prototype.isValidDate = function(date) {
	
	// check in cache
	var year  = date.getFullYear();
	var month = date.getMonth()+1;
	var year_month = year+"/"+( month < 10 ? "0"+month : month );
	var date_value = date.toString( this.getDateFormat() ) ;
	if ( this.excluded_dates_by_month[year_month] && this.excluded_dates_by_month[year_month][date_value] ) {
		return false;
	}
	
	return true;
};

Zymonic.Field.DateTime.prototype.clearExcludedDatesCache = function(date) {
	this.excluded_dates_by_month = {};
	
	// if there is a current value, fetch fresh dates and validate
	// block the field to indicate the validation
	var datetime = this.getDateTime();
	if (datetime) {
		var year = datetime.getFullYear();
		var month = datetime.getMonth()+1;
		var field = this;
		var unblock = loading_gui_element( this.container_div(), true );
		this.fetchExcludedDates(( month < 10 ? "0"+month : month ), year, function() { field.validate(); unblock(); });
	}
};

Zymonic.Field.DateTime.prototype.validate = function(validOnly) {

	this.clearErrors();
	
	// check date against excluded dates
	var datetime = this.getDateTime();
	if (datetime && !this.isValidDate(datetime)) {
		this.setError("Invalid Date");
		return false;
	}
	
	// then call super
	return Zymonic.Field.Field.prototype.validate.call(this, validOnly);
};

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

// return current value as seconds from epoch
Zymonic.Field.DateTime.prototype.epoch = function() {
	return Math.floor( this.getDateTime() / 1000 );
};