#include <malloc.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>
#include <xview/panel.h>
#include <xview/xview.h>

#include "defines.h"
#include "menudefs.h"
/*

Copyright (c) 1990,1991,1992 Steven Smith at the Harvard Genome Laboratory.
All rights reserved.
*/
ReadGDE(filename, dataset, type) char *filename;
NA_Alignment *dataset;
int type;
{
	register int done = FALSE, len = 0, j = 0;
	int success, count, temp = 0;
	char Inline[GBUFSIZ], c;
	char *buffer, *line, *gencomments = NULL, fields[8][GBUFSIZ];
	int buflen = GBUFSIZ, genclen = 0, curelem = 0, n = 0, flag = 0;
	NA_Sequence *this_elem = NULL, temp_elem;
	FILE *file;
	extern int Default_DNA_Trans[], Default_RNA_Trans[];
	extern int OVERWRITE, Default_NA_RTrans[], Default_PROColor_LKUP[];

	ErrorOut("No such file", file = fopen(filename, "r"));

	for (; fgets(Inline, GBUFSIZ, file) != 0;) {
		for (line = Inline; line[0] == ' ' || line[0] == '\t'; line++)
			;

		if (Find2(line, "{") == 0) {
			this_elem = &temp_elem;
			InitNASeq(this_elem, DNA);
			this_elem->offset = -(dataset->rel_offset);
		}
		else if (Find2(line, "type") == 0) {
			if (Find(line, "DNA")) {
				this_elem->elementtype = DNA;
				this_elem->tmatrix = Default_DNA_Trans;
				this_elem->rmatrix = Default_NA_RTrans;
			}
			else if (Find(line, "RNA")) {
				this_elem->elementtype = RNA;
				this_elem->tmatrix = Default_RNA_Trans;
				this_elem->rmatrix = Default_NA_RTrans;
			}
			else if (Find(line, "MASK")) {
				this_elem->elementtype = MASK;
				this_elem->rmatrix = NULL;
				this_elem->tmatrix = NULL;
				this_elem->col_lut = NULL;
			}
			else if (Find(line, "TEXT")) {
				this_elem->elementtype = TEXT;
				this_elem->rmatrix = NULL;
				this_elem->tmatrix = NULL;
				this_elem->col_lut = NULL;
			}
			else if (Find(line, "PROT")) {
				this_elem->elementtype = PROTEIN;
				this_elem->rmatrix = NULL;
				this_elem->tmatrix = NULL;
				this_elem->col_lut = Default_PROColor_LKUP;
			}
			/*
						this_elem->attr =
			   DEFAULT_X_ATTR;
			*/
		}
		else if (Find2(line, "circular") == 0) {
			sscanf(line, "%*s %d", &temp);
			if (temp == 1) {
				this_elem->attr |= IS_CIRCULAR;
			}
			else {
				this_elem->attr &= ~IS_CIRCULAR;
			}
		}
		else if (Find2(line, "orig_direction") == 0) {
			sscanf(line, "%*s %d", &temp);
			if (temp == 1) {
				this_elem->attr |= IS_ORIG_5_TO_3;
				this_elem->attr &= ~IS_ORIG_3_TO_5;
			}
			else {
				this_elem->attr |= IS_ORIG_3_TO_5;
				this_elem->attr &= ~IS_ORIG_5_TO_3;
			}
		}
		else if (Find2(line, "direction") == 0) {
			sscanf(line, "%*s %d", &temp);
			if (temp == 1) {
				this_elem->attr |= IS_5_TO_3;
				this_elem->attr &= ~IS_3_TO_5;
			}
			else {
				this_elem->attr |= IS_3_TO_5;
				this_elem->attr &= ~IS_5_TO_3;
			}
		}
		else if (Find2(line, "orig_strand") == 0) {
			sscanf(line, "%*s %d", &temp);
			if (temp == 1) {
				this_elem->attr |= IS_ORIG_PRIMARY;
				this_elem->attr &= ~IS_ORIG_SECONDARY;
			}
			else {
				this_elem->attr |= IS_ORIG_SECONDARY;
				this_elem->attr &= ~IS_ORIG_PRIMARY;
			}
		}
		else if (Find2(line, "strandedness") == 0) {
			sscanf(line, "%*s %d", &temp);
			if (temp == 1) {
				this_elem->attr |= IS_PRIMARY;
				this_elem->attr &= ~IS_SECONDARY;
			}
			else {
				this_elem->attr |= IS_SECONDARY;
				this_elem->attr &= ~IS_PRIMARY;
			}
		}
		else if (Find2(line, "creator") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->authority);
			RemoveQuotes(this_elem->authority);
		}
		else if (Find2(line, "longname") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->seq_name);
			RemoveQuotes(this_elem->seq_name);
		}
		else if (Find2(line, "descrip") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->description);
			RemoveQuotes(this_elem->description);
		}
		else if (Find2(line, "name") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->short_name);
			RemoveQuotes(this_elem->short_name);
		}
		else if (Find2(line, "group-ID") == 0) {
			sscanf(line, "%*s %d", &(this_elem->groupid));
			dataset->numgroups =
			    MAX(this_elem->groupid, dataset->numgroups);
		}
		else if (Find2(line, "sequence-ID") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->id);
			RemoveQuotes(this_elem->id);
		}
		else if (Find2(line, "barcode") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->barcode);
			RemoveQuotes(this_elem->barcode);
		}
		else if (Find2(line, "membrane") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->membrane);
			RemoveQuotes(this_elem->membrane);
		}
		else if (Find2(line, "contig") == 0) {
			sscanf(line, "%*s %[^\n]", this_elem->contig);
			RemoveQuotes(this_elem->contig);
		}
		else if (Find2(line, "creation-date") == 0) {
			sscanf(line, "%*s %2d%*c%2d%*c%2d%*c%2d%*c%2d%*c%2d\n",
			       &(this_elem->t_stamp.origin.mm),
			       &(this_elem->t_stamp.origin.dd),
			       &(this_elem->t_stamp.origin.yy),
			       &(this_elem->t_stamp.origin.hr),
			       &(this_elem->t_stamp.origin.mn),
			       &(this_elem->t_stamp.origin.sc));
		}
		else if (Find2(line, "offset") == 0) {
			sscanf(line, "%*s %d", &(this_elem->offset));
			this_elem->offset -= dataset->rel_offset;
		}
		else if (Find2(line, "comments") == 0) {
			if (this_elem->comments_maxlen == 0)
				buflen = 2048;
			else
				buflen = this_elem->comments_maxlen;

			done = FALSE;
			len = this_elem->comments_len;

			for (; line[0] != '"'; line++)
				if (line[0] == '\0')
					ErrorOut(0, "Error in input file");
			line++;
			buffer = Calloc(buflen, sizeof(char));
			for (; !done;) {
				for (j = 0; j < strlen(line); j++) {
					if (len + strlen(line) >= buflen) {
						buflen *= 2;
						buffer = Realloc(
						    buffer,
						    buflen * sizeof(char));
					}
					if (line[j] == '"')
						done = TRUE;

					else
						buffer[len++] = line[j];
				}
				/*
				 *	 Check pad with null
				 */
				buffer[len] = '\0';
				if (!done) {
					if (fgets(Inline, GBUFSIZ, file) == 0)
						done = TRUE;
					line = Inline;
				}
			}
			this_elem->comments = buffer;
			this_elem->comments_len = strlen(buffer);
			this_elem->comments_maxlen = buflen;
			RemoveQuotes(this_elem->comments);
		}
		else if (Find2(line, "sequence") == 0) {
			buflen = GBUFSIZ;
			done = FALSE;
			len = 0;

			buffer = Calloc(buflen, sizeof(char));
			for (; line[0] != '"'; line++)
				if (line[0] == '\0')
					ErrorOut(0, "Error in input file");

			line++;
			for (; !done;) {
				for (j = 0; j < strlen(line); j++) {
					if (len + strlen(line) >= buflen) {
						buflen *= 2;
						buffer = Realloc(
						    buffer,
						    buflen * sizeof(char));
					}
					if (line[j] == '"')
						done = TRUE;

					else {
						/*
						 *			If not
						 *text, ignore spaces...
						 */
						if (this_elem->elementtype !=
						    TEXT) {
							if (line[j] != ' ' &&
							    line[j] != '\t' &&
							    line[j] != '\n')
								buffer[len++] =
								    line[j];
						}
						else if (line[j] != '\t' &&
							 line[j] != '\n')
							buffer[len++] = line[j];
					}
				}
				if (!done) {
					if (fgets(Inline, GBUFSIZ, file) == 0)
						done = TRUE;
					line = Inline;
				}
			}
			if (this_elem->rmatrix)
				for (j = 0; j < len; j++)
					buffer[j] =
					    this_elem->rmatrix[buffer[j]];
			this_elem->sequence = (NA_Base *)buffer;
			this_elem->seqlen = len;
			this_elem->seqmaxlen = buflen;
		}

		else if (Find2(line, "}") == 0) {
			if (this_elem->id[0] == '\0')
				strncpy(this_elem->id, uniqueID(), 79);
			if (this_elem->short_name[0] == '\0')
				strncpy(this_elem->short_name, this_elem->id,
					79);
			if (this_elem->seqlen == 0)
				this_elem->protect =
				    PROT_BASE_CHANGES + PROT_GREY_SPACE +
				    PROT_WHITE_SPACE + PROT_TRANSLATION;
			genclen = 0;
			/*
			 *		Make a new sequence entry...
			 */

			success = -1;
			if (OVERWRITE) success = OverWrite(this_elem, dataset);

			if (success == -1) {
				curelem = dataset->numelements++;
				if (curelem == 0) {
					dataset->element =
					    (NA_Sequence *)Calloc(
						5, sizeof(NA_Sequence));
					dataset->maxnumelements = 5;
				}
				else if (curelem == dataset->maxnumelements) {
					(dataset->maxnumelements) *= 2;
					dataset->element =
					    (NA_Sequence *)Realloc(
						dataset->element,
						dataset->maxnumelements *
						    sizeof(NA_Sequence));
				}
				dataset->element[curelem] = *this_elem;
			}
		}
		else if (this_elem != NULL) {
			if (this_elem->baggage == NULL) {
				this_elem->baggage = String(line);
				this_elem->baggage_maxlen =
				    this_elem->baggage_len =
					strlen(this_elem->baggage) + 1;
			}
			else {
				this_elem->baggage_len += strlen(line) + 1;
				this_elem->baggage = Realloc(
				    this_elem->baggage,
				    this_elem->baggage_len * sizeof(char));
				this_elem->baggage_maxlen =
				    this_elem->baggage_len;

				strncat(this_elem->baggage, line, GBUFSIZ);
			}
		}
	}

	fclose(file);
	NormalizeOffset(dataset);
	Regroup(dataset);
	AdjustGroups(dataset);
	return;
}

