/*
 * Copyright (C) 2010 Andy Spencer <andy753421@gmail.com>
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#include <grits.h>
#include <GL/gl.h>
#include <stdio.h>
#include <string.h>

#include "alert.h"
#include "alert-info.h"

/**********
 * Alerts *
 **********/
/* Data types */
typedef struct {
	char sep0;
	char class [1 ]; char sep1;
	char action[3 ]; char sep2;
	char office[4 ]; char sep3;
	char phenom[2 ]; char sep4;
	char signif[1 ]; char sep5;
	char event [4 ]; char sep6;
	char begin [12]; char sep7;
	char end   [12]; char sep8;
} AWeatherVtec;

typedef struct {
	char *title;   // Winter Weather Advisory issued December 19 at 8:51PM
	char *link;    // http://www.weather.gov/alerts-beta/wwacapget.php?x=AK20101219205100AFGWinterWeatherAdvisoryAFG20101220030000AK
	char *summary; // ...WINTER WEATHER ADVISORY REMAINS IN EFFECT UNTIL 6
	struct {
		time_t  effective;  // 2010-12-19T20:51:00-09:00
		time_t  expires;    // 2010-12-20T03:00:00-09:00
		char   *status;     // Actual
		char   *urgency;    // Expected
		char   *severity;   // Minor
		char   *certainty;  // Likely
		char   *area_desc;  // Northeastern Brooks Range; Northwestern Brooks Range
		char   *fips6;      // 006015 006023 006045 006105
		AWeatherVtec *vtec; // /X.CON.PAFG.WW.Y.0064.000000T0000Z-101220T0300Z/
	} cap;
} AWeatherAlert;

/* Alert parsing */
typedef struct {
	AWeatherAlert *alert;
	GList         *alerts;
	gchar         *text;
	gchar         *value_name;
} ParseData;
time_t parse_time(gchar *iso8601)
{
	GTimeVal tv = {};
	g_time_val_from_iso8601(iso8601, &tv);
	return tv.tv_sec;
}
AWeatherVtec *parse_vtec(char *buf)
{
	AWeatherVtec *vtec = g_new0(AWeatherVtec, 1);
	strncpy((char*)vtec, buf, sizeof(AWeatherVtec));
	vtec->sep0 = vtec->sep1 = vtec->sep2 = '\0';
	vtec->sep3 = vtec->sep4 = vtec->sep5 = '\0';
	vtec->sep6 = vtec->sep7 = vtec->sep8 = '\0';
	return vtec;
}
void alert_start(GMarkupParseContext *context, const gchar *name,
		const gchar **keys, const gchar **vals,
		gpointer user_data, GError **error)
{
	//g_debug("start %s", name);
	ParseData *data = user_data;
	if (g_str_equal(name, "entry"))
		data->alert  = g_new0(AWeatherAlert, 1);
}
void alert_end(GMarkupParseContext *context, const gchar *name,
		gpointer user_data, GError **error)
{
	//g_debug("end %s", name);
	ParseData     *data  = user_data;
	AWeatherAlert *alert = data->alert;
	char          *text  = data->text;

	if (g_str_equal(name, "entry"))
		data->alerts = g_list_prepend(data->alerts, data->alert);

	if (!text || !alert) return;
	if      (g_str_equal(name, "title"))         alert->title         = g_strdup(text);
	else if (g_str_equal(name, "id"))            alert->link          = g_strdup(text); // hack
	else if (g_str_equal(name, "summary"))       alert->summary       = g_strdup(text);
	else if (g_str_equal(name, "cap:effective")) alert->cap.effective = parse_time(text);
	else if (g_str_equal(name, "cap:expires"))   alert->cap.expires   = parse_time(text);
	else if (g_str_equal(name, "cap:status"))    alert->cap.status    = g_strdup(text);
	else if (g_str_equal(name, "cap:urgency"))   alert->cap.urgency   = g_strdup(text);
	else if (g_str_equal(name, "cap:severity"))  alert->cap.severity  = g_strdup(text);
	else if (g_str_equal(name, "cap:certainty")) alert->cap.certainty = g_strdup(text);
	else if (g_str_equal(name, "cap:areaDesc"))  alert->cap.area_desc = g_strdup(text);

	if (g_str_equal(name, "valueName")) {
		if (data->value_name)
			g_free(data->value_name);
		data->value_name = g_strdup(text);
	}

	if (g_str_equal(name, "value") && data->value_name) {
		if (g_str_equal(data->value_name, "FIPS6")) alert->cap.fips6 = g_strdup(text);
		if (g_str_equal(data->value_name, "VTEC"))  alert->cap.vtec  = parse_vtec(text);
	}
}
void alert_text(GMarkupParseContext *context, const gchar *text,
		gsize len, gpointer user_data, GError **error)
{
	//g_debug("text %s", text);
	ParseData *data = user_data;
	if (data->text)
		g_free(data->text);
	data->text = strndup(text, len);
}

