#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <math.h>

#include <gtk/gtk.h>
#include <glib.h>
#include <glib/gstdio.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>

#include "globals.h"
#include "tile_management.h"
#include "route.h"
#include "wp.h"
#include "interface.h"
#include "support.h"
#include "converter.h"
#include "map_management.h"
#include "util.h"
#include "tracks.h"

#define GPX_ENCODING "utf-8"

/**
 * This is a GSList containing the waypoints of the route
 * which we are planing. It is the central data structure for route.c
 */
static GSList *route = NULL;

static GdkPixbuf	*wp_icon = NULL;
static int              wp_icon_width = 0;
static int              wp_icon_height = 0;

/**
 * Clear the route.
 */
void
reset_route ()
{
	route = NULL;
}

/**
 * Append a new waypoint at the end of the route.
 */
void
append_waypoint_to_route (double lat, double lon)
{
	waypoint_t *tp = g_new0 (waypoint_t,1);

	tp->lat = lat;
	tp->lon = lon;

	route = g_slist_append (route, tp);
}

/**
 * Change the position of the given waypoint to the new position.
 */
void
change_waypoint_of_route (waypoint_t *tp, double lat, double lon)
{
	tp->lat = lat;
	tp->lon = lon;
}

/**
 * Delete the given waypoint from the route.
 */
void
delete_waypoint_of_route (waypoint_t *wp)
{
	route = g_slist_remove (route, wp);
	g_free (wp);
}

/**
 * Insert a new waypoint before the given waypoint. This waypoint lies
 * between the given waypoint and the waypoint before this waypoint.
 */
void
insert_waypoint_before_of_route (waypoint_t *wp)
{
	waypoint_t *previous_wp;
	int position;

	position = g_slist_index (route, wp);
	if (position > 0) {
		previous_wp = g_slist_nth_data (route, position - 1);

		waypoint_t *new_wp = g_new0 (waypoint_t,1);

		new_wp->lat = previous_wp->lat - (previous_wp->lat - wp->lat) / 2;
		new_wp->lon = previous_wp->lon - (previous_wp->lon - wp->lon) / 2;

		route = g_slist_insert (route, new_wp, position + 0);
	}
}

/**
 * Find the waypoint which wp_icon is at the given mouse position.
 * Return that waypoint or NULL if none was found.
 */
waypoint_t *
find_routepoint (int mouse_x, int mouse_y)
{
	GSList *list;
	double lat;
	double lon;
	int pixel_x, pixel_y, x,y;

	for (list = route; list != NULL; list = list->next)
	{
		waypoint_t *tp = list->data;

		lat = tp->lat;
		lon = tp->lon;

		pixel_x = lon2pixel (global_zoom, lon);
		pixel_y = lat2pixel (global_zoom, lat);

		x = pixel_x - global_x + wp_icon_width / 2;
		y = pixel_y - global_y - wp_icon_height / 2;

		if (abs (x - mouse_x) < wp_icon_width / 2 &&
		    abs (y - mouse_y) < wp_icon_height / 2)
		{
			return tp;
		}
	}

	return NULL;
}

static
void
draw_arrow (GdkGC *gc, int start_x, int start_y, int end_x, int end_y)
{
	int x1,y1,x2,y2;
	double angle = atan2 (end_y - start_y, end_x - start_x) + M_PI;
	double arrow_length = 20;
	double arrow_degrees = M_PI / 10;

	/* https://kapo-cpp.blogspot.com/2008/10/drawing-arrows-with-cairo.html */

	x1 = end_x + arrow_length * cos (angle - arrow_degrees);
	y1 = end_y + arrow_length * sin (angle - arrow_degrees);
	x2 = end_x + arrow_length * cos (angle + arrow_degrees);
	y2 = end_y + arrow_length * sin (angle + arrow_degrees);

	gdk_draw_line (pixmap, gc, start_x, start_y, end_x, end_y);
	gdk_draw_line (pixmap, gc, end_x, end_y, x1, y1);
	gdk_draw_line (pixmap, gc, x1, y1, x2, y2);
	gdk_draw_line (pixmap, gc, x2, y2, end_x, end_y);
}

