/*************************************************************************
 * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
 * provided to you without charge for use only on a licensed Unix        *
 * system.  You may copy JOVE provided that this notice is included with *
 * the copy.  You may not sell copies of this program or versions        *
 * modified for use on microcomputer systems, unless the copies are      *
 * included with a Unix system distribution and the source is provided.  *
 *************************************************************************/

#include "jove.h"
#include "termcap.h"
#include "ctype.h"
#include <signal.h>
#include <varargs.h>

#ifdef F_COMPLETION
#	include <sys/stat.h>
#endif

int	Asking = 0;
char	Minibuf[LBSIZE];
private Line	*CurAskPtr = 0;	/* points at some line in mini-buffer */
private Buffer	*AskBuffer = 0;	/* Askbuffer points to actual structure */

/* The way the mini-buffer works is this:  The first line of the mini-buffer
   is where the user does his stuff.  The rest of the buffer contains
   strings that the user often wants to use, for instance, file names, or
   common search strings, etc.  If he types C-N or C-P while in ask(), we
   bump the point up or down a line and extract the contents (we make sure
   is somewhere in the mini-buffer). */

static Buffer *
get_minibuf()
{
	if (AskBuffer)
		return AskBuffer;
	AskBuffer = do_select((Window *) 0, "Minibuf");
	AskBuffer->b_type = B_SCRATCH;
	return AskBuffer;
}

/* Add a string to the mini-buffer. */

minib_add(str, movedown)
char	*str;
{
	register Buffer	*saveb = curbuf;

	SetBuf(get_minibuf());
	LineInsert();
	ins_str(str, NO);
	if (movedown)
		CurAskPtr = curline;
	SetBuf(saveb);
}

static char *
real_ask(delim, d_proc, def, prompt)
char	*delim,
	*def,
	*prompt;
int	(*d_proc)();
{
	static int	InAsk = 0;
	jmp_buf	savejmp;
	int	c,
		prompt_len;
	Buffer	*saveb = curbuf;
	int	abort = 0,
		no_typed = 0;
	data_obj	*push_cmd = LastCmd;
	int	o_exp = exp,
		o_exp_p = exp_p;

	if (InAsk)
		complain((char *) 0);
	push_env(savejmp);
	InAsk++;
	SetBuf(get_minibuf());
	if (!inlist(AskBuffer->b_first, CurAskPtr))
		CurAskPtr = curline;
	prompt_len = strlen(prompt);
	ToFirst();	/* Beginning of buffer. */
	linebuf[0] = '\0';
	modify();
	makedirty(curline);

	if (setjmp(mainjmp))
		if (InJoverc) {		/* this is a kludge */
			abort++;
			goto cleanup;
		}

	for (;;) {
		exp = 1;
		exp_p = 0;
		last_cmd = this_cmd;
		init_strokes();
cont:		s_mess("%s%s", prompt, linebuf);
		Asking = curchar + prompt_len;
		c = getch();
		if ((c == EOF) || index(delim, c)) {
			if (d_proc == 0 || (*d_proc)(c) == 0)
				goto cleanup;
		} else switch (c) {
		case CTL(G):
			message("[Aborted]");
			abort++;
			goto cleanup;

		case CTL(N):
		case CTL(P):
			if (CurAskPtr != 0) {
				int	n = (c == CTL(P) ? -exp : exp);

				CurAskPtr = next_line(CurAskPtr, n);
				if (CurAskPtr == curbuf->b_first && CurAskPtr->l_next != 0)
					CurAskPtr = CurAskPtr->l_next;
				(void) ltobuf(CurAskPtr, linebuf);
				modify();
				makedirty(curline);
				Eol();
				this_cmd = 0;
			}
			break;

		case CTL(R):
			if (def)
				ins_str(def, NO);
			else
				rbell();
			break;

		default:
			dispatch(c);
			break;
		}
		if (curbuf != AskBuffer)
			SetBuf(AskBuffer);
		if (curline != curbuf->b_first) {
			CurAskPtr = curline;
			curline = curbuf->b_first;	/* with whatever is in linebuf */
		}
		if (this_cmd == ARG_CMD)
			goto cont;
	}
cleanup:
	pop_env(savejmp);

	LastCmd = push_cmd;
	exp_p = o_exp_p;
	exp = o_exp;
	no_typed = (linebuf[0] == '\0');
	strcpy(Minibuf, linebuf);
	SetBuf(saveb);
	InAsk = Asking = Interactive = 0;
	if (!abort) {
		if (!charp()) {
			Placur(ILI, 0);
			flusho();
		}
		if (no_typed)
			return 0;
	} else
		complain(mesgbuf);
	return Minibuf;
}

/* VARARGS2 */

char *
ask(def, fmt, va_alist)
char	*def,
	*fmt;
va_dcl
{
	char	prompt[128];
	char	*ans;
	va_list	ap;

	va_start(ap);
	format(prompt, sizeof prompt, fmt, ap);
	va_end(ap);
	ans = real_ask("\r\n", (int (*)()) 0, def, prompt);
	if (ans == 0) {		/* Typed nothing. */
		if (def == 0)
			complain("[No default]");
		return def;
	}
	return ans;
}

/* VARARGS2 */

char *
do_ask(delim, d_proc, def, fmt, va_alist)
char	*delim,
	*def,
	*fmt;
int	(*d_proc)();
va_dcl
{
	char	prompt[128];
	va_list	ap;

	va_start(ap);
	format(prompt, sizeof prompt, fmt, ap);
	va_end(ap);
	return real_ask(delim, d_proc, def, prompt);
}

#ifdef F_COMPLETION
static char	*fc_filebase;
char	BadExtensions[128] = ".o";

