/*
	bday

	Birthday/Anniversary reminder

	(c) 2007 markus schnalke <meillo@marmaro.de>
	(c) 1994-1999 AS Mortimer

	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.  You may also
	distribute it under the Artistic License, as comes with Perl.

	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.

	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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

	You should also have recieved a copy of the Artistic license with
	this program.

===============================================================================

	Input is read through standard input. For example: bday < ~/.birthdays
	The input (file) has to have the following format:

	text=date flags

	where:
		date is yyyy-mm-dd
		flags is ONE or ZERO of
			bd  for a birthday (default)
			ann for an anniversary
			ev  for an event
		and zero or more of
			w <n> to set the warn-in-advance time to n days (don't include the
				brackets! :)
			to <date>
			for <days>
				to specify the length of time taken by an event, for example a holiday.

	Lines preceeded by # are treated as comments.

	Note: If you deviate from this format, I cannot guarantee anything about
	it's behaviour. In most cases, it will just quietly ignore the error,
	which probably isn't ideal behaviour. Oh, well.

===============================================================================
*/


/* standard time to warn in advance, when no explicit w flag is given. */
#define DEF_WARN 14


#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>



/* ========== Global constants and data types */


/* month lengths etc */
#define isleapyear(y) ((y)%4==0 && ((y)%100 != 0 || (y)%400 == 0))
const unsigned MLENDAT[];
#define mlen(m,y) (MLENDAT[(m)-1] != -1 ? MLENDAT[(m)-1] : (isleapyear((y)) ? 29 : 28))
#define before(a,b) ((a).month < (b).month || ((a).month == (b).month && (a).day < (b).day))
#define ydelta(a,b) ((int) (b).year - (a).year + before((a),(b)))

/* -------- modifier flags */
#define F_MTYPE 0x07
#define F_TBIRTHDAY 1
#define F_TANNIVERSARY 2
#define F_TEVENT 3

/* flags processed immediately on encountering */
#define F_MIMMEDIATE 0x24
#define F_WTIME_P 0x08
#define F_FORDAYS 0x16
#define F_TODATE 0x24

struct _ftable {char* txt; unsigned flag;};

const struct _ftable FTABLE[];

struct date {
  unsigned day;
  unsigned month;
  unsigned year;
};

struct event {
  char* text;
  struct date date;
  struct date enddate;
  int warn;
};

typedef int (*prnfunc)(const char *);

/* ========== Global Variables */

struct event* readlist(void);
void gettoday(void);
unsigned delta(struct date*);
unsigned ddiff(struct date* D1, struct date* D2);
void liststrings(struct event* evl, prnfunc outf);
char* tdelta(struct date* d);
char* ttime(int yr, int mn, int wk, int dy);
int skptok(int j, char* ptr);
int evcmp(const void* e1, const void* e2);


struct date today;
int iDWarn   = DEF_WARN;

const unsigned MLENDAT[]={31,-1,31,30,31,30,31,31,30,31,30,31};

const struct _ftable FTABLE[] = {
	{"bd", F_TBIRTHDAY},
	{"ann",F_TANNIVERSARY},
	{"ev", F_TEVENT},
	{"w",  F_WTIME_P},
	{"to", F_TODATE},
	{"for", F_FORDAYS},
	{NULL, 0}
};






/*
	xmalloc/xrealloc functions
	Note: the x* functions are lifted straight from the GNU libc info docs
	$Id: xmalloc.c,v 1.2 1999/01/16 17:08:59 andy Exp $
*/

void* xmalloc (size_t size) {
	register void* value = malloc (size);
	if (value == 0) {
		fprintf(stderr, "virtual memory exhausted\n");
		exit(1);
	}
	return value;
}

void* xrealloc (void* ptr, size_t size) {
	register void* value = realloc (ptr, size);
	if (value == 0) {
		fprintf(stderr, "virtual memory exhausted\n");
		exit(1);
	}
	return value;
}


/* ========== */


/* like strcat(), but lets the buffer automagically grow :-)
 * (needs local variable "size" with the buffer size) */
#define append(where, what) do {                            \
	if (strlen(what) > (size - strlen(where))) {          \
		xrealloc(where, size + 128 + strlen(what));   \
		size += 128 + strlen(what);                   \
	}                                                     \
	strcat(where, what);                                  \
} while(0)

