/*
 *   Copyright (C) 1991-2000 by Jonathan Naylor HB9DRD/G4KLX
 *
 *   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 2 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, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>

#include <gtk/gtk.h>

#include "global.h"

#define	TLE_NAME	0
#define	TLE_LINE1	1
#define	TLE_LINE2	2

#define	USER_NONE	0
#define	USER_DATA	1
#define	USER_COLOUR	2
#define	USER_MAP	3
#define	USER_STARTUP	4

static int Sats_Added;
static int Sats_Updated;

static int Read_NASA_Data(char *);
static int Assign_Sat_Name(char *, struct Sat_Struct *);
static int Assign_Line1(char *, struct Sat_Struct *);
static int Assign_Line2(char *, struct Sat_Struct *);

static int Insert_Sat(struct Sat_Struct);

static double Conv_Digits(char *, int);

static void FileSelCb(GtkWidget *, GtkFileSelection *);

void Import_Sat_Data(void)
{
	GtkWidget *filesel;

	filesel = gtk_file_selection_new("Select a File to Import");

	gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->cancel_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_destroy), GTK_OBJECT(filesel));
	gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(filesel)->ok_button), "clicked", (GtkSignalFunc)FileSelCb, filesel);

	gtk_widget_show(filesel);
}

static void FileSelCb(GtkWidget *w, GtkFileSelection *fs)
{
	char *file;

	file = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs));
		
	if (Read_NASA_Data(file))
		Write_Sat_Data();
}

static int Read_NASA_Data(char *Filename)
{
	struct Sat_Struct Temp_Data;
	char Buffer[101];
	FILE *fp;
	char *s;
	int  State;

	if ((fp = fopen(Filename, "r")) == NULL) {
		sprintf(Buffer, "Cannot open file %s", Filename);
		Warning_Box(Buffer);
		return FALSE;
	}

	Sats_Added = 0;
	Sats_Updated = 0;
	State = TLE_NAME;

	while (fgets(Buffer, 100, fp) != NULL) {
		if ((s = strchr(Buffer, '\n')) != NULL) *s = '\0';
		if ((s = strchr(Buffer, '\r')) != NULL) *s = '\0';

		switch (State) {
			case TLE_NAME:
				memset(&Temp_Data, '\0', sizeof(struct Sat_Struct));
				if (!Assign_Sat_Name(Buffer, &Temp_Data)) {
					State = TLE_NAME;
					break;
				}
				State = TLE_LINE1;
				break;
			case TLE_LINE1:
				if (!Assign_Line1(Buffer, &Temp_Data)) {
					State = TLE_NAME;
					break;
				}
				State = TLE_LINE2;
				break;
			case TLE_LINE2:
				if (!Assign_Line2(Buffer, &Temp_Data)) {
					State = TLE_NAME;
					break;
				}
				Insert_Sat(Temp_Data);
				State = TLE_NAME;
				break;
			default:
				break;
		}
	}

	fclose(fp);

	sprintf(Buffer, "%d Satellites Added and %d Satellites Updated", Sats_Added, Sats_Updated);
	Message_Box(Buffer);

	return TRUE;
}

static int Assign_Sat_Name(char *Buffer, struct Sat_Struct *Temp_Data)
{
	int  i;

	if (strlen(Buffer) < 2)
		return FALSE;

	for (i = strlen(Buffer) - 1; Buffer[i] == ' ' && i >= 0; i--);
	Buffer[i + 1] = '\0';

	if (strlen(Buffer) > 50 || strlen(Buffer) < 2)
		return FALSE;

	strcpy(Temp_Data->Name, Buffer);

	return TRUE;
}

static int Assign_Line1(char *Buffer, struct Sat_Struct *Temp_Data)
{
	if (Buffer[0] != '1' || strlen(Buffer) < 69)
		return FALSE;

	Temp_Data->Catalogue_No = (long)Conv_Digits(Buffer + 2, 5);

	Temp_Data->Epoch_Year = (int)Conv_Digits(Buffer + 18, 2);

	if (Temp_Data->Epoch_Year > 56)
		Temp_Data->Epoch_Year += 1900;
	else
		Temp_Data->Epoch_Year += 2000;

	Temp_Data->Epoch_Day  = Conv_Digits(Buffer + 20, 12);

	Temp_Data->Drag = Conv_Digits(Buffer + 33, 10);

	return TRUE;
}

static int Assign_Line2(char *Buffer, struct Sat_Struct *Temp_Data)
{
	char Temp[15];

	if (Buffer[0] != '2' || strlen(Buffer) < 69)
		return FALSE;

	Temp_Data->Inclination = Conv_Digits(Buffer + 8, 8);

	Temp_Data->RAAN = Conv_Digits(Buffer + 17, 8);

	Temp[0] = '0';
	Temp[1] = '.';
	strncpy(Temp + 2, Buffer + 26, 7);

	Temp_Data->Eccentricity = Conv_Digits(Temp, 9);

	Temp_Data->Arg_Of_Perigee = Conv_Digits(Buffer + 34, 8);

	Temp_Data->Mean_Anomoly = Conv_Digits(Buffer + 43, 8);

	Temp_Data->Mean_Motion = Conv_Digits(Buffer + 52, 11);

	Temp_Data->Epoch_Orbit = (long)Conv_Digits(Buffer + 63, 5);

	return TRUE;
}

static int Insert_Sat(struct Sat_Struct New_Data)
{
	struct Sat_Struct *Found, *Sat;
	int i;

	if ((Found = Find_Satellite_Cat_No(New_Data.Catalogue_No)) == NULL)
		Found = Find_Satellite_Name(New_Data.Name);

	if (Found == NULL) {
		Sats_Added++;

		New_Data.Category[0] = '\0';
		New_Data.Aflag       = FALSE;
		New_Data.Minus_Z     = FALSE;
		New_Data.No_Modes    = 0;
		New_Data.Frequency1  = 0.0;
		New_Data.Frequency2  = 0.0;

		Sat  = g_malloc(sizeof(struct Sat_Struct));
		*Sat = New_Data;

		Sat_List = g_slist_insert_sorted(Sat_List, Sat, Sat_Comparison);

		return TRUE;
	} else {
		Sats_Updated++;

		strcpy(New_Data.Category, Found->Category);
		New_Data.Display    = Found->Display;
		New_Data.Current    = Found->Current;
		New_Data.Aflag      = Found->Aflag;
		New_Data.Alon       = Found->Alon;
		New_Data.Alat       = Found->Alat;
		New_Data.Minus_Z    = Found->Minus_Z;
		New_Data.No_Modes   = Found->No_Modes;

		for (i = 0; i < Found->No_Modes; i++) {
			New_Data.MA_Day[i] = Found->MA_Day[i];
			strcpy(New_Data.Mode[i], Found->Mode[i]);
		}

		New_Data.Frequency1 = Found->Frequency1;
		New_Data.Frequency2 = Found->Frequency2;

		Sat_List = g_slist_remove(Sat_List, Found);
		g_free(Found);

		Sat  = g_malloc(sizeof(struct Sat_Struct));
		*Sat = New_Data;

		Sat_List = g_slist_insert_sorted(Sat_List, Sat, Sat_Comparison);

		return TRUE;
	}	
}

static double Conv_Digits(char *Buffer, int n)
{
	char Temp[20];

	strncpy(Temp, Buffer, n);
	Temp[n] = '\0';

	return atof(Temp);
}

void Read_Sat_Data(void)
{
	char Buffer[120], *t[12], *u[2];
	char File_Name[81], *s;
	struct Sat_Struct Temp_Data, *Sat;
	FILE *fp;
	int  n;

	sprintf(File_Name, "%s/satfile", Files_Path);

	if ((fp = fopen(File_Name, "r")) == NULL)
		return;

	while (fgets(Buffer, 119, fp) != NULL) {
		if (Buffer[0] == '[') {
			if ((s = strchr(Buffer, ']')) == NULL)
				g_error("mtrack: malformed line %s\n", Buffer);
			*s = '\0';

			strcpy(Temp_Data.Name, Buffer + 1);

			strcpy(Temp_Data.Category, "");
			Temp_Data.Aflag         = FALSE;
			Temp_Data.Minus_Z       = FALSE;
			Temp_Data.No_Modes      = 0;
			Temp_Data.Frequency1    = 0.0;
			Temp_Data.Frequency2    = 0.0;
			
			Temp_Data.SSP_Longitude = 0.0;
			Temp_Data.SSP_Latitude  = 0.0;
			Temp_Data.Half_Angle    = 0.0;
			Temp_Data.Elevation     = 0.0;
			Temp_Data.Range         = 0.0;
			Temp_Data.Elapsed_Time  = 0.0;
			
			Temp_Data.Current       = FALSE;
			Temp_Data.Display       = FALSE;
			Temp_Data.Beep          = FALSE;
		} else {
			if ((t[0] = strtok(Buffer, "=")) == NULL)
				continue;
			if ((t[1] = strtok(NULL, "\r\n")) == NULL)
				continue;

			if (strcmp(t[0], "categories") == 0) {
				if (t[1] != NULL && strlen(t[1]) > 0)
					strcpy(Temp_Data.Category, t[1]);
			} else if (strcmp(t[0], "epoch_year") == 0) {
				Temp_Data.Epoch_Year = atoi(t[1]);
			} else if (strcmp(t[0], "epoch_day") == 0) {
				Temp_Data.Epoch_Day = atof(t[1]);
			} else if (strcmp(t[0], "inclination") == 0) {
				Temp_Data.Inclination = atof(t[1]);
			} else if (strcmp(t[0], "mean_anomoly") == 0) {
				Temp_Data.Mean_Anomoly = atof(t[1]);
			} else if (strcmp(t[0], "mean_motion") == 0) {
				Temp_Data.Mean_Motion = atof(t[1]);
			} else if (strcmp(t[0], "eccentricity") == 0) {
				Temp_Data.Eccentricity = atof(t[1]);
			} else if (strcmp(t[0], "arg_of_perigee") == 0) {
				Temp_Data.Arg_Of_Perigee = atof(t[1]);
			} else if (strcmp(t[0], "raan") == 0) {
				Temp_Data.RAAN = atof(t[1]);
			} else if (strcmp(t[0], "orbit") == 0) {
				Temp_Data.Epoch_Orbit = atol(t[1]);
			} else if (strcmp(t[0], "drag") == 0) {
				Temp_Data.Drag = atof(t[1]);
			} else if (strcmp(t[0], "minusz") == 0) {
				if (strcmp(t[1], "yes") == 0)
					Temp_Data.Minus_Z = TRUE;
				else
					Temp_Data.Minus_Z = FALSE;
			} else if (strcmp(t[0], "alongitude") == 0) {
				Temp_Data.Alon  = atof(t[1]);
				Temp_Data.Aflag = TRUE;
			} else if (strcmp(t[0], "alatitude") == 0) {
				Temp_Data.Alat  = atof(t[1]);
				Temp_Data.Aflag = TRUE;
			} else if (strcmp(t[0], "modes") == 0) {
				s = t[1];
				n = 0;
				while ((t[n + 2] = strtok(s, " ")) != NULL) {
					n++;
					s = NULL;
				}

				Temp_Data.No_Modes = n;

				for (n = 0; n < Temp_Data.No_Modes; n++) {
					u[0] = strtok(t[n + 2], ":");
					u[1] = strtok(NULL, "");

					if (u[0] == NULL || u[1] == NULL)
						g_error("mtrack: cannot parse mode data\n");

					Temp_Data.MA_Day[n] = atoi(u[0]);
					strcpy(Temp_Data.Mode[n], u[1]);
				}
			} else if (strcmp(t[0], "frequencies") == 0) {
				t[2] = strtok(t[1], ",");
				t[3] = strtok(NULL, ",");

				if (t[2] == NULL || t[3] == NULL)
					g_error("mtrack: cannot parse frequencies data\n");

				Temp_Data.Frequency1 = atof(t[2]);
				Temp_Data.Frequency2 = atof(t[3]);
			} else if (strcmp(t[0], "catalogue_no") == 0) {
				Temp_Data.Catalogue_No = atol(t[1]);
				Sat  = g_malloc(sizeof(struct Sat_Struct));
				*Sat = Temp_Data;
				Sat_List = g_slist_insert_sorted(Sat_List, Sat, Sat_Comparison);
			} else {
				fprintf(stderr, "mtrack: unknown keyword %s in %s\n", t[0], File_Name);
			}
		}
	}

	fclose(fp);
}

void Read_Loc_Data(void)
{
	char Buffer[120], *t[5];
	char File_Name[81], *s;
	struct Loc_Struct Temp_Data, *Loc;
	FILE *fp;

	sprintf(File_Name, "%s/locfile", Files_Path);

	if ((fp = fopen(File_Name, "r")) == NULL)
		return;

	while(fgets(Buffer, 119, fp) != NULL) {
		if (Buffer[0] == '[') {
			if ((s = strchr(Buffer, ']')) == NULL)
				g_error("mtrack: malformed line %s\n", Buffer);
			*s = '\0';

			strcpy(Temp_Data.QTH, Buffer + 1);
		} else {
			if ((t[0] = strtok(Buffer, "=")) == NULL)
				continue;
			if ((t[1] = strtok(NULL, "\r\n")) == NULL)
				continue;

			if (strcmp(t[0], "latitude") == 0) {
				Temp_Data.Latitude = atof(t[1]);
			} else if (strcmp(t[0], "longitude") == 0) {
				Temp_Data.Longitude = -atof(t[1]);
			} else if (strcmp(t[0], "height") == 0) {
				Temp_Data.Height = atof(t[1]);
				Loc  = g_malloc(sizeof(struct Loc_Struct));
				*Loc = Temp_Data;
				Loc_List = g_slist_insert_sorted(Loc_List, Loc, Loc_Comparison);
			} else {
				fprintf(stderr, "mtrack: unknown keyword %s in %s\n", t[0], File_Name);
			}
		}
	}

	fclose(fp);
}

void Read_User_Data(void)
{
	char Buffer[120], *t[5];
	char File_Name[81], *s;
	int  Found = FALSE;
	FILE *fp = NULL;
	int  state = USER_NONE;

	if ((s = getenv("HOME")) != NULL) {
		sprintf(File_Name, "%s/.mtrackrc", s);

		if ((fp = fopen(File_Name, "r")) != NULL)
			Found = TRUE;
	}

	if (!Found) {
		sprintf(File_Name, "%s/mtrackrc", RCDIR);

		if ((fp = fopen(File_Name, "r")) == NULL)
			return;
	}

	while (fgets(Buffer, 119, fp) != NULL) {
		if ((s = strchr(Buffer, '\n')) != NULL) *s = '\0';
		if ((s = strchr(Buffer, '\r')) != NULL) *s = '\0';

		if (strcmp(Buffer, "[User]") == 0) {
			state = USER_DATA;
			continue;
		}
		if (strcmp(Buffer, "[Colours]") == 0) {
			state = USER_COLOUR;
			continue;
		}
		if (strcmp(Buffer, "[Map]") == 0) {
			state = USER_MAP;
			continue;
		}
		if (strcmp(Buffer, "[Startup]") == 0) {
			state = USER_STARTUP;
			continue;
		}

		if ((t[0] = strtok(Buffer, "=")) == NULL)
			continue;
		if ((t[1] = strtok(NULL, "\r\n")) == NULL)
			continue;

		switch (state) {
			case USER_NONE:
				break;

			case USER_DATA:
				if (strcmp(t[0], "callsign") == 0)
					strcpy(User_Data.Callsign, t[1]);
				else if (strcmp(t[0], "latitude") == 0)
					User_Data.Latitude = atof(t[1]);
				else if (strcmp(t[0], "longitude") == 0)
					User_Data.Longitude = -atof(t[1]);
				else if (strcmp(t[0], "height") == 0)
					User_Data.Height = atof(t[1]);
				else if (strcmp(t[0], "list_interval") == 0)
					User_Data.List_Interval = atoi(t[1]);
				else if (strcmp(t[0], "time_interval") == 0)
					User_Data.Time_Interval = atoi(t[1]);
				else if (strcmp(t[0], "time_offset") == 0)
					User_Data.Time_Offset = atoi(t[1]);
				else if (strcmp(t[0], "date_format") == 0) {
					if (strcmp(t[1], "DDMMYYYY") == 0)
						User_Data.Date_Format = DATE_FORMAT_DDMMYYYY;
					else if (strcmp(t[1], "MMDDYYYY") == 0)
						User_Data.Date_Format = DATE_FORMAT_MMDDYYYY;
					else
						g_error("mtrack: unknown date format %s\n", t[1]);
				} else
					fprintf(stderr, "mtrack: unknown keyword %s in %s\n", t[0], File_Name);
				break;

			case USER_COLOUR:
				if (strcmp(t[0], "background") == 0) {
					t[2] = strtok(t[1], ",");
					t[3] = strtok(NULL, ",");
					t[4] = strtok(NULL, "");

					if (t[2] == NULL || t[3] == NULL || t[4] == NULL)
						g_error("mtrack: cannot parse background colour data\n");

					User_Data.Colours[COLOUR_BACKGROUND].pixel = 0;
					User_Data.Colours[COLOUR_BACKGROUND].red   = atoi(t[2]);
					User_Data.Colours[COLOUR_BACKGROUND].green = atoi(t[3]);
					User_Data.Colours[COLOUR_BACKGROUND].blue  = atoi(t[4]);
				} else if (strcmp(t[0], "cities") == 0) {
					t[2] = strtok(t[1], ",");
					t[3] = strtok(NULL, ",");
					t[4] = strtok(NULL, "");

					if (t[2] == NULL || t[3] == NULL || t[4] == NULL)
						g_error("mtrack: cannot parse cities colour data\n");

					User_Data.Colours[COLOUR_CITIES].pixel = 0;
					User_Data.Colours[COLOUR_CITIES].red   = atoi(t[2]);
					User_Data.Colours[COLOUR_CITIES].green = atoi(t[3]);
					User_Data.Colours[COLOUR_CITIES].blue  = atoi(t[4]);
				} else if (strcmp(t[0], "land") == 0) {
					t[2] = strtok(t[1], ",");
					t[3] = strtok(NULL, ",");
					t[4] = strtok(NULL, "");

					if (t[2] == NULL || t[3] == NULL || t[4] == NULL)
						g_error("mtrack: cannot parse land colour data\n");

					User_Data.Colours[COLOUR_LAND].pixel = 0;
					User_Data.Colours[COLOUR_LAND].red   = atoi(t[2]);
					User_Data.Colours[COLOUR_LAND].green = atoi(t[3]);
					User_Data.Colours[COLOUR_LAND].blue  = atoi(t[4]);
				} else if (strcmp(t[0], "footprint") == 0) {
					t[2] = strtok(t[1], ",");
					t[3] = strtok(NULL, ",");
					t[4] = strtok(NULL, "");

					if (t[2] == NULL || t[3] == NULL || t[4] == NULL)
						g_error("mtrack: cannot parse footprint colour data\n");

					User_Data.Colours[COLOUR_FOOTPRINT].pixel = 0;
					User_Data.Colours[COLOUR_FOOTPRINT].red   = atoi(t[2]);
					User_Data.Colours[COLOUR_FOOTPRINT].green = atoi(t[3]);
					User_Data.Colours[COLOUR_FOOTPRINT].blue  = atoi(t[4]);
				} else if (strcmp(t[0], "satellite") == 0) {
					t[2] = strtok(t[1], ",");
					t[3] = strtok(NULL, ",");
					t[4] = strtok(NULL, "");

					if (t[2] == NULL || t[3] == NULL || t[4] == NULL)
						g_error("mtrack: cannot parse satellite colour data\n");

					User_Data.Colours[COLOUR_SATELLITE].pixel = 0;
					User_Data.Colours[COLOUR_SATELLITE].red   = atoi(t[2]);
					User_Data.Colours[COLOUR_SATELLITE].green = atoi(t[3]);
					User_Data.Colours[COLOUR_SATELLITE].blue  = atoi(t[4]);
				} else if (strcmp(t[0], "user") == 0) {
					t[2] = strtok(t[1], ",");
					t[3] = strtok(NULL, ",");
					t[4] = strtok(NULL, "");

					if (t[2] == NULL || t[3] == NULL || t[4] == NULL)
						g_error("mtrack: cannot parse user colour data\n");

					User_Data.Colours[COLOUR_USER].pixel = 0;
					User_Data.Colours[COLOUR_USER].red   = atoi(t[2]);
					User_Data.Colours[COLOUR_USER].green = atoi(t[3]);
					User_Data.Colours[COLOUR_USER].blue  = atoi(t[4]);
				} else
					fprintf(stderr, "mtrack: unknown keyword %s in %s\n", t[0], File_Name);
				break;

			case USER_MAP:
				if (strcmp(t[0], "number") == 0)
					User_Data.Map_No = atoi(t[1]);
				else
					fprintf(stderr, "mtrack: unknown keyword %s in %s\n", t[0], File_Name);
				break;

			case USER_STARTUP:
				if (strcmp(t[0], "satellite") == 0) {
					struct Sat_Struct *Sat_Data;

					if ((Sat_Data = Find_Satellite_Name(t[1])) != NULL) {
						if (Num_Chosen < MAX_CHOSEN) {
							Sat_Data->Display = TRUE;
							Num_Chosen++;
						}
					} else {
						g_error("mtrack: unknown satellite name %s in %s\n", t[1], File_Name);
					}
				} else if (strcmp(t[0], "current") == 0) {
					struct Sat_Struct *Sat_Data;

					if ((Sat_Data = Find_Satellite_Name(t[1])) != NULL) {
						Sat_Data->Current = TRUE;
					} else {
						g_error("mtrack: unknown satellite name %s in %s\n", t[1], File_Name);
					}
				} else
					fprintf(stderr, "mtrack: unknown keyword %s in %s\n", t[0], File_Name);
				break;

			default:
				g_error("mtrack: unknown state in Read_User_Data - %d\n", state);
				break;
		}
	}

	fclose(fp);
}


gint Sat_Comparison(gconstpointer s1, gconstpointer s2)
{
	const struct Sat_Struct *First  = (struct Sat_Struct *)s1;
	const struct Sat_Struct *Second = (struct Sat_Struct *)s2;
	
	return strcasecmp(First->Name, Second->Name);
}

gint Loc_Comparison(gconstpointer d1, gconstpointer d2)
{
	const struct Loc_Struct *First  = (struct Loc_Struct *)d1;
	const struct Loc_Struct *Second = (struct Loc_Struct *)d2;
	
	return strcasecmp(First->QTH, Second->QTH);
}

void Write_Sat_Data(void)
{
	char File_Name[81];
	GSList *Sat;
	struct Sat_Struct *Data;
	FILE *fp;
	int  i;

	sprintf(File_Name, "%s/satfile", Files_Path);

	if ((fp = fopen(File_Name, "w")) == NULL) {
		Warning_Box("Cannot open satfile for writing, changes are not saved");
		return;
	}

	Sat = Sat_List;

	while (Sat != NULL) {
		Data = (struct Sat_Struct *)Sat->data;

		fprintf(fp, "[%s]\n", Data->Name);
		fprintf(fp, "categories=%s\n", Data->Category);
		fprintf(fp, "epoch_year=%d\n", Data->Epoch_Year);
		fprintf(fp, "epoch_day=%f\n", Data->Epoch_Day);
		fprintf(fp, "inclination=%f\n", Data->Inclination);
		fprintf(fp, "mean_anomoly=%f\n", Data->Mean_Anomoly);
		fprintf(fp, "mean_motion=%f\n", Data->Mean_Motion);
		fprintf(fp, "eccentricity=%f\n", Data->Eccentricity);
		fprintf(fp, "arg_of_perigee=%f\n", Data->Arg_Of_Perigee);
		fprintf(fp, "raan=%f\n", Data->RAAN);
		fprintf(fp, "orbit=%ld\n", Data->Epoch_Orbit);
		fprintf(fp, "drag=%f\n", Data->Drag);

		if (Data->Aflag) {
			fprintf(fp, "alongitude=%f\n", Data->Alon);
			fprintf(fp, "alatitude=%f\n", Data->Alat);
		}

		if (Data->Minus_Z)
			fprintf(fp, "minusz=yes\n");

		if (Data->No_Modes > 0) {
			fprintf(fp, "modes=");

			for (i = 0; i < Data->No_Modes; i++)
				fprintf(fp, "%d:%s ", Data->MA_Day[i], Data->Mode[i]);

			fprintf(fp, "\n");
		}

		if (Data->Frequency1 != 0.0 || Data->Frequency2 != 0.0)
			fprintf(fp, "frequencies=%f,%f\n", Data->Frequency1, Data->Frequency2);

		fprintf(fp, "catalogue_no=%ld\n\n", Data->Catalogue_No);

		Sat = g_slist_next(Sat);
	}

	fclose(fp);
}

void Write_Loc_Data(void)
{
	char File_Name[81];
	GSList *Loc;
	struct Loc_Struct *Data;
	FILE *fp;

	sprintf(File_Name, "%s/locfile", Files_Path);

	if ((fp = fopen(File_Name, "w")) == NULL) {
		Warning_Box("Cannot open locfile for writing, changes are not saved");
		return;
	}

	Loc = Loc_List;

	while (Loc != NULL) {
		Data = (struct Loc_Struct *)Loc->data;

		fprintf(fp, "[%s]\n", Data->QTH);
		fprintf(fp, "latitude=%f\n", Data->Latitude);
		fprintf(fp, "longitude=%f\n", -Data->Longitude);
		fprintf(fp, "height=%f\n\n", Data->Height);

		Loc = g_slist_next(Loc);
	}

	fclose(fp);
}

void Write_User_Data(void)
{
	char File_Name[81], *s;
	struct Sat_Struct *Sat;
	GSList *Sat_Iterator;
	FILE *fp;

	if (getuid() == 0) {
		sprintf(File_Name, "%s/mtrackrc", RCDIR);
	} else {
		if ((s = getenv("HOME")) == NULL) {
			Warning_Box("Cannot find home directory, changes not saved");
			return;
		}

		sprintf(File_Name, "%s/.mtrackrc", s);
	}

	if ((fp = fopen(File_Name, "w")) == NULL) {
		Warning_Box("Cannot open userfile for writing, changes not saved");
		return;
	}

	fprintf(fp, "[User]\n");
	fprintf(fp, "callsign=%s\n", User_Data.Callsign);
	fprintf(fp, "latitude=%f\n", User_Data.Latitude);
	fprintf(fp, "longitude=%f\n", -User_Data.Longitude);
	fprintf(fp, "height=%f\n", User_Data.Height);
	fprintf(fp, "time_interval=%d\n", User_Data.Time_Interval);
	fprintf(fp, "list_interval=%d\n", User_Data.List_Interval);
	fprintf(fp, "time_offset=%d\n", User_Data.Time_Offset);

	switch (User_Data.Date_Format) {
		case DATE_FORMAT_DDMMYYYY:
			fprintf(fp, "date_format=DDMMYYYY\n");
			break;
		case DATE_FORMAT_MMDDYYYY:
			fprintf(fp, "date_format=MMDDYYYY\n");
			break;
		default:
			g_error("mtrack: unknown date format %d\n", User_Data.Date_Format);
	}

	fprintf(fp, "\n[Colours]\n");
	fprintf(fp, "background=%d,%d,%d\n", User_Data.Colours[COLOUR_BACKGROUND].red, User_Data.Colours[COLOUR_BACKGROUND].green, User_Data.Colours[COLOUR_BACKGROUND].blue);
	fprintf(fp, "cities=%d,%d,%d\n", User_Data.Colours[COLOUR_CITIES].red, User_Data.Colours[COLOUR_CITIES].green, User_Data.Colours[COLOUR_CITIES].blue);
	fprintf(fp, "footprint=%d,%d,%d\n", User_Data.Colours[COLOUR_FOOTPRINT].red, User_Data.Colours[COLOUR_FOOTPRINT].green, User_Data.Colours[COLOUR_FOOTPRINT].blue);
	fprintf(fp, "land=%d,%d,%d\n", User_Data.Colours[COLOUR_LAND].red, User_Data.Colours[COLOUR_LAND].green, User_Data.Colours[COLOUR_LAND].blue);
	fprintf(fp, "satellite=%d,%d,%d\n", User_Data.Colours[COLOUR_SATELLITE].red, User_Data.Colours[COLOUR_SATELLITE].green, User_Data.Colours[COLOUR_SATELLITE].blue);
	fprintf(fp, "user=%d,%d,%d\n", User_Data.Colours[COLOUR_USER].red, User_Data.Colours[COLOUR_USER].green, User_Data.Colours[COLOUR_USER].blue);
	fprintf(fp, "\n[Map]\n");
	fprintf(fp, "number=%d\n", User_Data.Map_No);

	if (Num_Chosen > 0) {
		fprintf(fp, "\n[Startup]\n");

		Sat_Iterator = Sat_List;

		while (Sat_Iterator != NULL) {
			Sat = (struct Sat_Struct *)Sat_Iterator->data;
		
			if (Sat->Display)
				fprintf(fp, "satellite=%s\n", Sat->Name);
			
			Sat_Iterator = g_slist_next(Sat_Iterator);
		}

		if ((Sat = Find_Current()) != NULL)
			fprintf(fp, "current=%s\n", Sat->Name);
	}

	fclose(fp);
}