static
void
draw_line_of_route (GdkGC *gc, int x1, int y1, int x2, int y2)
{
	if (abs (x1-x2) > 30 || abs (y1-y2) > 30) {
		/* Line is long enough. Draw arrow */
		draw_arrow (gc, x1, y1, x2, y2);
	} else {
		/* short line. Omit arrow. */
		gdk_draw_line (pixmap, gc, x1, y1, x2, y2);
	}
}

/**
 * This function draws the current route on the screen.
 */
void
paint_route ()
{
	GSList *list;
	int pixel_x, pixel_y, x,y, last_x = 0, last_y = 0;
	float lat, lon;
	GdkColor color;
	GdkGC *gc;
	gboolean is_line = FALSE;

	/* Load icon if not already loaded: */
	if (!wp_icon) {
		wp_icon        = load_wp_icon ();
		wp_icon_width  = gdk_pixbuf_get_width (wp_icon);
		wp_icon_height = gdk_pixbuf_get_height (wp_icon);
	}

	/* Create GC for drawing the route line */
	gc = gdk_gc_new (pixmap);
	color.green = 0;
	color.blue = 0;
	color.red = 50000;
	gdk_gc_set_rgb_fg_color (gc, &color);
	gdk_gc_set_line_attributes (gc, 5, GDK_LINE_SOLID,
	                            GDK_CAP_ROUND, GDK_JOIN_ROUND);

	/* [1] paint line first */
	for (list = route; list != NULL; list = list->next)
	{
		waypoint_t *tp = list->data;

		lat = tp->lat;
		lon = tp->lon;

		pixel_x = lon2pixel (global_zoom, lon);
		pixel_y = lat2pixel (global_zoom, lat);

		x = pixel_x - global_x;
		y = pixel_y - global_y;

		if (is_line)
		{
			draw_line_of_route (gc, last_x, last_y, x, y);
			gtk_widget_queue_draw_area (map_drawable,
			                            x-4, y-4, 8, 8);
		}

		last_x = x;
		last_y = y;

		is_line = TRUE;
	}

	/* [2] paint flags after line */
	for (list = route; list != NULL; list = list->next)
	{
		waypoint_t *tp = list->data;

		lat = tp->lat;
		lon = tp->lon;

		pixel_x = lon2pixel (global_zoom, lon);
		pixel_y = lat2pixel (global_zoom, lat);

		x = pixel_x - global_x;
		y = pixel_y - global_y;

		if (!wp_icon) {
			gdk_draw_arc (pixmap,
			              gc,
			              TRUE,
			              x-4, y-4,
			              8,8,
			              0,23040);
		} else {
			gdk_draw_pixbuf (pixmap,
			                 NULL,
			                 wp_icon,
			                 0,0,
			                 x,y-wp_icon_height,
			                 wp_icon_width,wp_icon_height,
			                 GDK_RGB_DITHER_NONE, 0, 0);

			gtk_widget_queue_draw_area (map_drawable,
			                            x, y-wp_icon_height,
			                            wp_icon_width,
			                            wp_icon_height);
		}
	}
}

/**
 * Find the bounding box of the given GSList containin waypoints.
 */
bbox_t
get_way_bbox (GSList *ways)
{
	GSList *list;
	bbox_t bbox;
	double lat, lon;

	bbox.lat1 =  -90;
	bbox.lon1 =  180;
	bbox.lat2 =   90;
	bbox.lon2 = -180;

	for (list = ways; list != NULL; list = list->next)
	{
		waypoint_t *tp = list->data;

		lat = tp->lat;
		lon = tp->lon;
		bbox.lat1 = (lat > bbox.lat1) ? lat : bbox.lat1;
		bbox.lat2 = (lat < bbox.lat2) ? lat : bbox.lat2;
		bbox.lon1 = (lon < bbox.lon1) ? lon : bbox.lon1;
		bbox.lon2 = (lon > bbox.lon2) ? lon : bbox.lon2;
	}

	return bbox;
}

/**
 * Write a single route point to the XML file in GPX format.
 */