/* ========== */

/* returns delta(d) in days, weeks, months, etc
 * the returned buffer is malloc()ed, do not forget to free() it */
char* tdelta(struct date* d) {
	int dy, wk, mn, yr;
	char* tmp;
	char* buf = xmalloc(128);
	int size = 128;
	*buf = 0;

	switch (delta(d)) {
		case 0:
			append(buf, "today");
			return buf;
		case 1:
			append(buf, "tomorrow");
			return buf;
		default:
			/* like delta(), we ignore the year */
			yr = -before(*d, today);
			mn = d->month - today.month;
			dy = d->day - today.day;

			if (dy < 0) {
				dy += mlen(today.month, today.year);
				mn--;
			}
			if (mn < 0) {
				mn += 12;
				yr++;
			}

			wk = (dy / 7);
			dy %= 7;

			append(buf, "in ");
			tmp = ttime(yr, mn, wk, dy);
			append(buf, tmp);
			free(tmp);

			return buf;
	}
}





/*
void donum(n,txt) {
	do {
		if (n > 0) {
			snprintf(tmp, sizeof(tmp), "%d", n);
			append(buf, tmp);
			append(buf, " " txt);
			if (n != 1)
				append(buf, "s");
			terms--;
			if (orgterms > 1) {
				if (terms == 1)
					append(buf, " and ");
				else if (terms > 1)
					append(buf, ", ");
			}
		}
	 } while(0)
}
*/


#define donum(n,txt) do {                       \
	if (n > 0) {                              \
		snprintf(tmp, sizeof(tmp), "%d", n);   \
		append(buf, tmp);                      \
		append(buf, " " txt);                  \
		if (n != 1)                            \
			append(buf, "s");                   \
		terms--;                               \
		if (orgterms > 1) {                    \
			if (terms == 1)                     \
				append(buf, " and ");            \
			else if (terms > 1)                 \
				append(buf, ", ");               \
		}                                      \
	}                                         \
} while(0)


/* returns allocated buffer, don't forget to free() */
char* ttime(int yr, int mn, int wk, int dy) {
	char* buf = xmalloc(128);
	int size = 128;
	int terms, orgterms;
	char tmp[128];

	*buf = 0; /* Initialize buffer */
	terms = orgterms = (yr!=0) + (mn!=0) + (wk!=0) + (dy!=0);

	donum(yr, "year");
	donum(mn, "month");
	donum(wk, "week");
	donum(dy, "day");

	return buf;
}
#undef donum






/* lists the birthdays in their string format, one by one, and passes the string to a function. */
void liststrings(struct event* evl, prnfunc outf) {
	int i,j;
	char *buf, *tmp;
	int size;

	for (i = 0; evl[i].text != NULL; i++) {
		buf = xmalloc(128);
		*buf = '\0';
		size = 128;

		if (evl[i].warn == -1 && delta(&(evl[i].date))==0) {
			 append(buf, evl[i].text);
		} else if (evl[i].enddate.day == 0) {
			if (delta(&(evl[i].date)) <= evl[i].warn) {
				append(buf, evl[i].text);
				append(buf, " ");
				tmp = tdelta(&(evl[i].date));
				append(buf, tmp);
				free(tmp);
			}
		} else {
			if (delta(&(evl[i].date)) <= evl[i].warn) {
				append(buf, evl[i].text);
				append(buf, " for ");
				/* +1 because, if the difference between two dates is one day, then the length of an event on those days is two days */
				j = ddiff(&(evl[i].date),&(evl[i].enddate)) + 1;
				tmp = ttime(0, 0, j/7, j%7);
				append(buf, tmp);
				free(tmp);
				append(buf, " ");
				tmp = tdelta(&(evl[i].date));
				append(buf, tmp);
			} else if (delta(&(evl[i].enddate)) <= evl[i].warn) {
				append(buf, evl[i].text);
				append(buf, " ");
				j = delta(&(evl[i].enddate));
				if (j) {
					append(buf, "for ");
					tmp = ttime(0, 0, j/7, j%7);
					append(buf, tmp);
					free(tmp);
					append(buf, " longer");
				} else {
					append(buf, "finishes today");
				}
			}
		}
		if (*buf) {
			append(buf, ".");
			outf(buf);
		}
		free(buf);
	}
}








