/*
*	cutof text-lines
*
*	Nicholas Christopoulos
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <pcre.h>

typedef char *	char_p;

#define OVECCOUNT 30    /* should be a multiple of 3 */

///////////////////////////////////////////////////////////////////////////////////////////////////////////
// classic... text buffers 

// strdup using new[]
char	*pstrdup(const char *source)
{
	char	*ns = new char[strlen(source)+1];
	strcpy(ns, source);
	return ns;
}

// typical node (abstract class)
class node {
public:
	node	*next;
	node()	{ next = NULL; }
	virtual ~node() { }
	};

// typical list (abstract class)
class list : public node {
public:
	node	*head, *tail;

	list() : node()	{ head = tail = NULL; }
	virtual	~list()	{ clear(); }

	// clean up
	void	clear()	{
		node	*cp, *pp;

		cp = head;
		while ( cp )	{
			pp = cp;
			cp = cp->next;
			delete pp;
			}
		}

	// connect a new node
	void	connect(node *np)	{
		if	( !head )	
			head = tail = np;
		else
			( tail->next = np, tail = np );
		}
	};

// text node / text line
class tnode : public node {
public:
	char	*line;
	pcre	*re;
	int		type;
	char	*data;

	tnode(const char *src) : node()	{ line = pstrdup(src); type = 0; data = NULL; }
	virtual ~tnode()				{ delete[] line; if (data) delete[] data; }
	void	setData(const char *s)	{ if ( data ) delete[] data; data = pstrdup(s); }
	};

// text list
class tlist : public list {
public:
	tlist() : list()	{ }
	virtual ~tlist()	{ }

	// add a new line
	tnode	*add(const char *text)	{
		tnode	*np = new tnode(text);
		connect(np);
		return np;
		}
	};

// buffer list
class buflist : public list	{
public:
	buflist() : list()	{ }
	virtual ~buflist()	{ }

	// add a new buffer
	tlist	*add()	{
		tlist	*np = new tlist();
		connect(np);
		return np;
		}
	};

///////////////////////////////////////////////////////////////////////////////////////////////////////////

//buflist	*buffers;

tlist	ignstart;
tlist	ignstop;
tlist	ignline;
tlist	redir;

enum cltype { usr_strstr, use_pcre, use_re };

/* ignore empty lines more than this */
static int		ignlines = 1;

/* ignore block on/off */
static int		ignore = 0;

/* ignore control characters */
static int		ignctrl = 0;

// another panic routine
void	die(bool what, const char *fmt, ...)
{
	if	( what )	{
		char	buf[4096];
		va_list	ap;

		va_start(ap, fmt);
		vsnprintf(buf, 4096, fmt, ap);
		va_end(ap);
		perror(buf);
		exit(1);
		}
}

//														  
void	cleantext(const char *src, char *dst)
{
	const char	*p = src;
	char		*d = dst;

	while ( *p )	{
		if	( *p == '\b' )	{
			d --;
			p ++;
			}
		else	{
			if	( *p >= ' ' )
				*d ++ = *p ++;
			else
				p ++;
			}
		}
	*d = '\0';
}

//
void	rmprefix(char *buf, char ch)
{
	char	*p;

	p = strchr(buf, ch);
	if	( p )	{
		p ++;
		while ( *p == ' ' || *p == '\t' )	p ++;
		strcpy(buf, p);
		}
}

//
void	rmsuffix(char *buf, char ch)
{
	char	*p;

	p = strchr(buf, ch);
	if	( p )	
		*p = '\0';
}