static
bad_extension(name, bads)
char	*name,
	*bads;
{
	char	*ip;
	int	namelen = strlen(name),
		ext_len,
		stop = 0;

	do {
		if (ip = index(bads, ' '))
			*ip = 0;
		else {
			ip = bads + strlen(bads);
			stop++;
		}
		if ((ext_len = ip - bads) == 0)
			continue;
		if ((ext_len < namelen) &&
		    (strcmp(&name[namelen - ext_len], bads) == 0))
			return YES;
	} while ((bads = ip + 1), !stop);
	return NO;
}

f_match(file)
char	*file;
{
	int	len = strlen(fc_filebase);

	return ((len == 0) ||
		(strncmp(file, fc_filebase, strlen(fc_filebase)) == 0));
}

static
isdir(name)
char	*name;
{
	struct stat	stbuf;
	char	filebuf[FILESIZE];

	PathParse(name, filebuf);
	return ((stat(filebuf, &stbuf) != -1) &&
		(stbuf.st_mode & S_IFDIR) == S_IFDIR);
}

static
fill_in(dir_vec, n)
register char	**dir_vec;
{
	int	minmatch = 0,
    		numfound = 0,
    		lastmatch = -1,
		i,
		the_same = TRUE, /* After filling in, are we the same
				    as when we were called? */
		is_ntdir;	/* Is Newly Typed Directory name */
	char	bads[128];

	for (i = 0; i < n; i++) {
		strcpy(bads, BadExtensions);
		/* bad_extension() is destructive */
		if (bad_extension(dir_vec[i], bads))
			continue;
		if (numfound)
			minmatch = min(minmatch,
				       numcomp(dir_vec[lastmatch], dir_vec[i]));
		else
			minmatch = strlen(dir_vec[i]);
		lastmatch = i;
		numfound++;
	}
	/* Ugh.  Beware--this is hard to get right in a reasonable
	   manner.  Please excuse this code--it's past my bedtime. */
	if (numfound == 0) {
		rbell();
		return;
	}
	Eol();
	if (minmatch > strlen(fc_filebase)) {
		the_same = FALSE;
		null_ncpy(fc_filebase, dir_vec[lastmatch], minmatch);
		Eol();
		makedirty(curline);
	}
	is_ntdir = ((numfound == 1) &&
		    (curchar > 0) &&
		    (linebuf[curchar - 1] != '/') &&
		    (isdir(linebuf)));
	if (the_same && !is_ntdir) {
		add_mess(n == 1 ? " [Unique]" : " [Ambiguous]");
		(void) SitFor(7);
	}
	if (is_ntdir)
		Insert('/');
}

extern int	alphacomp();

/* called from do_ask() when one of "\r\n ?" is typed.  Does the right
   thing, depending on which. */

static
f_complete(c)
{
	char	dir[FILESIZE],
		**dir_vec;
	int	nentries,
		i;

	if (c == CR || c == LF)
		return 0;	/* tells ask to return now */
	if ((fc_filebase = rindex(linebuf, '/')) != 0) {
		char	tmp[FILESIZE];

		null_ncpy(tmp, linebuf, (++fc_filebase - linebuf));
		if (tmp[0] == '\0')
			strcpy(tmp, "/");
		PathParse(tmp, dir);
	} else {		
		fc_filebase = linebuf;
		strcpy(dir, ".");
	}
	if ((nentries = scandir(dir, &dir_vec, f_match, alphacomp)) == -1) {
		add_mess(" [Unknown directory: %s]", dir);
		(void) SitFor(7);
		return 1;
	}
	if (nentries == 0) {
		add_mess(" [No match]");
		(void) SitFor(7);
	} else if (c == ' ')
		fill_in(dir_vec, nentries);
	else {
		/* we're a '?' */
		int	maxlen = 0,
			ncols,
			col,
			lines,
			linespercol;

		TOstart("Completion", FALSE);	/* false means newline only on request */
		Typeout("(! means file will not be chosen unless typed explicitly)");
		Typeout((char *) 0);
		Typeout("Possible completions (in %s):", dir);
		Typeout((char *) 0);

		for (i = 0; i < nentries; i++)
			maxlen = max(strlen(dir_vec[i]), maxlen);
		maxlen += 4;	/* pad each column with at least 4 spaces */
		ncols = (CO - 2) / maxlen;
		linespercol = 1 + (nentries / ncols);

		for (lines = 0; lines < linespercol; lines++) {
			for (col = 0; col < ncols; col++) {
				int	isbad,
					which;
				char	bads[128];

				which = (col * linespercol) + lines;
				if (which >= nentries)
					break;
				strcpy(bads, BadExtensions);
				isbad = bad_extension(dir_vec[which], bads);
				Typeout("%s%-*s", isbad ? "!" : NullStr,
					maxlen - isbad, dir_vec[which]);
			}
			Typeout((char *) 0);
		}
		TOstop();
	}
	freedir(&dir_vec, nentries);
	return 1;
}

#endif

char *
ask_file(def, buf)
char	*def,
	*buf;
{
	char	*ans,
		prompt[128],
		*pretty_name = pr_name(def);

	if (def != 0 && *def != '\0')
		sprintf(prompt, ": %f (default %s) ", pretty_name);
	else
		sprintf(prompt, ProcFmt);
#ifdef F_COMPLETION
  	ans = real_ask("\r\n ?", f_complete, pretty_name, prompt);
	if (ans == 0 && (ans = pretty_name) == 0)
		complain("[No default file name]");
#else
	ans = ask(pretty_name, prompt);
#endif
	PathParse(ans, buf);

	return buf;
}