/* sort the events by the time before the next time they come up, putting those
	 where the start has passed but we are still in the time-period first */
int evcmp(const void* p1, const void* p2) {
	struct event* e1=(struct event*) p1;
	struct event* e2=(struct event*) p2;
	unsigned d1, d2;

	/* if the delta for the enddate is less than that for the start date, then we
		have passed the start date but not yet the end date, and so we should
		display the enddate; otherwise, we should display the start date */

	d1=delta(&(e1->date));
	if (e1->enddate.day && delta(&(e1->enddate)) < d1)
		d1=delta(&(e1->enddate));

	d2=delta(&(e2->date));
	if (e2->enddate.day && delta(&(e2->enddate)) < d2)
		d2=delta(&(e2->enddate));

	if (d1 < d2) return -1;
	if (d1 > d2) return 1;

	return strcmp(e1->text, e2->text);
}






/* difference in days between two dates */
/* it is assumed that D1 < D2, and so the result is always positive */
unsigned ddiff(struct date* D1, struct date* D2) {
	struct date d1, d2;
	int dd, m;

	/* make working copies */
	d1 = *D1;
	d2 = *D2;

	/* sort out zero years */
	if (d1.year == 0 || d2.year==0) {
		if (d1.year != d2.year) {
			if (d1.year == 0) {
				if (before(d1,d2))
					d1.year = d2.year;
				else
					d1.year = d2.year - 1;
						} else {
				if (before(d1, d2))
					d2.year = d1.year;
				else
					d2.year = d1.year + 1;
			}
		} else { /* both years zero */
			if (before(d1, d2))
				d1.year = d2.year = today.year;
			else {
				d1.year = today.year;
				d2.year = d1.year + 1;
			}
		}
	}

	/* now we can actually do the comparison ... */
	dd = 0;

	/* to start with, we work in months */
	for (m=d1.month; m < d2.month + (d2.year-d1.year)*12; m++)
		dd += mlen(((m-1)%12)+1, d1.year + m/12);

	/* and then we renormalise for the days within the months */
	/* the first month was included in our calculations */
	dd -= d1.day;
	/* but the last one wasn't */
	dd += d2.day;

	return dd;
}








/* actually until the next anniversary of ... */
unsigned delta(struct date *date) {
	struct date d;
	unsigned dt, mn;

	memcpy(&d, date, sizeof(struct date));

	/* past the end of the year */
	if (before(d, today)) {
		d.year = 1;
	} else {
		d.year = 0;
	}

	for (mn = today.month, dt=0; mn < d.month + 12*d.year; mn++) {
		dt += mlen(((mn-1)%12) + 1,today.year + mn/12);
	}

	dt -= today.day;
	dt += d.day;

	return dt;
}






void gettoday(void) {
	struct tm *tm;
	time_t t;

	time(&t);
	tm = localtime(&t);
	today.day = tm->tm_mday;
	today.month = tm->tm_mon + 1; /* 1-12 instead of 0-11 */
	today.year = tm->tm_year + 1900;
}










struct event* readlist() {
	int i, j, k, l, d;
	struct event *evl;
	char buf[1024], buf2[1024];
	char *ptr;
	unsigned flags;

	/* initialise */
	gettoday();

