/*
 * Looks better at 4 spaces/tab
 *
 */
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/wait.h>
#ifdef HAS_GLOB
#include <glob.h>
#endif
#include "errors.h"
#include "prefs.h"
#include "she.h"
#include "rdir.h"
#include "shield.h"

#ifdef MYGETOPT
char getopt( int	argc, char	*argv[], char *format );
#endif

/* globales */

char*		g_ProgName;
PrefsType	Prefs;
int			parate;
aProcesar	lista;
int			shields[32] = { SIGINT, SIGQUIT, SIGALRM, SIGTERM, -1};

extern int	optind;

extern void obito(int quien, int restos_mortales);

int main(int argc, char **argv);
void launch(int nproc);
int glob_err(const char *path, int err);

int main(int argc, char **argv)
{
	char		s[ BUFSIZE ];
	char		Prompt[ BUFSIZE ];
	char		*argt[MAXTERM];	/* user input */
	char		*arg;
	char		*home;
	int			i, j, k;
	static int	fdstdin;
	int		restos_mortales;
#ifdef HAS_GLOB
	glob_t		sglob;
#endif


	g_ProgName=argv[0];
	GetPrefs(&Prefs,argc,argv);
	home = getenv("HOME");

	shield();

	while(1)
	{
		*s = 0x00;

		fprintf( stderr, "%s:%s > ", g_ProgName,
							getcwd(Prompt, sizeof(Prompt)));
		gets( s );

		if(feof(stdin))
		{
			if(!Prefs.ignoreeof)
			{
				exit(0);
			}
			else
			{
				clearerr(stdin);
				puts("");
			}
		}


		if ( *s == 0x00 ) continue;

#ifdef HAS_GLOB
	if(!Prefs.glob)
	{
#endif
		argt [0] = strtok( s, " \t" );

		if ((argt[0] != NULL) && (NULL != strstr(QUIT, argt[0]) )) {
			write ( 2, LOGOUT, strlen(LOGOUT)) ;
			exit ( 0 );
		}
		for (i = 1; (argt[i] = strtok(NULL, " \t")) != NULL; i++)
			;

#ifdef HAS_GLOB
	}
	else
	{
		globfree(&sglob);

		for (	i = 0, arg = strtok( s, " \t" );
				arg != NULL;
				arg = strtok(NULL, " \t")
				)
		{
			switch(glob(arg,
			i==0 ? GLOB_NOCHECK : GLOB_NOCHECK | GLOB_APPEND,
			glob_err, &sglob))
			{
				case GLOB_NOSPACE:
					DoError(SYS_ERR, ABORT_ERR, "Glob: No space");
					break;
#ifdef GLOB_ABORTED
				case GLOB_ABORTED:
					DoError(PROG_ERR, ABORT_ERR, "Glob: Aborted");
					break;
#endif
				case GLOB_NOMATCH:
					DoError(PROG_ERR, ABORT_ERR, "Glob: No Match");
					break;
				default:
					i++;
					break;
			}
		}
		for(j=0; j<sglob.gl_pathc; j++)
				argt[j] = sglob.gl_pathv[j];
		argt[j] = NULL;
		sglob.gl_pathc = 0 ;

		if ((argt[0] != NULL) && (NULL != strstr(QUIT, argt[0]) ))
		{
			write ( 2, LOGOUT, strlen(LOGOUT)) ;
			exit ( 0 );
		}
	}
	/*glob*/
#endif

		if (*argt[0] != 0)
		{
			if ( 0 == strcmp( argt[i-1], M_BACK))
			{
				if ( i == 1 )
				{
					DoError(INPUT_ERR, INFO_ERR,
					"Error de usuario:%d", EMPTY );
						continue ;
				}
					
				parate = false;
				argt[i-1] = NULL;
			}
			else
				parate = true;
		} else
			continue;


		if (0 == strcmp(argt[0], "cd"))
		{
			if( 0!= chdir(argt[1] == NULL ? home : argt[1]))
				DoError(SYS_ERR, INFO_ERR, "cd");
			continue;
		}

		lcom_parsing(argt, &lista);

		if (lista.error != NO_ERR)
		{
			if (lista.error == SYS_ERROR)
			DoError(SYS_ERR, INFO_ERR, "Error de usuario:%d", lista.error);
			else
			DoError(INPUT_ERR, INFO_ERR, "Error de usuario:%d", lista.error);

			continue;
		}

		fdstdin = dup(0);		/* ver nota mas abajo */
		launch(0);
		close(0);	/* launch deja invalido stdout;
					podria recuperarse dentro de la funcion,
					pero no se ha hecho por razones de eficiencia */
		dup(fdstdin);
		close(fdstdin);

		/* Ahora se debe esperar si parate==TRUE, entre tanto
		morir'an hijos tanto de la 'ultima linea de comandos
		como de anteriores relaciones; se deber'a decir misa de
		difuntos s'olo por estos 'ultimos */

		if ( parate )
		{
			while (lista.elPID[0] != -1)
			{
				i = wait(&restos_mortales);

				if ( restos_mortales == -1 )
				{
					if (errno == EINTR) 
						fprintf(stderr, "\nMe rio yo de tus signals...\n");
					else 
						DoError(SYS_ERR,ABORT_ERR,"wait");
				}
				else
				{
					/* avanzar k hasta encontrar i o acabar */
					for ( k = 0; 
					    (lista.elPID[k] != i) && (lista.elPID[k] != -1); 
					    k++)
						; /* de for */

					/* si no esta en la lista, es viejo */
					if (lista.elPID[k] == -1 )
						obito(i, (restos_mortales));
					else
						/* se borra de la lista */
						for (; lista.elPID[k] != -1; k++)
							lista.elPID[k] = lista.elPID[k+1];

				}/* de else -wait no error- */
			}/* de while lista... */
		} /* fin de if parate */
	}/* guail uan */
} /*main*/