/* Alert methods */
GList *alert_parse(gchar *text, gsize len)
{
	g_debug("GritsPluginAlert: alert_parse");
	GMarkupParser parser = {
		.start_element = alert_start,
		.end_element   = alert_end,
		.text          = alert_text,
	};
	ParseData data = {};
	GMarkupParseContext *context =
		g_markup_parse_context_new(&parser, 0, &data, NULL);
	g_markup_parse_context_parse(context, text, len, NULL);
	g_markup_parse_context_free(context);
	if (data.text)
		g_free(data.text);
	if (data.value_name)
		g_free(data.value_name);
	return data.alerts;
}

void alert_free(AWeatherAlert *alert)
{
	g_free(alert->title);
	g_free(alert->link);
	g_free(alert->summary);
	g_free(alert->cap.status);
	g_free(alert->cap.urgency);
	g_free(alert->cap.severity);
	g_free(alert->cap.certainty);
	g_free(alert->cap.area_desc);
	g_free(alert->cap.fips6);
	g_free(alert->cap.vtec);
	g_free(alert);
}

void alert_test(char *file)
{
	gchar *text; gsize len;
	g_file_get_contents(file, &text, &len, NULL);
	GList *alerts = alert_parse(text, len);
	g_free(text);
	for (GList *cur = alerts; cur; cur = cur->next) {
		AWeatherAlert *alert = cur->data;
		g_message("alert:");
		g_message("	title         = %s",  alert->title        );
		g_message("	link          = %s",  alert->link         );
		g_message("	summary       = %s",  alert->summary      );
		g_message("	cat.effective = %lu", alert->cap.effective);
		g_message("	cat.expires   = %lu", alert->cap.expires  );
		g_message("	cat.status    = %s",  alert->cap.status   );
		g_message("	cat.urgency   = %s",  alert->cap.urgency  );
		g_message("	cat.severity  = %s",  alert->cap.severity );
		g_message("	cat.certainty = %s",  alert->cap.certainty);
		g_message("	cat.area_desc = %s",  alert->cap.area_desc);
		g_message("	cat.fips6     = %s",  alert->cap.fips6    );
		g_message("	cat.vtec      = %p",  alert->cap.vtec     );
	}
	g_list_foreach(alerts, (GFunc)alert_free, NULL);
	g_list_free(alerts);
}


/********
 * FIPS *
 ********/
int int_compare(int a, int b)
{
	return (a <  b) ? -1 :
	       (a == b) ?  0 : 1;
}

gdouble timed(void)
{
	GTimeVal tv;
	g_get_current_time(&tv);
	return (gdouble)tv.tv_sec + (gdouble)tv.tv_usec/G_USEC_PER_SEC;
}

gdouble fips_area(gdouble *a, gdouble *b, gdouble *c)
{
	gdouble cross[3];
	crossd3(a, b, c, cross);
	return  lengthd(cross)/2;
}

gdouble fips_remove_one(GList **poly, gdouble thresh)
{
	gdouble min_area = thresh;
	GList  *min_list = NULL;
	if (g_list_length(*poly) <= 4)
		return 0;
	for (GList *prev = *poly; prev->next->next; prev = prev->next) {
		GList *cur  = prev->next;
		GList *next = prev->next->next;
		gdouble area = fips_area(prev->data, cur->data, next->data);
		if (area < min_area) {
			min_area = area;
			min_list = cur;
		}
	}
	if (min_list) {
		*poly = g_list_delete_link(*poly, min_list);
		return min_area;
	} else {
		return 0;
	}
}

gpointer fips_simplify(gdouble (*coords)[3], gdouble thresh, gint key)
{
	GList *poly = NULL;

	/* Add points to poly list */
	for (int i = 0; coords[i][0]; i++)
		poly = g_list_prepend(poly, coords[i]);
	int before = g_list_length(poly);

	/* Simplify poly list */
	//fprintf(stderr, "GritsPluginAlert: remove_one ");
	gdouble area;
	while ((area = fips_remove_one(&poly, thresh)) > 0) {
		//fprintf(stderr, " %f", area);
	}
	//fprintf(stderr, "\n");
	int after = g_list_length(poly);

	/* Copy points back */
	gdouble (*simp)[3] = (gpointer)g_new0(gdouble, 3*(after+1));
	GList *cur = poly;
	for (int i = 0; i < after; i++) {
		gdouble *coord = cur->data;
		simp[i][0] = coord[0];
		simp[i][1] = coord[1];
		simp[i][2] = coord[2];
		cur = cur->next;
	}

	(void)before;
	(void)after;
	g_debug("GritsPluginAlert: fips_simplify %d: %d -> %d",
			key, before, after);
	g_list_free(poly);
	g_free(coords);
	return simp;
}