	for (i = 0, evl = NULL; fgets(buf, sizeof(buf), stdin) != NULL; i++) {
		evl = (struct event *) xrealloc(evl, sizeof(struct event) * (i + 1));

		/* ignore comments and empty lines */
		if (*buf == '#' || *buf == '\n') {
			i--;
			continue;
		}

		/* parse string in buf */
		ptr = strrchr(buf, '='); /* allow '=' in text */

		/* not a valid line, so ignore it! Cool, huh? */
		/* Attention: only recognizes lines without '=' */
		if (ptr == NULL) {
			fprintf(stderr, "WARNING: Invalid line in input:\n%s", buf);
			i--;
			continue;
		}

		*(ptr++) = 0;

		j = sscanf(ptr, "%u-%u-%u", &(evl[i].date.year), &(evl[i].date.month), &(evl[i].date.day));
		/* ... unless it wasn't read, in which case set it to zero */
		if (j==2) {
			evl[i].date.year = 0;
		}


		/* parse flags */

		evl[i].warn = iDWarn;
		evl[i].enddate.day = 0;
		evl[i].enddate.month = 0;
		evl[i].enddate.year = 0;

		flags = 0;
		j = 0;

		while(j = skptok(j, ptr), ptr[j] != 0) {
			for (k = 0; FTABLE[k].txt != NULL && strncmp(FTABLE[k].txt, ptr + j, strlen(FTABLE[k].txt)); k++) {
			}

			switch (FTABLE[k].flag) {
				case F_WTIME_P: /* w <n> -- sets warning time */
					sscanf(ptr + j, "w %u", &(evl[i].warn));
					break;
				case F_FORDAYS: /* for <days> -- sets the duration of the event */
					sscanf(ptr + j, "for %u", &d);
					evl[i].enddate=evl[i].date;
					for (l = 1; l < d; l++) {
						evl[i].enddate.day++;
						if (evl[i].enddate.day > mlen(evl[i].enddate.month, evl[i].enddate.year)) {
							evl[i].enddate.month++;
							evl[i].enddate.day = 1;
						}
						if (evl[i].enddate.month > 12) {
							evl[i].enddate.year++;
							evl[i].enddate.month = 1;
						}
					}
					break;
				case F_TODATE: /* to <date> -- sets the end date of the event */
					l = sscanf(ptr + j, "to %u-%u-%u", &(evl[i].enddate.year), &(evl[i].enddate.month), &(evl[i].enddate.day));
					if (l == 2) {
						evl[i].enddate.year = 0;
					}
					break;
				case 0:
					break;
				default:
					flags |= FTABLE[k].flag;
					break;
			}
		}


		/* construct event text */

		switch(flags & F_MTYPE) {
			case F_TBIRTHDAY:
			default: /* assume it's a birthday */
				if (evl[i].date.year != 0) {
					int tmp_age = ydelta(evl[i].date, today);
					if (tmp_age != 1) {
						sprintf(buf2, "%s is %d years old", buf, tmp_age);
					} else {
						sprintf(buf2, "%s is %d year old", buf, tmp_age);
					}
				} else {
					sprintf(buf2, "%s has a birthday", buf);
				}
				break;
			case F_TANNIVERSARY:
				if (evl[i].date.year != 0) {
					sprintf(buf2, "%s %d years ago", buf, ydelta(evl[i].date, today));
				} else {
					strcpy(buf2, buf);
				}
				break;
			case F_TEVENT:
				/* if a year was specified, and this warning isn't for it, ignore! */
				if ((evl[i].date.year != 0 && ydelta(evl[i].date, today) != 0) && (evl[i].enddate.year == 0 || ydelta(evl[i].enddate, today) != 0)) {
					i--;
					continue;
				}
				strcpy(buf2, buf);
				break;
		}
		evl[i].text = strdup(buf2);
	}

	evl = (struct event *) xrealloc(evl, sizeof(struct event) * (i + 1));
	evl[i].date.day = 0;
	evl[i].date.month = 0;
	evl[i].date.year = 0;
	evl[i].text = (char *) NULL;

	fclose(stdin);

	/* NB uses i from above */
	qsort(evl, i, sizeof(struct event), evcmp);
	return evl;
}





int skptok(int j, char *ptr) {
	for (; ptr[j] != 0 &&  ptr[j] != ' ' && ptr[j] != '\t' ; j++);
	for (; ptr[j] != 0 && (ptr[j] == ' ' || ptr[j] == '\t'); j++);

	return j;
}






int main(int argc, char* argv[]) {

  while (--argc > 0 && (*++argv)[0] == '-') {
		if (strcmp(argv[0], "-W") == 0) {
			/* TODO: catch if no value given */
			iDWarn = atoi((++argv)[0]);
			argc--;
		} else {
			fprintf(stderr, "unknown option %s\n", argv[0]);
			exit(1);
		}
	}

	liststrings(readlist(), puts);

  return 0;
}