/*
 * Entry point, initialization, miscellaneous routines.
 */

#include "less.h"
#include "position.h"
#include <setjmp.h>

public int	ispipe;
public jmp_buf	main_loop;
public char *	first_cmd;
public char *	every_first_cmd;
public int	new_file;
public int	is_tty;
public char 	current_file[FILENAME];
public char 	previous_file[FILENAME];
public POSITION	prev_pos;
public int	any_display;
public int	ac;
public char **	av;
public int 	curr_ac;
#if LOGFILE
public int	logfile = -1;
public int	force_logfile = 0;
public char *	namelogfile = NULL;
#endif
#if EDITOR
public char *	editor;
#endif

extern int file;
extern int nbufs;
extern int sigs;
extern int quit_at_eof;
extern int p_nbufs, f_nbufs;
extern int back_scroll;
extern int top_scroll;
extern int sc_height;
extern int errmsgs;

#ifdef AMIGA
/********** amiga **************/
#include <ctype.h>
long CurrentDir();
int called_from_WB = 0;

char prog_name[32];

/* max items and chars that *.c can expand to */
#define MAXTEMPLATES 100
#define MAXARGVCHARS 1000
public char	local_buffer[MAXARGVCHARS];
public char	*local_av[MAXTEMPLATES];
#endif

/*
 * Edit a new file.
 * Filename "-" means standard input.
 * No filename means the "current" file, from the command line.
 */
	public void
edit(filename)
	register char *filename;
{
	register int f;
	register char *m;
	POSITION initial_pos;
	char message[100];
	char tempfile[FILENAME];
	static int didpipe;

	initial_pos = NULL_POSITION;
	if (filename == NULL || *filename == '\0')
	{
		if (curr_ac >= ac)
		{
			error("No current file");
			return;
		}
		filename = av[curr_ac];
	}
	if (strcmp(filename, "#") == 0)
	{
		if (*previous_file == '\0')
		{
			error("no previous file");
			return;
		}
		strtcpy(tempfile, previous_file, sizeof(tempfile));
		filename = tempfile;
		initial_pos = prev_pos;
	}
	if (strcmp(filename, "-") == 0)
	{
		/* 
		 * Use standard input.
		 */
		if (didpipe)
		{
			error("Can view standard input only once");
			return;
		}
		f = 0;
	} else if ((m = bad_file(filename, message, sizeof(message))) != NULL)
	{
		error(m);
		return;
	} else if ((f = open(filename, 0)) < 0)
	{
		error(errno_message(filename, message, sizeof(message)));
		return;
	}

	if (isatty(f))
	{
		/*
		 * Not really necessary to call this an error,
		 * but if the control terminal (for commands)
		 * and the input file (for data) are the same,
		 * we get weird results at best.
		 */
		error("Can't take input from a terminal");
		if (f > 0)
			close(f);
		return;
	}

#if LOGFILE
	/*
	 * If he asked for a log file and we have opened standard input,
	 * create the log file.  
	 * We take care not to blindly overwrite an existing file.
	 */
	end_logfile();
	if (f == 0 && namelogfile != NULL && is_tty)
	{
		int exists;
		int answer;

		/*
		 * {{ We could use access() here. }}
		 */
		exists = open(namelogfile, 0);
		close(exists);
		exists = (exists >= 0);

		if (exists && !force_logfile)
		{
			static char w[] = "WARNING: log file exists: ";
			strcpy(message, w);
			strtcpy(message+sizeof(w)-1, namelogfile,
				sizeof(message)-sizeof(w));
			error(message);
			answer = 'X';	/* Ask the user what to do */
		} else
			answer = 'O';	/* Create the log file */

	loop:
		switch (answer)
		{
		case 'O': case 'o':
			logfile = creat(namelogfile, 0644);
			break;
		case 'A': case 'a':
			logfile = open(namelogfile, 1);
			if (lseek(logfile, (offset_t)0, 2) < 0)
			{
				close(logfile);
				logfile = -1;
			}
			break;
		case 'D': case 'd':
			answer = 0;	/* Don't print an error message */
			break;
		case 'q':
			quit();
		default:
			putstr("\n  Overwrite, Append, or Don't log? ");
			answer = getchr();
			putstr("\n");
			flush();
			goto loop;
		}

		if (logfile < 0 && answer != 0)
		{
			sprintf(message, "Cannot write to \"%s\"", 
				namelogfile);
			error(message);
		}
	}
#endif

	/*
	 * We are now committed to using the new file.
	 * Close the current input file and set up to use the new one.
	 */
	if (file > 0)
		close(file);
	new_file = 1;
	strtcpy(previous_file, current_file, sizeof(previous_file));
	strtcpy(current_file, filename, sizeof(current_file));
	prev_pos = position(TOP);
#ifdef AMIGA
	ispipe = ((f == 0) && !called_from_WB);
#else
	ispipe = (f == 0);
#endif
	if (ispipe)
		didpipe = 1;
	file = f;
	ch_init( (ispipe) ? p_nbufs : f_nbufs );
	init_mark();

	if (every_first_cmd != NULL)
		first_cmd = every_first_cmd;

	if (is_tty)
	{
		int no_display = !any_display;
		any_display = 1;
		if (no_display && errmsgs > 0)
		{
			/*
			 * We displayed some messages on error output
			 * (file descriptor 2; see error() function).
			 * Before erasing the screen contents,
			 * display the file name and wait for a keystroke.
			 */
			error(filename);
		}
		/*
		 * Indicate there is nothing displayed yet.
		 */
		pos_clear();
		if (initial_pos != NULL_POSITION)
			jump_loc(initial_pos);
	}
}