void fips_print(FILE *fd, gchar *fips, gchar *name, gchar *state,
		gdouble (**points)[3])
{
	fprintf(fd, "%s\t%s\t%s", fips, name, state);
	for (int i = 0; points[i]; i++) {
		fprintf(fd, "\t");
		for (int j = 0; points[i][j][0]; j++) {
			//fwrite(points[i][j], sizeof(double), 3, fd);
			gdouble lat, lon;
			xyz2ll(points[i][j][0], points[i][j][1],
					points[i][j][2], &lat, &lon);
			fprintf(fd, "%.7lf,%.7lf ", lat, lon);
		}
	}
	fprintf(fd, "\n");
}

GTree *fips_parse(gchar *text)
{
	g_debug("GritsPluginAlert: fips_parse");
	//FILE *fd = fopen("/tmp/fips_polys_simp.txt", "w+");

	GTree *tree = g_tree_new((GCompareFunc)int_compare);
	gchar **lines = g_strsplit(text, "\n", -1);
	for (gint li = 0; lines[li]; li++) {
		/* Split and count parts */
		gchar **sparts = g_strsplit(lines[li], "\t", -1);
		int     nparts = g_strv_length(sparts);
		if (nparts < 4) {
			g_strfreev(sparts);
			continue;
		}

		GritsPoint center = {0,0,0};
		gdouble (**polys)[3] = (gpointer)g_new0(double*, nparts-3+1);
		for (int pi = 3; pi < nparts; pi++) {
			/* Split and count coordinates */
			gchar **scoords = g_strsplit(sparts[pi], " ", -1);
			int     ncoords = g_strv_length(scoords);

			/* Create binary coords */
			gdouble (*coords)[3] = (gpointer)g_new0(gdouble, 3*(ncoords+1));
			for (int ci = 0; ci < ncoords; ci++) {
				gdouble lat, lon;
				//sscanf(scoords[ci], "%lf,%lf", &lon, &lat);
				sscanf(scoords[ci], "%lf,%lf", &lat, &lon);
				if (ci == 0) {
					center.lat  = lat;
					center.lon  = lon;
					center.elev = 0;
				}
				lle2xyz(lat, lon, 0,
					&coords[ci][0],
					&coords[ci][1],
					&coords[ci][2]);
			}

			/* Simplify coords/contour */
			//coords = fips_simplify(coords, 1000*1000*4, li);

			/* Insert coords into poly array */
			polys[pi-3] = coords;
			g_strfreev(scoords);
		}

		/* print simplified polys */
		//fips_print(fd, sparts[0], sparts[1], sparts[2], polys);

		/* Create GritsPoly */
		GritsPoly *poly = grits_poly_new(polys);
		GRITS_OBJECT(poly)->center  = center;
		GRITS_OBJECT(poly)->skip   |= GRITS_SKIP_CENTER;
		GRITS_OBJECT(poly)->skip   |= GRITS_SKIP_STATE;

		/* Insert polys into the tree */
		gint id = g_ascii_strtoll(sparts[0], NULL, 10);
		g_tree_insert(tree, (gpointer)id, poly);
		g_strfreev(sparts);
	}
	g_strfreev(lines);

	//fclose(fd);
	return tree;
}

/********************
 * GritsPluginAlert *
 ********************/
/* Setup helpers
 * init:
 *   parse counties
 *   init county polys
 *   init config area
 * refresh:
 *   parse alert
 *   update buttons
 *   update counties
 * clicked:
 *   update counties
 */

