#define _LARGEFILE64_SOURCE     /* required for GLIBC to enable stat64 and friends */
#include <sys/types.h>
#include <regex.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <signal.h>

#include "mt.h"
#include "error.h"
#include "utils.h"
#include "mem.h"
#include "term.h"
#include "my_pty.h"
#include "globals.h"


int start_tail(char *filename, char retry_open, char follow_filename, int initial_tail, int *pipefd)
{
	pid_t pid;

	/* start child process */
	if ((pid = fork()) == 0)
	{
		char *pars[9], *posix_version = NULL;
		int npars = 0;
		char nlines_buffer[32];

		setpgid(0,0);

		setup_for_childproc(pipefd[1], 0, "dumb");

		/* create command for take last n lines & follow and start tail */

		/* the command to start */
		pars[npars++] = tail;

		/* Linux' tail has the --retry option, but not all
		 * other UNIX'es have this, so I implemented it
		 * myself
		 */
		if (retry_open)
		{
			/* FIXME: *//* #if defined(linux) */
#if 0
			pars[npars++] = "--retry";
#else
			int rc;
			struct stat64 buf;

			for(;;)
			{
				rc = stat64(filename, &buf);
				if (rc == -1)
				{
					if (errno != ENOENT)
					{
						fprintf(stderr, "Error while looking for file %s: %d\n", filename, errno);
						exit(EXIT_FAILURE);
					}
				}
				else if (rc == 0)
					break;

				usleep(WAIT_FOR_FILE_DELAY * 1000);
			}
#endif
		}

		/* get the posix compliance level */
		posix_version = getenv("_POSIX2_VERSION");

		/* follow filename is only supported on *BSD and Linux */
#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(linux) || defined(__CYGWIN__) || defined(__APPLE__) || defined(__GNU__)
		if (follow_filename)
		{
#if defined(linux) || defined(__CYGWIN__) || defined(__GNU__)
			pars[npars++] = "--follow=name";
#elif defined(__OpenBSD__)
			pars[npars++] = "-f";
#else
			pars[npars++] = "-F";
#endif
			/* number of lines to tail initially */
			pars[npars++] = "-n";
			snprintf(nlines_buffer, sizeof(nlines_buffer), "%d", initial_tail);
			pars[npars++] = nlines_buffer;
		}
		else
#endif
		{
			/* check the posix compliance level */
			if (posix_version && atoi(posix_version) >= 200112)
			{
				pars[npars++] = "-f";
				pars[npars++] = "-n";
				snprintf(nlines_buffer, sizeof(nlines_buffer), "%d", initial_tail);
				pars[npars++] = nlines_buffer;
			}
			else
			{
				/* number of lines to tail initially and 'follow file' ('f') */
				snprintf(nlines_buffer, sizeof(nlines_buffer), "-%dlf", initial_tail);
				pars[npars++] = nlines_buffer;
			}
		}

		/* add the filename to monitor */
		pars[npars++] = filename;
		pars[npars] = NULL;

		/* run tail! */
		if (-1 == execvp(pars[0], pars)) error_exit("start_tail: execvp of tail failed\n");

		/* if execlp returns, an error occured */
		error_exit("start_tail: error while starting process!\n");
	}

	return pid;
}

void start_proc_signal_handler(int sig)
{
	if (sig != SIGTERM) error_exit("unexpected signal %d in start_proc_signalhandler\n", sig);

	stop_process(tail_proc);

	exit(1);
}