/*
*	true if c is a white-space
*/
int		is_wspace(int c)
{
	return (c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\b');
}

/*
*	removes spaces and returns a new string
*/
char	*trimdup(const char *str)
{
	char	*buf;
	char	*p;

	buf = (char *) malloc(strlen(str)+1);
	strcpy(buf, str);

	if	( *str == '\0' )	
		return buf;
		
	p = (char *) str;
	while ( is_wspace(*p) )		p ++;
	strcpy(buf, p);

	if	( *p != '\0' )	{
		p = buf;
		while ( *p )	p ++;
		p --;
		while ( p > buf && is_wspace(*p) )	p --;
		p ++;
		*p = '\0';
		}
	return buf;			
}

/*
*/
tnode	*conf_line(int line, tlist *list, const char *text)
{
	if	( strncmp(text, "@re:", 4) == 0 )	{
		const char *error;
		int			errofs;

		tnode *c = (tnode *) list->add(text+4);
		c->type = use_pcre;
		c->re = pcre_compile(text+4, 0, &error, &errofs, NULL);
		die(c->re == NULL, "pcre_compile(), failed (line %d, offset %d)\n-> %s", line, error, errofs);
		return c;
		}
	return (tnode *) list->add(text);
}

/*
*/
void	read_config(const char *file)
{
	FILE	*fp;
	int		mode = 0;
	char	buf[1024], *p;
	int		line = 0;

	fp = fopen(file, "rt");
	if	( fp )	{
		while ( fgets(buf, 1024, fp) )	{
			if	( buf[strlen(buf)-1] == '\n' )	
				buf[strlen(buf)-1] = '\0';
			line ++;
			
			if	( strlen(buf) )	{
				if	( strstr(buf, "@remove_text_lines") )	
					mode = 1;
				else if	( strstr(buf, "@ignore_block_start") )	
					mode = 2;
				else if	( strstr(buf, "@ignore_block_stop") )	
					mode = 3;
				else if	( strstr(buf, "@max_empty_lines") )	
					mode = 4;
				else if	( strstr(buf, "@default_ignore_state") )
					mode = 5;
				else if	( strstr(buf, "@remove_control_chars") )
					mode = 6;
				else if	( strstr(buf, "@redirect") )	
					mode = 7;
				else	{
					switch ( mode )	{
					case	1:
						conf_line(line, &ignline, buf);
						break;
					case	2:
						conf_line(line, &ignstart, buf);
						break;
					case	3:
						conf_line(line, &ignstop, buf);
						break;
					case	4:
						ignlines = atoi(buf);
						break;
					case	5:
						ignore = atoi(buf);
						break;
					case	6:
						ignctrl = atoi(buf);
						break;
					case	7:
						p = strstr(buf, ":");
						if	( p )	{
							*p = '\0';
							tnode *t = conf_line(line, &redir, p+1);
							t->setData(buf);
							}
						else
							die(true, "syntax error");
						break;
					default:
						fprintf(stderr, "I don't know what to do [%s]\n", buf);
						}
					}
				}
			}

		fclose(fp);
		}
	else
		fprintf(stderr, "config not found [%s]\n", file);
}

/*
*/
tnode	*check_list(tlist *list, const char *text)
{
	tnode	*t;
	int		rc;
    int		erroffset;
	int		ovector[OVECCOUNT];

	t = (tnode *) list->head;
	while ( t )	{
		switch ( t->type )	{
		case use_pcre:
			rc = pcre_exec(t->re, NULL, text, strlen(text), 0, 0, ovector, OVECCOUNT);
			if	( rc >= 0 )
				return t;
			break;
		default:
			if	( strstr(text, t->line) )
				return t;
			}

		t = (tnode *) t->next;
		}
	return NULL;
}

/*
*/
int	main(int argc, char *argv[])
{
	char	buf[1024], *trimed;
	int		lnsp = 0, i, idx, c;
	int		no_store = 0, arg_mode = 0;
	char	conf[1024];
	char	file[1024];
	FILE	*fp, *fout;
	tnode	*t;

	// init
	strcpy(conf, "cutof.conf");
	fp = stdin;
	fout = stdout;

	// read args
	for ( i = 1; i < argc; i ++ )	{
		if	( argv[i][0] == '-' )	{
			if	( strcmp(argv[i], "-f") == 0 )
				arg_mode = 1;
			else if	( strcmp(argv[i], "-rc") == 0 )
				ignctrl = 1;
			else if	( strcmp(argv[i], "-h") == 0 || strcmp(argv[i], "--help") == 0 )	{
				printf("usage: cutof [-f config-file] [-rc] [input-file]\n");
				printf("-rc = enable cut control characters\n");
				return 1;
				}
			else
				fprintf(stderr, "unknown argument [%s]\n", argv[i]);
			}
		else {
			if	( arg_mode == 1 )	{
				strcpy(conf, argv[i]);
				arg_mode = 0;
				}
			else	{
				strcpy(file, argv[i]);
				fp = fopen(file, "rt");
				if	( !fp )	{
					fprintf(stderr, "cannot open 'input-file' [%s]\n", file);
					return 1;
					}
				}
			}
		}

	read_config(conf);

	// start input
	while ( !feof(fp) )	{
		
		// read text-line
		idx = 0;
		while ( !feof(fp) )	{
			c = fgetc(fp);
			if	( c == 0 )	c = '\r';
			else if	( c == '\n' )
				break;
			if	( c != '\r' )	{
				if	( ignctrl )	{
					if	( c >= 32 )	{
						buf[idx] = c;
						idx ++;
						}
					}
				else	{
					buf[idx] = c;
					idx ++;
					}
				}
			}
		buf[idx] = '\0';
		trimed = trimdup(buf);

		////////////
		
		if	( ignore )	{	// inside ignored block
			if	( check_list(&ignstop, buf) )	{
				ignore = 0;
				lnsp = 0;
				}
			}
		else	{	// inside not-ignored block
			// check start-ignore block
			if	( check_list(&ignstart, buf) )	
				ignore = 1;

			//
			no_store = 0;

			// check ignore text-line
			if	( check_list(&ignline, buf) )	
				no_store = 1;

			// check empty lines
			if	( strlen(trimed) == 0 )	{
				lnsp ++;
				if	( lnsp > ignlines )
					no_store = 1;
				}
			else {
				if	( no_store == 0 )
					lnsp = 0;
				}

			// check for redirection
			if	( (t = check_list(&redir, buf)) != NULL )	{
				if	( fout != stdout )
					fclose(fout);
				fout = fopen(t->data, "wt");
				if	( !fout )	{
					fprintf(stderr, "cannot redir [%s]\n", t->data);
					fout = stdout;
					}
				}
			}

		// print
		if	( no_store == 0 && ignore == 0 )	
			fprintf(fout, "%s\n", buf);

		free(trimed);
		}

	return 0;
}