WriteGDE(aln, filename, method, maskable) NA_Alignment *aln;
char *filename;
int method, maskable;
{
	int i, j, k, mask = -1;
	FILE *file;
	NA_Sequence *this_elem;
	extern char month[12][6];

	if (aln == NULL) return;
	if (aln->na_ddata == NULL) return;

	file = fopen(filename, "w");
	if (file == NULL) {
		Warning("Cannot open file for output");
		return (1);
	}

	if (maskable && method != SELECT_REGION)
		for (j = 0; j < aln->numelements; j++)
			if (aln->element[j].elementtype == MASK &&
			    aln->element[j].selected)
				mask = j;

	for (j = 0; j < aln->numelements; j++) {
		if ((aln->element[j].selected && j != mask &&
		     method != SELECT_REGION) ||
		    (method == ALL) ||
		    (aln->element[j].subselected && method == SELECT_REGION)) {
			this_elem = &(aln->element[j]);
			SeqNorm(this_elem);
			fprintf(file, "{\n");
			if (this_elem->short_name[0])
				fprintf(file, "name	\"%s\"\n",
					this_elem->short_name);
			switch (this_elem->elementtype) {
				case DNA:
					fprintf(file,
						"type		\"DNA\"\n");
					break;
				case RNA:
					fprintf(file,
						"type		\"RNA\"\n");
					break;
				case PROTEIN:
					fprintf(file,
						"type		\"PROTEIN\"\n");
					break;
				case MASK:
					fprintf(file,
						"type		\"MASK\"\n");
					break;
				case TEXT:
					fprintf(file,
						"type		\"TEXT\"\n");
					break;
			}
			if (this_elem->seq_name[0])
				fprintf(file, "longname	%s\n",
					this_elem->seq_name);

			if (this_elem->id[0])
				fprintf(file, "sequence-ID	\"%s\"\n",
					this_elem->id);
			RemoveQuotes(this_elem->barcode);
			RemoveQuotes(this_elem->contig);

			if (this_elem->barcode[0])
				fprintf(file, "barcode		\"%s\"\n",
					this_elem->barcode);
			if (this_elem->membrane[0])
				fprintf(file, "membrane		\"%s\"\n",
					this_elem->membrane);
			if (this_elem->contig[0])
				fprintf(file, "contig		\"%s\"\n",
					this_elem->contig);
			if (this_elem->description[0])
				fprintf(file, "descrip		\"%s\"\n",
					this_elem->description);
			if (this_elem->authority[0])
				fprintf(file, "creator		\"%s\"\n",
					this_elem->authority);
			if (this_elem->groupid)
				fprintf(file, "group-ID		%d\n",
					this_elem->groupid);
			if (this_elem->offset + aln->rel_offset &&
			    method != SELECT_REGION)
				fprintf(file, "offset		%d\n",
					this_elem->offset + aln->rel_offset);
			if (method == SELECT_REGION) {
				/*
				 *	If selecting a region, the offset should
				 *be moved to the first non-'0' space in the
				 *mask.
				 */
				for (k = this_elem->offset;
				     k < aln->selection_mask_len &&
				     aln->selection_mask[k] == '0';
				     k++)
					;
				fprintf(file, "offset        %d\n",
					aln->rel_offset + k);
			}
			if (this_elem->t_stamp.origin.mm != 0)
				fprintf(
				    file,
				    "creation-date	%2d/%2d/%2d "
				    "%2d:%2d:%2d\n",
				    this_elem->t_stamp.origin.mm,
				    this_elem->t_stamp.origin.dd,
				    (this_elem->t_stamp.origin.yy) > 1900
					? (this_elem->t_stamp.origin.yy - 1900)
					: (this_elem->t_stamp.origin.yy),
				    this_elem->t_stamp.origin.hr,
				    this_elem->t_stamp.origin.mn,
				    this_elem->t_stamp.origin.sc);
			if ((this_elem->attr & IS_ORIG_5_TO_3) &&
			    ((this_elem->attr & IS_ORIG_3_TO_5) == 0))
				fprintf(file, "orig_direction	1\n");

			if ((this_elem->attr & IS_CIRCULAR))
				fprintf(file, "circular	1\n");

			if ((this_elem->attr & IS_5_TO_3) &&
			    ((this_elem->attr & IS_3_TO_5) == 0))
				fprintf(file, "direction	1\n");

			if ((this_elem->attr & IS_ORIG_3_TO_5) &&
			    ((this_elem->attr & IS_ORIG_5_TO_3) == 0))
				fprintf(file, "orig_direction	-1\n");

			if ((this_elem->attr & IS_3_TO_5) &&
			    ((this_elem->attr & IS_5_TO_3) == 0))
				fprintf(file, "direction	-1\n");

			if ((this_elem->attr & IS_ORIG_PRIMARY) &&
			    ((this_elem->attr & IS_ORIG_SECONDARY) == 0))
				fprintf(file, "orig_strand	1\n");

			if ((this_elem->attr & IS_PRIMARY) &&
			    ((this_elem->attr & IS_SECONDARY) == 0))
				fprintf(file, "strandedness	1\n");

			if (((this_elem->attr & IS_ORIG_PRIMARY) == 0) &&
			    (this_elem->attr & IS_ORIG_SECONDARY))
				fprintf(file, "orig_strand	2\n");

			if (((this_elem->attr & IS_PRIMARY) == 0) &&
			    (this_elem->attr & IS_SECONDARY))
				fprintf(file, "strandedness	2\n");

			if (this_elem->comments != NULL) {
				StripSpecial(this_elem->comments);
				fprintf(file, "comments	\"%s\"\n",
					this_elem->comments);
			}
			if (this_elem->baggage != NULL) {
				if (this_elem
					->baggage[strlen(this_elem->baggage) -
						  1] == '\n')
					fprintf(file, "%s", this_elem->baggage);
				else
					fprintf(file, "%s\n",
						this_elem->baggage);
			}
			fprintf(file, "sequence	\"");
			if (this_elem->tmatrix) {
				if (mask == -1) {
					for (k = this_elem->offset;
					     k < this_elem->seqlen +
						     this_elem->offset;
					     k++) {
						if (k % 60 == 0)
							putc('\n', file);
						if (method == SELECT_REGION) {
							if (aln->selection_mask
								[k] == '1')
								putc(
								    this_elem->tmatrix
									[getelem(
									    this_elem,
									    k)],
								    file);
						}
						else
							putc(this_elem->tmatrix
								 [getelem(
								     this_elem,
								     k)],
							     file);
					}
				}
				else {
					for (i = 0, k = this_elem->offset;
					     k < this_elem->seqlen +
						     this_elem->offset;
					     k++)
						if (aln->element[mask].seqlen +
							this_elem->offset >
						    k)
							if ((char)getelem(
								&(aln->element
								      [mask]),
								k) != '0' &&
							    ((char)getelem(
								 &(aln->element
								       [mask]),
								 k) != '-')) {
								if (i % 60 == 0)
									putc(
									    '\n',
									    file);
								putc(
								    this_elem->tmatrix
									[getelem(
									    this_elem,
									    k)],
								    file);
								i++;
							}
				}
				fprintf(file, "\"\n");
			}
			else {
				if (mask == -1) {
					for (k = this_elem->offset;
					     k < this_elem->seqlen +
						     this_elem->offset;
					     k++) {
						if (k % 60 == 0)
							putc('\n', file);
						if (method == SELECT_REGION) {
							if (aln->selection_mask
								[k] == '1')
								putc(
								    getelem(
									this_elem,
									k),
								    file);
						}
						else
							putc(getelem(this_elem,
								     k),
							     file);
					}
				}
				else {
					for (i = 0, k = this_elem->offset;
					     k < this_elem->seqlen +
						     this_elem->offset;
					     k++)
						if (((aln->element[mask]
							  .seqlen) +
						     (aln->element[mask]
							  .offset)) > k)
							if ((char)getelem(
								&(aln->element
								      [mask]),
								k) == '1') {
								if (i % 60 == 0)
									putc(
									    '\n',
									    file);
								putc(
								    getelem(
									this_elem,
									k),
								    file);
								i++;
							}
				}
				fprintf(file, "\"\n");
			}
			fprintf(file, "}\n");
		}
	}
	fclose(file);
	return;
}