/* Update counties */
static gboolean _hide_county(gchar *_, GritsObject *county)
{
	g_object_set_data(G_OBJECT(county), "info", NULL);
	//county->hidden = TRUE;
	return FALSE;
}
static void _update_counties(GritsPluginAlert *alert)
{
	/* Setup counties based on alerts:
	 * foreach alert in alerts:
	 * 	info   = infotable.get(alert.type)
	 * 	foreach fips  in alert.fipses:
	 * 		county = counties.get(fips)
	 * 		if info is higher priority
	 * 			county.color = info.color
	 */
	g_debug("GritsPluginAlert: _update_counties");
	g_tree_foreach(alert->counties, (GTraverseFunc)_hide_county, NULL);
	for (GList *cur = alert->alerts; cur; cur = cur->next) {
		AWeatherAlert *msg = cur->data;

		/* Find alert info */
		AlertInfo *info = alert_info_find(msg->title);
		if (!info) {
			g_warning("GritsPluginAlert: unknown warning - %s", msg->title);
			continue;
		}
		if (!info->enabled)
			continue;

		/* Set color for each county in alert */
		gchar **fipses = g_strsplit(msg->cap.fips6, " ", -1);
		for (int i = 0; fipses[i]; i++) {
			gint fips = g_ascii_strtoll(fipses[i], NULL, 10);
			GritsPoly *county = g_tree_lookup(alert->counties, (gpointer)fips);
			if (!county)
				continue;
			AlertInfo *old = g_object_get_data(G_OBJECT(county), "info");
			if (old != NULL && old < info)
				continue;
			g_object_set_data(G_OBJECT(county), "info", info);
			county->color[0] = (float)info->color[0] / 256;
			county->color[1] = (float)info->color[1] / 256;
			county->color[2] = (float)info->color[2] / 256;
			county->color[3] = 0.25;
			GRITS_OBJECT(county)->hidden = FALSE;
		}
		g_strfreev(fipses);
	}
	gtk_widget_queue_draw(GTK_WIDGET(alert->viewer));
}

/* Update buttons */
static void _alert_click(GtkRadioButton *button, gpointer alert)
{
	g_debug("GritsPluginAlert: _alert_click");
	AlertInfo *info = g_object_get_data(G_OBJECT(button), "info");
	info->enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
	_update_counties(alert);
}

static GtkWidget *_make_button(AlertInfo *info)
{
	g_debug("GritsPluginAlert: _make_button - %s", info->title);
	GdkColor black = {0, 0, 0, 0};
	GdkColor color = {0, info->color[0]<<8, info->color[1]<<8, info->color[2]<<8};

	gchar text[6+7];
	g_snprintf(text, sizeof(text), "<b>%.5s</b>", info->title);

	GtkWidget *button = gtk_toggle_button_new();
	GtkWidget *align  = gtk_alignment_new(0.5, 0.5, 1, 1);
	GtkWidget *cbox   = gtk_event_box_new();
	GtkWidget *label  = gtk_label_new(text);
	for (int state = 0; state < GTK_STATE_INSENSITIVE; state++) {
		gtk_widget_modify_fg(label, state, &black);
		gtk_widget_modify_bg(cbox,  state, &color);
	} /* Yuck.. */
	g_object_set_data(G_OBJECT(button), "info", info);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_alignment_set_padding(GTK_ALIGNMENT(align), 2, 2, 4, 4);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), info->enabled);
	gtk_widget_set_tooltip_text(GTK_WIDGET(button), info->title);
	gtk_container_add(GTK_CONTAINER(cbox), label);
	gtk_container_add(GTK_CONTAINER(align), cbox);
	gtk_container_add(GTK_CONTAINER(button), align);
	return button;
}