static
void
write_rtept (xmlTextWriterPtr writer, waypoint_t *wp, int no)
{
	xmlTextWriterStartElement (writer, BAD_CAST "rtept");
	xmlTextWriterWriteFormatAttribute (writer, BAD_CAST "lat",
	                                   "%f", rad2deg (wp->lat));
	xmlTextWriterWriteFormatAttribute (writer, BAD_CAST "lon",
	                                   "%f", rad2deg (wp->lon));
	xmlTextWriterEndElement (writer); /* </rtept> */
}

/**
 * Save the route in GPX format to the given URI.
 */
void
save_route_as_gpx (const char *uri)
{
	int rc;
	xmlTextWriterPtr writer;
	int no;
	GSList *list;
	char now_as_string[200];
	struct tm now_as_tm;
	time_t now;

	if (uri == NULL) return;

	bbox_t bbox = get_way_bbox (route);

	/*
	 * this initialize the library and check potential ABI mismatches
	 * between the version it was compiled for and the actual shared
	 * library used.
	 */
	LIBXML_TEST_VERSION

	/* Create a new XmlWriter for uri, with no compression. */
	writer = xmlNewTextWriterFilename (uri, 0);
	if (writer == NULL) {
		printf ("testXmlwriterFilename: Error creating the xml writer\n");
		return;
	}

	/* We would like to indent the elements for better readability. */
	xmlTextWriterSetIndent (writer, 1);

	/* Start the document with the xml default for the version,
	 * encoding and the default for the standalone
	 * declaration. */
	rc = xmlTextWriterStartDocument (writer, "1.0", GPX_ENCODING, "no");
	if (rc < 0) {
		printf ("testXmlwriterFilename: Error at xmlTextWriterStartDocument\n");
		return;
	}

	xmlTextWriterStartElement (writer, BAD_CAST "gpx");
	xmlTextWriterWriteAttribute (writer, BAD_CAST "version",
	                                     BAD_CAST "1.1");
	xmlTextWriterWriteAttribute (writer, BAD_CAST "creator",
	                                     BAD_CAST PACKAGE_STRING);
	xmlTextWriterWriteAttribute (writer, BAD_CAST "xmlns:xsi",
	                                     BAD_CAST "http://www.w3.org/2001/XMLSchema-instance");
	xmlTextWriterWriteAttribute (writer, BAD_CAST "xmlns:topografix",
	                                     BAD_CAST "http://www.topografix.com/GPX/Private/TopoGrafix/0/1");
	xmlTextWriterWriteAttribute (writer, BAD_CAST "xmlns",
	                                     BAD_CAST "http://www.topografix.com/GPX/1/1");
	xmlTextWriterWriteAttribute (writer, BAD_CAST "xsi:schemaLocation",
	                                     BAD_CAST "http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd");

	xmlTextWriterStartElement (writer, BAD_CAST "metadata");

	/* save current time into GPX file: */
	time (&now);
	gmtime_r (&now, &now_as_tm);
	strftime (now_as_string, sizeof (now_as_string), "%Y-%m-%dT%H:%M:%SZ",
	          &now_as_tm);
	xmlTextWriterWriteElement (writer, BAD_CAST "time",
	                                   BAD_CAST now_as_string);

	xmlTextWriterStartElement (writer, BAD_CAST "bounds");
	xmlTextWriterWriteFormatAttribute (writer, BAD_CAST "minlat",
	                                   "%f", rad2deg (bbox.lat2));
	xmlTextWriterWriteFormatAttribute (writer, BAD_CAST "minlon",
	                                   "%f", rad2deg (bbox.lon1));
	xmlTextWriterWriteFormatAttribute (writer, BAD_CAST "maxlat",
	                                   "%f", rad2deg (bbox.lat1));
	xmlTextWriterWriteFormatAttribute (writer, BAD_CAST "maxlon",
	                                   "%f", rad2deg (bbox.lon2));
	xmlTextWriterEndElement (writer); /* </bounds> */

	xmlTextWriterEndElement (writer); /* </metadata> */

	xmlTextWriterStartElement (writer, BAD_CAST "rte");

	for (list = route, no = 1; list != NULL; list = list->next, no++)
	{
		waypoint_t *wp = list->data;
		write_rtept (writer, wp, no);
	}

	xmlTextWriterEndElement (writer); /* </rte> */
	xmlTextWriterEndElement (writer); /* </gpx> */

	xmlTextWriterEndDocument (writer);

	xmlFreeTextWriter (writer);
}