/*
 * Edit the next file in the command line list.
 */
	public void
next_file(n)
	int n;
{
	if (curr_ac + n >= ac)
	{
		if (quit_at_eof)
			quit();
		error("No (N-th) next file");
	} else
		edit(av[curr_ac += n]);
}

/*
 * Edit the previous file in the command line list.
 */
	public void
prev_file(n)
	int n;
{
	if (curr_ac - n < 0)
		error("No (N-th) previous file");
	else
		edit(av[curr_ac -= n]);
}

/*
 * Copy a file directly to standard output.
 * Used if standard output is not a tty.
 */
	static void
cat_file()
{
	register int c;

	while ((c = ch_forw_get()) != EOF)
		putchr(c);
	flush();
}
#ifdef AMIGA
/**************** amiga *****************************/
/* Bob Leivian  4/28/87 fudge up things so it will work
   when called from Work Bench */

char argvbuf[80];
long old_dir;
long current_dir;

#include "workbench/startup.h"

/* ignore AZTECs wb stuff */
_wb_parse(ignore, ignore2)
char *ignore;
char *ignore2;
{
    return;
} 
#endif


#ifdef NO_GETENV
/* this requires the workbench disk --
  ignore all environment variables for now */
char * getenv(ignore)
{
	return NULL;
}
#endif

/*
 * Entry point.
 */
