1 /*
2  * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "compat.h"
18 
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 
23 #include "minibuffer.h"
24 #include "session.h"
25 #include "ui.h"
26 #include "utf8.h"
27 #include "utils.h"
28 
29 #define nitems(x) (sizeof(x)/sizeof(x[0]))
30 
31 static void		*minibuffer_metadata(void);
32 static const char	*minibuffer_compl_text(void);
33 static void		 minibuffer_hist_save_entry(void);
34 static void		 yornp_self_insert(void);
35 static void		 yornp_abort(void);
36 static void		 read_self_insert(void);
37 static void		 read_abort(void);
38 static void		 read_select(void);
39 static void		 handle_clear_echoarea(int, short, void *);
40 
41 static struct event	clechoev;
42 static struct timeval	clechoev_timer = { 5, 0 };
43 
44 static void (*yornp_cb)(int, struct tab *);
45 static struct tab *yornp_data;
46 
47 static void (*read_cb)(const char*, struct tab *);
48 static struct tab *read_data;
49 
50 /* XXX: don't forget to init these in minibuffer_init */
51 struct histhead eecmd_history,
52 	ir_history,
53 	lu_history,
54 	read_history;
55 
56 struct ministate ministate;
57 
58 struct buffer minibufferwin;
59 
60 int in_minibuffer;
61 
62 static inline int
63 matches(char **words, size_t len, struct line *l)
64 {
65 	size_t	i;
66 	int	lm, am;
67 
68 	for (i = 0; i < len; ++i) {
69 		lm = am = 0;
70 
71 		if (strcasestr(l->line, words[i]) != NULL)
72 			lm = 1;
73 		if (l->alt != NULL &&
74 		    strcasestr(l->alt, words[i]) != NULL)
75 			am = 1;
76 
77 		if (!lm && !am)
78 			return 0;
79 	}
80 
81 	return 1;
82 }
83 
84 /*
85  * Recompute the visible completions.  If add is 1, don't consider the
86  * ones already hidden.
87  */
88 void
89 recompute_completions(int add)
90 {
91 	static char	 buf[GEMINI_URL_LEN];
92 	const char	*text;
93 	char		*input, **ap, *words[10];
94 	size_t		 len = 0;
95 	struct line	*l;
96 	struct vline	*vl;
97 	struct buffer	*b;
98 
99 	if (in_minibuffer != MB_COMPREAD)
100 		return;
101 
102 	if (ministate.hist_cur != NULL)
103 		text = ministate.hist_cur->h;
104 	else
105 		text = ministate.buf;
106 
107 	strlcpy(buf, text, sizeof(buf));
108 	input = buf;
109 
110 	/* tokenize the input */
111 	for (ap = words; ap < words + nitems(words) &&
112 	    (*ap = strsep(&input, " ")) != NULL;) {
113 		if (**ap != '\0')
114 			ap++, len++;
115 	}
116 
117 	b = &ministate.compl.buffer;
118 	TAILQ_FOREACH(l, &b->page.head, lines) {
119 		l->type = LINE_COMPL;
120 		if (add && l->flags & L_HIDDEN)
121 			continue;
122 		if (matches(words, len, l)) {
123 			if (l->flags & L_HIDDEN)
124 				b->line_max++;
125 			l->flags &= ~L_HIDDEN;
126 		} else {
127 			if (!(l->flags & L_HIDDEN))
128 				b->line_max--;
129 			l->flags |= L_HIDDEN;
130 		}
131 	}
132 
133 	if (b->current_line == NULL)
134 		b->current_line = TAILQ_FIRST(&b->head);
135 	b->current_line = adjust_line(b->current_line, b);
136 	vl = b->current_line;
137 	if (ministate.compl.must_select && vl != NULL)
138 		vl->parent->type = LINE_COMPL_CURRENT;
139 }
140 
141 int
142 minibuffer_insert_current_candidate(void)
143 {
144 	struct vline *vl;
145 
146 	vl = ministate.compl.buffer.current_line;
147 	if (vl == NULL || vl->parent->flags & L_HIDDEN)
148 		return -1;
149 
150 	minibuffer_taint_hist();
151 	strlcpy(ministate.buf, vl->parent->line, sizeof(ministate.buf));
152 	ministate.buffer.cpoff = utf8_cplen(ministate.buf);
153 
154 	return 0;
155 }
156 
157 static void *
158 minibuffer_metadata(void)
159 {
160 	struct vline	*vl;
161 
162 	vl = ministate.compl.buffer.current_line;
163 
164 	if (vl == NULL || vl->parent->flags & L_HIDDEN)
165 		return NULL;
166 
167 	return vl->parent->data;
168 }
169 
170 static const char *
171 minibuffer_compl_text(void)
172 {
173 	struct vline	*vl;
174 
175 	if (ministate.hist_cur != NULL)
176 		return ministate.hist_cur->h;
177 
178 	vl = ministate.compl.buffer.current_line;
179 	if (vl == NULL || vl->parent->flags & L_HIDDEN ||
180 	    vl->parent->type == LINE_COMPL || vl->parent->line == NULL)
181 		return ministate.buf;
182 	return vl->parent->line;
183 }
184 
185 static void
186 minibuffer_hist_save_entry(void)
187 {
188 	struct hist	*hist;
189 	const char	*t;
190 
191 	if (ministate.history == NULL)
192 		return;
193 
194 	if ((hist = calloc(1, sizeof(*hist))) == NULL)
195 		abort();
196 
197 	t = minibuffer_compl_text();
198 	strlcpy(hist->h, t, sizeof(hist->h));
199 
200 	TAILQ_INSERT_TAIL(&ministate.history->head, hist, entries);
201 	ministate.history->len++;
202 }
203 
204 /*
205  * taint the minibuffer cache: if we're currently showing a history
206  * element, copy that to the current buf and reset the "history
207  * navigation" thing.
208  */
209 void
210 minibuffer_taint_hist(void)
211 {
212 	if (ministate.hist_cur == NULL)
213 		return;
214 
215 	strlcpy(ministate.buf, ministate.hist_cur->h, sizeof(ministate.buf));
216 	ministate.hist_cur = NULL;
217 	ministate.buffer.current_line->line = ministate.buf;
218 }
219 
220 void
221 minibuffer_self_insert(void)
222 {
223 	char	*c, tmp[5] = {0};
224 	size_t	len;
225 
226 	minibuffer_taint_hist();
227 
228 	if (thiskey.cp == 0)
229 		return;
230 
231 	len = utf8_encode(thiskey.cp, tmp);
232 	c = utf8_nth(ministate.buffer.current_line->line, ministate.buffer.cpoff);
233 	if (c + len > ministate.buf + sizeof(ministate.buf) - 1)
234 		return;
235 
236 	memmove(c + len, c, strlen(c)+1);
237 	memcpy(c, tmp, len);
238 	ministate.buffer.cpoff++;
239 
240 	recompute_completions(1);
241 }
242 
243 void
244 sensible_self_insert(void)
245 {
246 	if (thiskey.meta ||
247 	    (!unicode_isgraph(thiskey.key) && thiskey.key != ' ')) {
248 		global_key_unbound();
249 		return;
250 	}
251 
252 	minibuffer_self_insert();
253 }
254 
255 void
256 eecmd_select(void)
257 {
258 	struct cmd	*cmd;
259 	const char	*t;
260 
261 	t = minibuffer_compl_text();
262 	for (cmd = cmds; cmd->cmd != NULL; ++cmd) {
263 		if (!strcmp(cmd->cmd, t)) {
264 			minibuffer_hist_save_entry();
265 			exit_minibuffer();
266 			cmd->fn(current_buffer());
267 			return;
268 		}
269 	}
270 
271 	message("No match");
272 }
273 
274 void
275 ir_select_gemini(void)
276 {
277 	char		 buf[1025] = {0};
278 	struct phos_uri	 uri;
279 	struct tab	*tab = current_tab;
280 
281 	minibuffer_hist_save_entry();
282 
283 	/* a bit ugly but... */
284 	memcpy(&uri, &tab->uri, sizeof(tab->uri));
285 	phos_uri_set_query(&uri, minibuffer_compl_text());
286 	phos_serialize_uri(&uri, buf, sizeof(buf));
287 
288 	exit_minibuffer();
289 	load_url_in_tab(tab, buf, NULL, LU_MODE_NOCACHE);
290 }
291 
292 void
293 ir_select_reply(void)
294 {
295 	char		 buf[1025] = {0};
296 	struct phos_uri	 uri;
297 	struct tab	*tab = current_tab;
298 
299 	minibuffer_hist_save_entry();
300 
301 	/* a bit ugly but... */
302 	strlcpy(buf, tab->last_input_url, sizeof(buf));
303 	phos_parse_absolute_uri(buf, &uri);
304 	phos_uri_set_query(&uri, minibuffer_compl_text());
305 	phos_serialize_uri(&uri, buf, sizeof(buf));
306 
307 	exit_minibuffer();
308 	load_url_in_tab(tab, buf, NULL, LU_MODE_NOCACHE);
309 }
310 
311 void
312 ir_select_gopher(void)
313 {
314 	minibuffer_hist_save_entry();
315 	gopher_send_search_req(current_tab, minibuffer_compl_text());
316 	exit_minibuffer();
317 }
318 
319 void
320 lu_select(void)
321 {
322 	char url[GEMINI_URL_LEN+1];
323 
324 	minibuffer_hist_save_entry();
325 	humanify_url(minibuffer_compl_text(), url, sizeof(url));
326 	exit_minibuffer();
327 	load_url_in_tab(current_tab, url, NULL, LU_MODE_NOCACHE);
328 }
329 
330 void
331 bp_select(void)
332 {
333 	exit_minibuffer();
334 	if (*ministate.buf != '\0')
335 		add_to_bookmarks(ministate.buf);
336 	else
337 		message("Abort.");
338 }
339 
340 void
341 ts_select(void)
342 {
343 	struct tab	*tab;
344 
345 	if ((tab = minibuffer_metadata()) == NULL) {
346 		message("No tab selected");
347 		return;
348 	}
349 
350 	exit_minibuffer();
351 	switch_to_tab(tab);
352 }
353 
354 void
355 ls_select(void)
356 {
357 	struct line	*l;
358 
359 	if ((l = minibuffer_metadata()) == NULL) {
360 		message("No link selected");
361 		return;
362 	}
363 
364 	exit_minibuffer();
365 	load_url_in_tab(current_tab, l->alt, NULL, LU_MODE_NOCACHE);
366 }
367 
368 static inline void
369 jump_to_line(struct line *l)
370 {
371 	struct vline	*vl;
372 	struct buffer	*buffer;
373 
374 	buffer = current_buffer();
375 
376 	TAILQ_FOREACH(vl, &buffer->head, vlines) {
377 		if (vl->parent == l)
378 			break;
379 	}
380 
381 	if (vl == NULL)
382 		message("Ops, %s error!  Please report to %s",
383 		    __func__, PACKAGE_BUGREPORT);
384 	else {
385 		buffer->top_line = vl;
386 		buffer->current_line = vl;
387 	}
388 }
389 
390 void
391 swiper_select(void)
392 {
393 	struct line	*l;
394 
395 	if ((l = minibuffer_metadata()) == NULL) {
396 		message("No line selected");
397 		return;
398 	}
399 
400 	exit_minibuffer();
401 	jump_to_line(l);
402 }
403 
404 void
405 toc_select(void)
406 {
407 	struct line	*l;
408 
409 	if ((l = minibuffer_metadata()) == NULL) {
410 		message("No line selected");
411 		return;
412 	}
413 
414 	exit_minibuffer();
415 	jump_to_line(l);
416 }
417 
418 static void
419 yornp_self_insert(void)
420 {
421 	if (thiskey.key != 'y' && thiskey.key != 'n') {
422 		message("Please answer y or n");
423 		return;
424 	}
425 
426 	exit_minibuffer();
427 	yornp_cb(thiskey.key == 'y', yornp_data);
428 }
429 
430 static void
431 yornp_abort(void)
432 {
433 	exit_minibuffer();
434 	yornp_cb(0, yornp_data);
435 }
436 
437 static void
438 read_self_insert(void)
439 {
440 	if (thiskey.meta || !unicode_isgraph(thiskey.cp)) {
441 		global_key_unbound();
442 		return;
443 	}
444 
445 	minibuffer_self_insert();
446 }
447 
448 static void
449 read_abort(void)
450 {
451 	exit_minibuffer();
452 	read_cb(NULL, read_data);
453 }
454 
455 static void
456 read_select(void)
457 {
458 	exit_minibuffer();
459 	minibuffer_hist_save_entry();
460 	read_cb(ministate.buf, read_data);
461 }
462 
463 /*
464  * TODO: we should collect this asynchronously...
465  */
466 static inline void
467 populate_compl_buffer(complfn *fn, void *data)
468 {
469 	const char	*s, *descr;
470 	struct line	*l;
471 	struct buffer	*b;
472 	struct parser	*p;
473 	void		*linedata;
474 
475 	b = &ministate.compl.buffer;
476 	p = &b->page;
477 
478 	linedata = NULL;
479 	descr = NULL;
480 	while ((s = fn(&data, &linedata, &descr)) != NULL) {
481 		if ((l = calloc(1, sizeof(*l))) == NULL)
482 			abort();
483 
484 		l->type = LINE_COMPL;
485 		l->data = linedata;
486 		l->alt = (char*)descr;
487 		if ((l->line = strdup(s)) == NULL)
488 			abort();
489 
490 		TAILQ_INSERT_TAIL(&p->head, l, lines);
491 
492 		linedata = NULL;
493 		descr = NULL;
494 	}
495 
496 	if ((l = TAILQ_FIRST(&p->head)) != NULL &&
497 	    ministate.compl.must_select)
498 		l->type = LINE_COMPL_CURRENT;
499 }
500 
501 void
502 enter_minibuffer(void (*self_insert_fn)(void), void (*donefn)(void),
503     void (*abortfn)(void), struct histhead *hist,
504     complfn *complfn, void *compldata, int must_select)
505 {
506 	in_minibuffer = complfn == NULL ? MB_READ : MB_COMPREAD;
507 	if (in_minibuffer == MB_COMPREAD) {
508 		ui_schedule_redraw();
509 
510 		ministate.compl.fn = complfn;
511 		ministate.compl.data = compldata;
512 		ministate.compl.must_select = must_select;
513 		populate_compl_buffer(complfn, compldata);
514 	}
515 
516 	base_map = &minibuffer_map;
517 	current_map = &minibuffer_map;
518 
519 	base_map->unhandled_input = self_insert_fn;
520 
521 	ministate.donefn = donefn;
522 	ministate.abortfn = abortfn;
523 	memset(ministate.buf, 0, sizeof(ministate.buf));
524 	ministate.buffer.current_line = &ministate.vline;
525 	ministate.buffer.current_line->line = ministate.buf;
526 	ministate.buffer.cpoff = 0;
527 	strlcpy(ministate.buf, "", sizeof(ministate.prompt));
528 
529 	ministate.history = hist;
530 	ministate.hist_cur = NULL;
531 	ministate.hist_off = 0;
532 }
533 
534 void
535 exit_minibuffer(void)
536 {
537 	if (in_minibuffer == MB_COMPREAD) {
538 		erase_buffer(&ministate.compl.buffer);
539 		ui_schedule_redraw();
540 	}
541 
542 	in_minibuffer = 0;
543 	base_map = &global_map;
544 	current_map = &global_map;
545 }
546 
547 void
548 yornp(const char *prompt, void (*fn)(int, struct tab*),
549     struct tab *data)
550 {
551 	size_t len;
552 
553 	if (in_minibuffer) {
554 		fn(0, data);
555 		return;
556 	}
557 
558 	yornp_cb = fn;
559 	yornp_data = data;
560 	enter_minibuffer(yornp_self_insert, yornp_self_insert,
561 	    yornp_abort, NULL, NULL, NULL, 0);
562 
563 	len = sizeof(ministate.prompt);
564 	strlcpy(ministate.prompt, prompt, len);
565 	strlcat(ministate.prompt, " (y or n) ", len);
566 }
567 
568 void
569 minibuffer_read(const char *prompt, void (*fn)(const char *, struct tab *),
570     struct tab *data)
571 {
572 	size_t len;
573 
574 	if (in_minibuffer)
575 		return;
576 
577 	read_cb = fn;
578 	read_data = data;
579 	enter_minibuffer(read_self_insert, read_select, read_abort,
580 	    &read_history, NULL, NULL, 0);
581 
582 	len = sizeof(ministate.prompt);
583 	strlcpy(ministate.prompt, prompt, len);
584 	strlcat(ministate.prompt, ": ", len);
585 }
586 
587 static void
588 handle_clear_echoarea(int fd, short ev, void *d)
589 {
590 	free(ministate.curmesg);
591 	ministate.curmesg = NULL;
592 
593 	ui_after_message_hook();
594 }
595 
596 void
597 vmessage(const char *fmt, va_list ap)
598 {
599 	if (evtimer_pending(&clechoev, NULL))
600 		evtimer_del(&clechoev);
601 
602 	free(ministate.curmesg);
603 	ministate.curmesg = NULL;
604 
605 	if (fmt != NULL) {
606 		evtimer_set(&clechoev, handle_clear_echoarea, NULL);
607 		evtimer_add(&clechoev, &clechoev_timer);
608 
609 		/* TODO: what to do if the allocation fails here? */
610 		if (vasprintf(&ministate.curmesg, fmt, ap) == -1)
611 			ministate.curmesg = NULL;
612 	}
613 
614 	ui_after_message_hook();
615 }
616 
617 void
618 message(const char *fmt, ...)
619 {
620 	va_list ap;
621 
622 	va_start(ap, fmt);
623 	vmessage(fmt, ap);
624 	va_end(ap);
625 }
626 
627 void
628 minibuffer_init(void)
629 {
630 	TAILQ_INIT(&eecmd_history.head);
631 	TAILQ_INIT(&ir_history.head);
632 	TAILQ_INIT(&lu_history.head);
633 	TAILQ_INIT(&read_history.head);
634 
635 	TAILQ_INIT(&ministate.compl.buffer.head);
636 	TAILQ_INIT(&ministate.compl.buffer.page.head);
637 
638 	ministate.line.type = LINE_TEXT;
639 	ministate.vline.parent = &ministate.line;
640 	ministate.buffer.page.name = "*minibuffer*";
641 	ministate.buffer.current_line = &ministate.vline;
642 
643 	evtimer_set(&clechoev, handle_clear_echoarea, NULL);
644 }