//my hate for java
#include <stdio.h>
#include <unistd.h>

#define DEFAULT_BUFFER_SIZE 1024

#define VERBOSE(x)		fprintf(stderr, x)
#define ELEMENTCOUNT(x)		sizeof(x)/sizeof(*x)


typedef struct _param {
	char *datatype;
	char *name;
	char *comment;
	int is_array;
	char *is_collection;
} param;
#define NEW_PARAM_P(x)	x = (param *) malloc(sizeof(param));\
			memset(x, 0, sizeof(param);

#define M_ABSTRACT	1
#define M_FINAL		2
#define	M_INTERFACE	4
#define M_NATIVE	8
#define M_PRIVATE	16
#define M_PROTECTED	32
#define M_PUBLIC	64
#define M_STATIC	128
#define M_STRICT	256
#define M_SYNCHRONIZED	512
#define M_TRANSIENT	1024
#define M_VOLATILE	2048
typedef struct _kv {
	char *key;
	int val;
} kv;

kv modkv[] = {	{"abstract", M_ABSTRACT},
		{"interface", M_INTERFACE},
		{"native", M_NATIVE},
		{"private", M_PRIVATE},
		{"protected", M_PROTECTED},
		{"public", M_PUBLIC},
		{"static", M_STATIC},
		{"strict", M_STRICT},
		{"final", M_FINAL},
		{"synchronized", M_SYNCHRONIZED},
		{"transient", M_TRANSIENT},
		{"volatile", M_VOLATILE}
	};

int get_mod_flag_mask(char *str) {
	int i;
	for (i = 0; i < ELEMENTCOUNT(modkv); i++)
		if (!strcmp(str, modkv[i].key)) 
			return(modkv[i].val);
	return(0);
}

char *get_mod_str(int modifiers) {
	static char ret[sizeof(modkv)];
	ret[0] = 0;
	int i;
	for (i = 0; i < ELEMENTCOUNT(modkv); i++) 
		if (modifiers & modkv[i].val) {
			strcat(ret, modkv[i].key);
			strcat(ret, " ");
		}
	ret[strlen(ret) - 1] = 0;
	return(ret);
}

typedef struct _sentinel {
	char *name;
	int datatype;
	param **c_exception;
	param **c_arg;
	char *c_return;
	int modifiers;
} sentinel;
#define NEW_SENTINEL_P(x)	x = (sentinel *) malloc(sizeof(param));\
				memset(x, 0, sizeof(param));

#define IS_WHITESPACE(x)	(x == ' ' || x == '\t' || x == '\r' || x == '\n' || x == '\0')
int set_mod_type(sentinel *rs, char *ptr, int type) {
	char *ret;
	int argc, arglim;
	char **args;
	char c;
	int state, i, t;

	argc = 0;
	args = 0;
	state = 0;

	for (i = 0; c = ptr[i], state != -1; i++) {
		if (IS_WHITESPACE(c)) {
			if (state = 1) {
				ptr[i] = 0;
				state = c ? 0 : -1;
			}
		} else {
			if (state == 0) {
				args = (char **)realloc(args, (argc + 1) * sizeof(char*));
				args[argc++] = ptr + i;
				state = 1;
			}
		}
	}

	rs->modifiers = 0;
	for (i = 0; i < argc; i++){
		if (!(t = get_mod_flag_mask(args[i])))
			break;
		rs->modifiers |= t;
	}

	return(strlen(ptr));
}

char *tagptr_str[] = {
	"<!-- ============ FIELD DETAIL =========== -->",
	"<!-- ========= CONSTRUCTOR DETAIL ======== -->",
	"<!-- ============ METHOD DETAIL ========== -->",
 	"<!-- ========= END OF CLASS DATA ========= -->"
};

#define TAG_FIELD	0
#define TAG_CON		1
#define TAG_METH	2
#define TAG_EOF		3

char *tagptr[ELEMENTCOUNT(tagptr_str)];
	
int debuglevel = 1;

int ptrlevel(char *ptr) {
	int i;
	for (i = ELEMENTCOUNT(tagptr) - 1; i >= 0; i--)
		if (ptr > tagptr[i])
			return(i);
	return(0);
}

char *eof_read(FILE *ffd) {
	char *ret = (char *)malloc(DEFAULT_BUFFER_SIZE);
	int nbytes = 0;
	int allocated = DEFAULT_BUFFER_SIZE;
	while (nbytes += fread(ret + nbytes, 1, allocated - nbytes, ffd), !feof(ffd)) 
		if (nbytes == allocated)
			ret = (char *)realloc(ret, (allocated += DEFAULT_BUFFER_SIZE));
	if (nbytes < 0)
		return(0);
	return(ret);
}

int capture_stdin(char **ret) {
	return((*ret = eof_read(stdin)) == 0);
}

int load_image(char *filename, char **ret) {
	FILE *filefd;
	if (!(filefd = fopen(filename, "r"))) {
		return(0);
	}
	*ret = eof_read(filefd);
	fclose(filefd);
	return(*ret == 0);
}

char *find_a_tag(char *start) {
	char *ptr, *nl, *end;
	while (1) {
		if ((ptr = strstr(start, "<A NAME=\"")) == 0 || 
			(nl = strstr(ptr, "\n")) == 0 || 
			(end = strstr(ptr, "\"><!-- --></A><H3>")) == 0) {
			return(0);
		}
		if (end > nl) {
			start = ptr + 1;
			continue;
		}
		return(nl + 1);
	}
}

typedef struct _sar {
	char *html;
	char *rep;
} sar;

sar repkw[] = {
	{"&lt;", "<"},
	{"&gt;", ">"},
	{"&nbsp;", " "},
	{"&quot;", "\""},
	{"\t", " "},
	{"\n", " "},
	{"\r", " "}
};

char *search_replace(char *str, sar *kw) {
	int i, hlen, replen, last;
	int allocated, nbytes, write;
	char *ptr, *ret;
	allocated = nbytes = strlen(str) + 1;
	ret = (char *)malloc(nbytes);
	strcpy(ret, str);
	for (i = 0; i < ELEMENTCOUNT(repkw); i++) {
		hlen = strlen(repkw[i].html);
		replen = strlen(repkw[i].rep);
		for (last = 0; (ptr = strstr(ret + last, repkw[i].html));) {
			write = last = ptr - ret;
			if (hlen > replen) {
				memmove(ret + last + replen, ret + last + hlen, nbytes - last - hlen);
				nbytes -= hlen - replen;
			} else if (replen > hlen) {
				if ((nbytes += replen - hlen) > allocated - nbytes) 
					ret = (char *)realloc(ret, (allocated += DEFAULT_BUFFER_SIZE < hlen ? hlen : DEFAULT_BUFFER_SIZE));
				memmove(ret + last + replen - 1, ret + last, nbytes - last + 1);
				last += replen;
			}
			strncpy(ret + write, repkw[i].rep, replen);
		}
	}
	return(ret);
}

char *kill_html(char *str) {
	char *ret, *working, c, q;
	int i, j, state, ws;
	working = (char *)malloc(strlen(str) + 128);
	
	for (ws = state = i = j = 0; (c = str[i]); i++) {
		if (IS_WHITESPACE(c)) {
			if (ws)
				continue;
			c = ' ';
			ws = 1;
		} else
			ws = 0;

		if (state == 0) {
			if (c == '<')
				state = 1;
			else
				working[j++] = c;
		} else if (state == 1) {
			if (c == '>')
				state = 0;
			if (c == '\'' || c == '"') {
				state = 2;
				q = c;
			}
		} else if (state == 2) {
			if (c == q)
				state = 1;
		}
	}
	working[j] = 0;
	ret = search_replace(working, repkw);
	free(working);
	return(ret);
}

int whitelen(char *str) {
	register int i;
	register char c;
	c = *str;
	if (IS_WHITESPACE(c))
		return(c != 0);
	for (i = 1; c = str[i], !IS_WHITESPACE(c); i++);
	return(i);
}

char *breakline(char **str, int ccount) {
	static char ret[DEFAULT_BUFFER_SIZE + 1];
	int i, l, ws;
	char c;
	
	if (*str == 0) 
		return(0);
		
	if (DEFAULT_BUFFER_SIZE < ccount)
		ccount = DEFAULT_BUFFER_SIZE;

	for(i = 0, ws = -1; (c = **str) && i < ccount; (*str)++) 
		if (IS_WHITESPACE(c)) {
			if (ws == 0) 
				ws = 1;
		} else {
			if ((l = whitelen(*str)) + i + ((ws == 1) ? 1 : 0) >= ccount)
				break;
			if (ws == 1) 
				ret[i++] = ' ';
			ws = 0;

			strncpy(ret + i, *str, (l = whitelen(*str)));
			i += l;

			*str += l - 1;
		}

	if (ws == -1) {
		*str = 0;
		return(0);
	}

	ret[i] = 0;
	return(ret);
}

int main(int argc, char **argv) {
	char *str;
	int methodanal = 0;
	int i;
	int fot = TAG_EOF;

	load_image(argv[1], &str);

	for (i = ELEMENTCOUNT(tagptr) - 1; i >= 0; i--) 
		if ((tagptr[i] = strstr(str, tagptr_str[i])))
			fot = i;

	if (fot == TAG_EOF) {
		fprintf(stderr, "[-] Could not locate appropriate tags.\n");
		return(1);
	} else if (debuglevel) 
		fprintf(stderr, "[+] Found tags, highest ranked tag `%s'.\n", tagptr_str[fot]);
	
	char *at, *hptr, *modhptr;
	char *end;
	sentinel *temsen;
	do {
		if (!(at = find_a_tag(str)))
			break;

		if (!(hptr = strchr(at, '<')))
			continue;
		if (!(end = strstr(at, "<HR>\n\n")))
			continue;
		*end = 0;

		NEW_SENTINEL_P(temsen);
		temsen->name = (char *)strndup(at, hptr - at);
		hptr += 12;
		char *dz = strstr(hptr, "</PRE>");
		char *throws = strstr(hptr, "Throws:");
		char *throwsend;
		char *retrut = strstr(hptr, "Returns:");
		char *retend;
		char *parm = strstr(hptr, "Parameters:");
		char *parmend;
		char *desc = strstr(dz, "<DD>");
		char *descend = strstr(desc, "<P>");
		int lev = ptrlevel(at);

		*descend = 0;
		//printf("\t/**\n\t *\n%s\n", kill_html(desc));
		char *lolz = kill_html(desc), *t;
		printf("\t/**\n");
		while ((t = breakline(&lolz, 75)))
			printf("\t * %s\n", t);
		printf("\t *\n");

		*descend = '<';
		if (parm && lev > 0) {
			parm += 11;
			if ((parmend = strchr(parm, '\n'))) {
				*parmend = 0;
				char *t;
				for (t = parm; (t = strstr(t, "<CODE>")); t++) {
					char *wtf = strstr(t, "<DD>");
					if (wtf)
						*wtf = 0;
					printf("\t * @param %s\n", kill_html(t));
					if (wtf)
						*wtf = '<';
				}
				
				*parmend = '\n';
			}
		}
		if (retrut && lev == 2) {
			retrut += 8;
			if ((retend = strstr(retrut, "</DL>"))) {
				*retend = 0;
				printf("\t * @return %s\n", kill_html(retrut));
				*retend = '.';
			}
		}
		if (throws && (throwsend = strstr(throws, "</DL>")) && lev > 0) {
			throws += 6;
			*throwsend = 0;
			printf("\t * @throws %s\n", kill_html(throws) + 2);
			*throwsend = '<';
		}
		printf("\t */\n");
		*end = '<';
		*dz = 0;
		printf("\t%s %s\n", kill_html(hptr), lev > 0 ? "{\n\n\t}" : ";");
		*dz = '<';
		printf("\n\n\n");
	} while( (str = at) < tagptr[TAG_EOF]);

	return(0);

}