main(argc, argv)
	int argc;
	char *argv[];
{
	char *getenv();
	int i,j;
	
#ifdef AMIGA
/***************** amiga ********************/
	/* if we were called from the workbench we will have no args
	   but a pointer to WBstruct, get the filename from this structure */
	if(argc == 0) {
		struct WBStartup *WBmsg;
		struct WBArg *p;

		/* the argv is really the work bench structure */
		WBmsg = (struct WBStartup *) argv;
		p = WBmsg->sm_ArgList;

		/* fake up the args now */
		/* argv[0] = p->wa_Name; */
		argv[0] = "less";
		p++;  /* ignore first parm (name) */
		strcpy(argvbuf, p->wa_Name);
		argc = 2;
		argv[1] = argvbuf;
		argv[2] = NULL;

		/* we have to setup this icons current dir (& release it later) */
		called_from_WB++;
		current_dir = p->wa_Lock;
		old_dir = CurrentDir(current_dir);
	}

	/* save my name, in case someone renamed less to something else */
	strcpy(prog_name, argv[0]);

	/* are we called to do a print function */
	if (argc > 1 && 0 == strcmp(argv[1], "-p")) {

		extern int Enable_Abort;
		long atol(), Output();
		long his_lock, DupLock();

	    /* this was a print only request */
		argc--;
		argv++;
		Enable_Abort = 1;

#ifdef NO
		/* if called from a workbench, he also passed the lock */
		if (isdigit(*argv[1])) {

			called_from_WB++;
			his_lock = atol(argv[1]);
			argc--;
			argv++;

			current_dir = DupLock(his_lock);
			old_dir = CurrentDir(current_dir);
		}
#endif
		start_print(argc, argv);

		if (called_from_WB) {
			CurrentDir(old_dir);

#ifdef NO
			/* close the stdout that my father opened */
			his_lock = Output();
			Close(his_lock); 
#endif
		}
		exit(0);
	}
#endif

	/*
	 * Process command line arguments and LESS environment arguments.
	 * Command line arguments override environment arguments.
	 */
	init_option();
	scan_option(getenv("LESS"));
	argv++;
	while ( (--argc > 0) && 
		(argv[0][0] == '-' || argv[0][0] == '+') && 
		 argv[0][1] != '\0')
		scan_option(*argv++);

#if EDITOR
	editor = getenv("EDITOR");
	if (editor == NULL || *editor == '\0')
		editor = "ed";
#endif

	/*
	 * Set up list of files to be examined.
	 */
	ac = argc;
	av = argv;
	
#ifdef AMIGA
	/* CLI doesn't expand templates link U*ix so we do it 'by hand' */

	for (i=0, j=0; i<ac; i++) {
	   int temp = 0;
	   char *p;
	   char *scdir();

		if(index(av[i], '*') || index(av[i], '?')) {

			/* this is a template it needs to be expanded */
			while( (p = scdir(av[i])) && (j < MAXTEMPLATES)) {
				 strcpy(&local_buffer[temp], p);
				 local_av[j++] = &local_buffer[temp];
				 temp += (strlen(&local_buffer[temp]) +1);
				 if (temp > MAXARGVCHARS) break;
			}
	 	} else
	 		local_av[j++] = av[i];
	}
	av = local_av;
	local_av[j] = NULL;
	ac = j;
#endif

	curr_ac = 0;

	/*
	 * Set up terminal, etc.
	 */
#ifdef AMIGA
	is_tty = 1;
	ttopen();
#else
	is_tty = isatty(1);
	if (!is_tty)
	{
		/*
		 * Output is not a tty.
		 * Just copy the input file(s) to output.
		 */
		if (ac < 1)
		{
			edit("-");
			cat_file();
		} else
		{
			do
			{
				edit((char *)NULL);
				if (file >= 0)
					cat_file();
			} while (++curr_ac < ac);
		}
		exit(0);
	}
#endif

	raw_mode(1);
	get_term();
	open_getchr();
	init();

	if (setjmp(main_loop))
		quit();
	init_signals();

	/*
	 * Select the first file to examine.
	 */
	if (ac < 1)
		edit("-");	/* Standard input */
	else 
	{
		/*
		 * Try all the files named as command arguments.
		 * We are simply looking for one which can be
		 * opened without error.
		 */
		do
		{
			edit((char *)NULL);
		} while (file < 0 && ++curr_ac < ac);
	}

	if (file >= 0)
		commands();
	quit();
	/*NOTREACHED*/
}

/*
 * Copy a string, truncating to the specified length if necessary.
 * Unlike strncpy(), the resulting string is guaranteed to be null-terminated.
 */
strtcpy(to, from, len)
	char *to;
	char *from;
	int len;
{
	strncpy(to, from, len);
	to[len-1] = '\0';
}

/*
 * Exit the program.
 */
	public void
quit()
{
	/*
	 * Put cursor at bottom left corner, clear the line,
	 * reset the terminal modes, and exit.
	 */
#if LOGFILE
	end_logfile();
#endif
	lower_left();
	clear_eol();
	deinit();

	flush();
	raw_mode(0);
	
#ifdef AMIGA
	ttclose();

	if(called_from_WB)
		CurrentDir(old_dir);
#endif

	exit(0);
}