/**
 * Save a route to a TomTom ITN file format.
 */
void
save_route_as_tomtom_itn (const char *uri)
{
	FILE *tomtom;
	int no;
	GSList *list;

	if (uri == NULL) return;

	tomtom = fopen (uri, "w");
	if (tomtom == NULL) {
		perror ("opening file to save tomtom.");
	} else {
		for (list = route, no = 1;
		     list != NULL;
		     list = list->next, no++)
		{
			waypoint_t *wp = list->data;
			fprintf (tomtom, "%d|%d|WP%d|0\n",
			         (int) (rad2deg (wp->lon) * 100000),
			         (int) (rad2deg (wp->lat) * 100000),
			         no);
		}

		fclose (tomtom);
	}
}

/**
 * Take all routepoints from a DOM tree containing GPX nodes.
 */
static
GSList *
parse_gpx_routepoints (xmlNode *node)
{
	xmlNode *cur_node = NULL;
	GSList *list = NULL;

	for (cur_node = node; cur_node; cur_node = cur_node->next)
	{
		if (cur_node->type == XML_ELEMENT_NODE)
		{
			if (xmlStrEqual (cur_node->name, BAD_CAST "rtept"))
			{
				double lat, lon;
				waypoint_t *tp = g_new0 (waypoint_t, 1);

				lat = atof ((char *) xmlGetProp (cur_node,
				                                 BAD_CAST "lat"));
				lon = atof ((char *) xmlGetProp (cur_node,
				                                 BAD_CAST "lon"));

				tp->lat = deg2rad (lat);
				tp->lon = deg2rad (lon);

				list = g_slist_append (list, tp);
			}
		}
		list = g_slist_concat (list,
		                       parse_gpx_routepoints (cur_node->children));
	}

	return list;
}

/**
 * Load a route from a given GPX file.
 */
GSList *
load_route_as_gpx (const char *file)
{
  	GSList *list = NULL;
	xmlDoc *doc = NULL;
	xmlNode *root_element = NULL;

	LIBXML_TEST_VERSION

	doc = xmlReadFile (file, NULL, 0);
	if (doc == NULL)
	{
		printf ("error: could not parse file %s\n", file);
	}

	root_element = xmlDocGetRootElement (doc);
	list = parse_gpx_routepoints (root_element);
	xmlFreeDoc (doc);
	xmlCleanupParser ();

	return list;
}

/**
 * Load a route from a file with a supported file format.
 */
void
load_route (const char *filename)
{
	bbox_t bbox;

	if (filename == NULL) return;

	route = load_route_as_gpx (filename);
	if (route != NULL)
	{
		bbox = get_way_bbox (route);
		show_bbox (bbox);
	}
}


char *
choose_save_file (char *currentName)
{
	char *filename = NULL;
	GtkWidget *dialog;
	dialog = gtk_file_chooser_dialog_new ("Save File",
	                                      NULL,
	                                      GTK_FILE_CHOOSER_ACTION_SAVE,
	                                      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                      GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
	                                      NULL);
	gtk_file_chooser_set_do_overwrite_confirmation
		(GTK_FILE_CHOOSER (dialog), TRUE);
	gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog),
	                                   currentName);

	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
	{
		filename = gtk_file_chooser_get_filename
			(GTK_FILE_CHOOSER (dialog));
	}

	gtk_widget_destroy (dialog);

	return filename;
}

char *
choose_load_file ()
{
	char *filename = NULL;
	GtkWidget *dialog;
	dialog = gtk_file_chooser_dialog_new ("Open File", NULL,
	                                      GTK_FILE_CHOOSER_ACTION_OPEN,
	                                      GTK_STOCK_CANCEL,
	                                      GTK_RESPONSE_CANCEL,
	                                      GTK_STOCK_OPEN,
	                                      GTK_RESPONSE_ACCEPT,
	                                      NULL);

	if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
	{
		filename = gtk_file_chooser_get_filename
			(GTK_FILE_CHOOSER (dialog));
	}
	gtk_widget_destroy (dialog);

	return filename;
}