StripSpecial(string) char *string;
{
	register int i, j, len;

	len = strlen(string);
	for (j = 0; j < len; j++) {
		if (string[j] == '"')
			string[j] = '`';
		else if (string[j] == '{')
			string[j] = '(';
		else if (string[j] == '}')
			string[j] = ')';
	}
	return;
}

RemoveQuotes(string) char *string;
{
	register int i, j, len;

	len = strlen(string);
	for (j = 0; j < len; j++)
		if (string[j] == '"') string[j] = ' ';

	for (j = 0; string[j] == ' ' && j < strlen(string); j++)
		;

	len = strlen(string);
	for (i = 0; i < len - j; i++) string[i] = string[i + j];

	for (j = strlen(string) - 1;
	     j >= 0 && (string[j] == '\n' || string[j] == ' '); j--)
		string[j] = '\0';

	return;
}

/*
 *       Normalize seq (remove leading indels in the sequence;
 */
void SeqNorm(seq) NA_Sequence *seq;
{
	int len, j, shift_width, trailer;
	char *sequence;
	len = seq->seqlen;

	sequence = (char *)seq->sequence;

	if (len == 0) return;

	if (seq->tmatrix)
		for (shift_width = 0; (shift_width < len) &&
				      ((sequence[shift_width] & 15) == '\0');
		     shift_width++)
			;
	else
		for (shift_width = 0;
		     (shift_width < len) && (sequence[shift_width] == '-');
		     shift_width++)
			;

	for (j = 0; j < len - shift_width; j++)
		sequence[j] = sequence[j + shift_width];

	seq->seqlen -= shift_width;
	seq->offset += shift_width;
	for (trailer = seq->seqlen - 1;
	     (sequence[trailer] == '-' || sequence[trailer] == '\0') &&
	     trailer >= 0;
	     trailer--)
		sequence[trailer] = '\0';
	seq->seqlen = trailer + 1;
	return;
}