int start_proc(proginfo *cur, int initial_tail)
{
	cur -> n_runs++;

	if (cur -> is_command)
	{
		int fd_master, fd_slave;

		/* allocate pseudo-tty & fork*/
		cur -> pid = get_pty_and_fork(&fd_master, &fd_slave);
		if (-1 == cur -> pid) error_exit("start_proc: failed to create pseudo-tty & fork\n");

		/* child? */
		if (cur -> pid == 0)
		{
			setpgid(0,0);

			/* reset signal handler for SIGTERM */
			signal(SIGTERM, SIG_DFL);

			/* sleep if requested and only when 2nd or 3d (etc.) execution time */
			if (cur -> restart && cur -> first == 0)
				sleep(cur -> restart);

			/* connect slave-fd to stdin/out/err */
			setup_for_childproc(fd_slave, 1, term_t_to_string(cur -> term_emul));

			/* start process */
			if (-1 == execlp(shell, shell, "-c", cur -> filename, (void *)NULL)) error_exit("start_proc: execlp of %s failed\n", cur -> filename);

			/* if execlp returns, an error occured */
			error_exit("start_proc: error while starting process!\n");
		}

#if defined(sun) || defined(__sun) || defined(AIX) || defined(_HPUX_SOURCE) || defined(OSF1) || defined(scoos)
		/* these platforms only have the slave-fd available in the childprocess
		 *                  * so don't try to close it as the parent process doesn't have it
		 *
		 */
#else
		if (myclose(fd_slave) == -1) error_exit("start_proc: error closing slave-fd (pseudo tty, fd %d)\n", fd_slave);
#endif

		/* remember master-fd (we'll read from that one) */
		cur -> fd = fd_master;
		cur -> wfd = fd_master;

		/* next time, sleep */
		cur -> first = 0;
	}
	else
	{
		int pipefd[2];

		/* create a pipe, will be to child-process */
		if (-1 == pipe(pipefd)) error_exit("start_proc: error creating pipe\n");

		if (cur -> check_interval)
		{
			/* start the process that will check every 'interval' seconds
			 * if a matching file with a more recent mod-time is available
			 */
			cur -> pid = fork();
			if (cur -> pid == 0)
			{
				char *cur_file = NULL, *new_file;

				setpgid(0,0);

				signal(SIGTERM, start_proc_signal_handler);

				for(;;)
				{
					/* find (new) file */
					new_file = find_most_recent_file(cur -> filename, cur_file);

					/* if find_most_recent_file returned NOT null, a file was found
					 * which is more recent
					 */
					if (new_file != NULL)
					{
						/* if there was a previous file, see if it is different
						 * from the new filename. this should always be the case!
						 */
						if (cur_file && strcmp(new_file, cur_file) != 0)
						{
							LOG("killing process for %s\n", cur_file);
							stop_process(tail_proc);
						}

						/* remember new filename */
						myfree(cur_file);
						cur_file = new_file;

						LOG("new_file: %s\n", cur_file);

						/* and start a proc process */
						tail_proc = start_tail(cur_file, cur -> retry_open, cur -> follow_filename, initial_tail, pipefd);
						if (tail_proc == -1)
						{
							LOG("failed starting process for file %s: %d\n", cur_file, errno);
							break;
						}
					}
					else
					{
						LOG("no file found for pattern %s\n", cur -> filename);
					}

					sleep(cur -> check_interval);
				}

				LOG("stopped checking for file pattern %s\n", cur -> filename);

				exit(1);
			}
		}
		else
		{
			cur -> pid = start_tail(cur -> filename, cur -> retry_open, cur -> follow_filename, initial_tail, pipefd);
		}

		cur -> fd = pipefd[0];
		cur -> wfd = pipefd[1];
	}

	if (cur -> pid > -1)
		return 0;

	return -1;
}

int execute_program(char *execute, char bg)
{
	int status;
	pid_t child;

	if (bg)
	{
		/* to prevent meltdowns, only a limited number of
		 * processes can be executed
		 */
		if (n_children >= MAX_N_SPAWNED_PROCESSES)
			return 0;
	}
	else
		endwin();

	child = fork();
	if (child == 0)
	{
		setpgid(0,0);

		if (bg)
			setup_for_childproc(open_null(), 1, "dumb");

		/* start process */
		if (-1 == execlp(shell, shell, "-c", execute, (void *)NULL)) error_exit("execute_program: execlp of %s failed\n", execute);

		/* if execlp returns, an error occured */
		error_exit("execute_program: error while starting process!\n");
	}
	else if (child == -1)
	{
		error_exit("execute_program: failed to fork child process\n");
	}

	if (bg)
	{
		/* remember this childprocess: we'll see if it has
		 * exited in the main-loop
		 */
		children_list[n_children++] = child;
	}
	else
	{
		/* wait for the childprocess to exit */
		if (waitpid(child, &status, 0) == -1)
			error_exit("execute_program: failt waiting for process to exit!\n");

		/* restore (n)curses */
		mydoupdate();
	}

	return 0;
}

void init_children_reaper(void)
{
	/* init list of pids to watch for exit */
	memset(children_list, 0x00, sizeof(children_list));
}