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