/*************************************************************/
/* indice del proceso que se ejecuta */
void launch(int nproc)
{
	int	pid;
	int	fd[2];

	pipe(fd);

	switch ( pid = fork () ) {
	case -1: /* error */
		DoError(SYS_ERR, ABORT_ERR,"Can't fork");
		break;

	case 0: /* hijo ( cria cuervos... ) */
		unshield();

		/* redireccion entrada ( mayor prioridad que pipe in ) */
		if ( lista.elProc[nproc].rdir.in != 0 )
		{
			rdir_in(lista.elProc[nproc].rdir.file_in);
		}

		/* rdir out ( menos prioridasd que pipe out )*/
		switch ( lista.elProc[nproc].rdir.out)
		{
			case 0:
				break;
			case 1:
				rdir_out(lista.elProc[nproc].rdir.file_out);
				break;
			case 2:
				rdir_app(lista.elProc[nproc].rdir.file_out);
				break;
			default:
				DoError(PROG_ERR, ABORT_ERR,"Panic!");
				break;
		}

		/* pipe out */
		close(fd[0]);
		if (lista.elProc[nproc+ 1].lproc[0] != NULL) {
			/* si hay mas procesos detras ... */
			close(1);
			dup(fd[1]);
		}
		close(fd[1]);

		close(3);	/* El omitir esta linea no afectaria al
					funcinamiento externo, pero el proceso hijo
					tendria un descriptor menos
					( notese que 3 es el save del stdin
							- ver main- ) */

		/* ejecutar de verdad */
	
		execvp (  lista.elProc[nproc].lproc[0],
		    lista.elProc[nproc].lproc );

		DoError(SYS_ERR, INFO_ERR, "can't execvp: %s",
					lista.elProc[nproc].lproc[0] );
		exit(255);

		break;

	default: /* papa */

		/* pipe in */
		close(fd[1]);

		/* update elPID[] */
		lista.elPID[nproc ] = pid;
		lista.elPID[nproc +1] = -1;

		if (lista.elProc[nproc+ 1].lproc[0] != NULL)
		{
		/* si hay mas procesos detras ... */
			close(0);
			dup(fd[0]);
			close(fd[0]);
			/* ejecucion */
			launch( nproc + 1 );
		}
		else
		{
			close(fd[0]);
		}

		break;
	} /*switch*/
}/* function */


int glob_err(const char *path, int err)
{
	errno = err;
	DoError(SYS_ERR, INFO_ERR, "Glob: %s",path);
	return 0;
}