static void _update_buttons(GritsPluginAlert *alert)
{
	g_debug("GritsPluginAlert: _update_buttons");
	/* Delete old buttons */
	GList *frames = gtk_container_get_children(GTK_CONTAINER(alert->config));
	for (GList *frame = frames; frame; frame = frame->next) {
		GtkWidget *table = gtk_bin_get_child(GTK_BIN(frame->data));
		GList *btns = gtk_container_get_children(GTK_CONTAINER(table));
		g_list_foreach(btns, (GFunc)gtk_widget_destroy, NULL);
	}

	/* Add new buttons */
	for (int i = 0; alert_info[i].title; i++) {
		if (!alert_info[i].current)
			continue;

		GtkWidget *table = g_object_get_data(G_OBJECT(alert->config),
				alert_info[i].category);
		GList *kids = gtk_container_get_children(GTK_CONTAINER(table));
		int nkids = g_list_length(kids);
		int x = nkids % 3;
		int y = nkids / 3;
		g_list_free(kids);

		GtkWidget *button = _make_button(&alert_info[i]);
		gtk_table_attach(GTK_TABLE(table), button, x, x+1, y, y+1,
				GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
		g_signal_connect(button, "clicked",
				G_CALLBACK(_alert_click), alert);
	}
}

/* Init helpers */
static gboolean _add_county(gint key, GritsObject *poly, GritsViewer *viewer)
{
	grits_viewer_add(viewer, poly, GRITS_LEVEL_WORLD+1, TRUE);
	return FALSE;
}

static GtkWidget *_make_config(void)
{
	gchar *labels[] = {"Warnings", "Watches", "Advisories", "Other"};
	gchar *keys[]   = {"warning",  "watch",   "advisory",   "other"};
	gint   cols[]   = {3, 2, 2, 2};
	GtkWidget *config = gtk_hbox_new(FALSE, 10);
	for (int i = 0; i < G_N_ELEMENTS(labels); i++) {
		GtkWidget *frame = gtk_frame_new(labels[i]);
		GtkWidget *table = gtk_table_new(1, cols[i], TRUE);
		gtk_container_add(GTK_CONTAINER(frame), table);
		gtk_box_pack_start(GTK_BOX(config), frame, TRUE, TRUE, 0);
		g_object_set_data(G_OBJECT(config), keys[i], table);
	}
	return config;
}

/* Methods */
GritsPluginAlert *grits_plugin_alert_new(GritsViewer *viewer, GritsPrefs *prefs)
{
	g_debug("GritsPluginAlert: new");
	GritsPluginAlert *alert = g_object_new(GRITS_TYPE_PLUGIN_ALERT, NULL);
	g_tree_foreach(alert->counties, (GTraverseFunc)_add_county, viewer);
	alert->viewer = viewer;
	alert->prefs  = prefs;
	return alert;
}

static GtkWidget *grits_plugin_alert_get_config(GritsPlugin *_alert)
{
	GritsPluginAlert *alert = GRITS_PLUGIN_ALERT(_alert);
	return alert->config;
}


/* GObject code */
static void grits_plugin_alert_plugin_init(GritsPluginInterface *iface);
G_DEFINE_TYPE_WITH_CODE(GritsPluginAlert, grits_plugin_alert, G_TYPE_OBJECT,
		G_IMPLEMENT_INTERFACE(GRITS_TYPE_PLUGIN,
			grits_plugin_alert_plugin_init));
static void grits_plugin_alert_plugin_init(GritsPluginInterface *iface)
{
	g_debug("GritsPluginAlert: plugin_init");
	/* Add methods to the interface */
	iface->get_config = grits_plugin_alert_get_config;
}
static void grits_plugin_alert_init(GritsPluginAlert *alert)
{
	g_debug("GritsPluginAlert: class_init");
	/* Set defaults */
	alert->config   = _make_config();

	/* Load counties */
	gchar *text; gsize len;
	const gchar *fips_file = "/scratch/aweather/data/fips_polys_simp.txt";
	g_file_get_contents(fips_file, &text, &len, NULL);
	alert->counties = fips_parse(text);
	g_free(text);

	/* Load alerts (once for testing) */
	const gchar *alert_file = "/scratch/aweather/src/plugins/alert4.xml";
	g_file_get_contents(alert_file, &text, &len, NULL);
	alert->alerts = alert_parse(text, len);
	g_free(text);

	/* For now, set alert "current" at init */
	for (GList *cur = alert->alerts; cur; cur = cur->next) {
		AWeatherAlert *msg  = cur->data;
		AlertInfo     *info = alert_info_find(msg->title);
		if (info) info->current = TRUE;
	}

	/* For now, run updates */
	_update_buttons(alert);
	_update_counties(alert);
}
static void grits_plugin_alert_dispose(GObject *gobject)
{
	g_debug("GritsPluginAlert: dispose");
	GritsPluginAlert *alert = GRITS_PLUGIN_ALERT(gobject);
	(void)alert; // TODO
	/* Drop references */
	G_OBJECT_CLASS(grits_plugin_alert_parent_class)->dispose(gobject);
}
static void grits_plugin_alert_finalize(GObject *gobject)
{
	g_debug("GritsPluginAlert: finalize");
	GritsPluginAlert *alert = GRITS_PLUGIN_ALERT(gobject);
	/* Free data */
	gtk_widget_destroy(alert->config);

	/* Free countes */
	g_tree_destroy(alert->counties);

	/* Free alerts (once for testing) */
	g_list_foreach(alert->alerts, (GFunc)alert_free, NULL);
	g_list_free(alert->alerts);

	G_OBJECT_CLASS(grits_plugin_alert_parent_class)->finalize(gobject);
}
static void grits_plugin_alert_class_init(GritsPluginAlertClass *klass)
{
	g_debug("GritsPluginAlert: class_init");
	GObjectClass *gobject_class = (GObjectClass*)klass;
	gobject_class->dispose  = grits_plugin_alert_dispose;
	gobject_class->finalize = grits_plugin_alert_finalize;
}