/* ALWAYS COPY the result from uniqueID() to a char[32],
 * (strlen(hostname)+1+10).  Memory is lost when the function
 * is finished.
 */
char vname[32];
char *uniqueID()
{
	char hname[32]; /* ,vname[32]; rtm 18.III.98 */
	int hnamelen = 32;
	time_t *tp;
	static cnt = 0;

	tp = (time_t *)Calloc(1, sizeof(time_t));

	if (gethostname(hname, 10) == -1) {
		fprintf(stderr, "UniqueID(): Failed to get host name.\n");
		exit(1);
	}

	time(tp);
	sprintf(vname, "%s:%d:%ld", hname, cnt, *tp);
	cnt++;
	Cfree(tp);
	return (vname);
}

/*
 *	OverWrite(), overwrite all non-default data from a sequence entry
 *	onto any entry with the same ID or short name.
 */
OverWrite(this, aln) NA_Sequence *this;
NA_Alignment *aln;
{
	int j, indx = -1;
	NA_Sequence *that;
	for (j = 0; j < aln->numelements; j++) {
		if (Find2(this->id, aln->element[j].id) != -1)
			if (Find2(aln->element[j].id, this->id) != -1) indx = j;
	}
	if (indx == -1)
		for (j = 0; j < aln->numelements; j++) {
			if (Find2(this->short_name,
				  aln->element[j].short_name) != -1)
				if (Find2(aln->element[j].short_name,
					  this->short_name) != -1)
					indx = j;
		}
	if (indx != -1) {
		that = &(aln->element[indx]);
		if (this->seq_name[0]) strcpy(that->seq_name, this->seq_name);
		if (this->barcode[0]) strcpy(that->barcode, this->barcode);
		if (this->contig[0]) strcpy(that->contig, this->contig);
		if (this->membrane[0]) strcpy(that->membrane, this->membrane);
		if (this->authority[0])
			strcpy(that->authority, this->authority);
		if (this->short_name[0])
			strcpy(that->short_name, this->short_name);
		if (this->description[0])
			strcpy(that->description, this->description);
		if (this->sequence) {
			cfree(that->sequence);
			that->sequence = this->sequence;
			that->seqlen = this->seqlen;
			that->seqmaxlen = this->seqmaxlen;
		}
		if (this->baggage) {
			that->baggage_len += this->baggage_len;
			that->baggage_maxlen += this->baggage_maxlen;
			if (that->baggage)
				that->baggage = Realloc(
				    that->baggage,
				    that->baggage_maxlen * sizeof(char));
			else
				that->baggage =
				    Calloc(that->baggage_maxlen, sizeof(char));
			strncat(that->baggage, this->baggage,
				that->baggage_maxlen);
		}
		if (this->comments) {
			that->comments_len += this->comments_len;
			that->comments_maxlen += this->comments_maxlen;
			if (that->comments)
				that->comments = Realloc(
				    that->comments,
				    that->comments_maxlen * sizeof(char));
			else
				that->comments =
				    Calloc(that->comments_maxlen, sizeof(char));
			strncat(that->comments, this->comments,
				that->comments_maxlen);
		}
		if (this->cmask) {
			cfree(that->cmask);
			that->cmask = this->cmask;
		}
		if (this->offset != that->offset) that->offset = this->offset;
		if (this->attr != 0) that->attr = this->attr;
		if (this->groupid != 0) {
			that->groupid = this->groupid;
		}
		that->groupb = NULL;
		that->groupf = NULL;
	}
	/*
		NormalizeOffset(aln);
		Regroup(aln);
		AdjustGroups(aln);
	*/
	return (indx);
}