/* Copyright (C) 2020  C. McEnroe <june@causal.agency>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysexits.h>

#include "server.h"

const char *SearchQuery = SQL(
	SELECT
		events.event,
		events.time,
		contexts.network,
		contexts.name,
		events.type,
		names.nick,
		names.user,
		names.host,
		events.target,
		highlight(search, 6, :highlight, :highlight)
	FROM events
	JOIN contexts USING (context)
	JOIN names USING (name)
	JOIN search ON search.rowid = events.event
	WHERE coalesce(contexts.network = :network, true)
		AND coalesce(contexts.name = :context, true)
		AND contexts.query <= NOT :public
		AND search MATCH :query
	ORDER BY search.rowid DESC
	LIMIT :offset, :limit;
);

static char *offsetURL(
	const char *network, const char *context, const char *query, int64_t offset
) {
	char *url = khttp_urlpartx(
		NULL, NULL, Pages[Search],
		Keys[Query].name, KATTRX_STRING, query,
		Keys[Offset].name, KATTRX_INT, offset,
		(network ? Keys[Network].name : NULL), KATTRX_STRING, network,
		(context ? Keys[Context].name : NULL), KATTRX_STRING, context,
		NULL
	);
	if (!url) err(EX_OSERR, "khttp_urlpartx");
	return url;
}

enum kcgi_err searchPage(struct kreq *req) {
	if (!req->fieldmap[Query]) return httpFail(req, KHTTP_400);
	const char *query = req->fieldmap[Query]->parsed.s;
	const char *network = NULL;
	const char *context = NULL;
	int64_t offset = 0;
	if (req->fieldmap[Network]) network = req->fieldmap[Network]->parsed.s;
	if (req->fieldmap[Context]) context = req->fieldmap[Context]->parsed.s;
	if (req->fieldmap[Offset]) offset = req->fieldmap[Offset]->parsed.i;
	if (context && !network) return httpFail(req, KHTTP_400);

	enum kcgi_err error = 0
		|| httpHead(req, KHTTP_200, KMIME_TEXT_HTML)
		|| khttp_body(req);
	if (req->method == KMETHOD_HEAD) return error;

	struct khtmlreq html;
	error = error
		|| khtml_open(&html, req, 0)
		|| htmlHead(&html, req, query)
		|| htmlNav(&html, req)
		|| khtml_elem(&html, KELEM_TABLE);
	if (error) return error;

	if (offset && !req->fieldmap[Export]) {
		int64_t prev = offset - eventsLimit;
		char *href = offsetURL(network, context, query, (prev > 0 ? prev : 0));
		error = 0
			|| khtml_attr(&html, KELEM_TR, KATTR_CLASS, "page", KATTR__MAX)
			|| khtml_attr(&html, KELEM_TH, KATTR_COLSPAN, "5", KATTR__MAX)
			|| khtml_attr(&html, KELEM_A, KATTR_HREF, href, KATTR__MAX)
			|| khtml_puts(&html, "Later results")
			|| khtml_closeelem(&html, 3);
		free(href);
		if (error) return error;
	}

	sqlite3_reset(stmt.search);
	dbBindText(stmt.search, ":highlight", "\26");
	dbBindText(stmt.search, ":network", network);
	dbBindText(stmt.search, ":context", context);
	dbBindText(stmt.search, ":query", query);
	dbBindInt(stmt.search, ":public", contextsPublic);
	dbBindInt(stmt.search, ":limit", eventsLimit);
	dbBindInt(stmt.search, ":offset", offset);

	int rows;
	int result;
	for (rows = 0; SQLITE_ROW == (result = sqlite3_step(stmt.search)); ++rows) {
		int i = 0;
		struct Event event = {0};
		event.event = sqlite3_column_int64(stmt.search, i++);
		event.time = sqlite3_column_int64(stmt.search, i++);
		event.network = sqlite3_column_text(stmt.search, i++);
		event.context = sqlite3_column_text(stmt.search, i++);
		event.type = sqlite3_column_int(stmt.search, i++);
		event.nick = sqlite3_column_text(stmt.search, i++);
		event.user = sqlite3_column_text(stmt.search, i++);
		event.host = sqlite3_column_text(stmt.search, i++);
		event.target = sqlite3_column_text(stmt.search, i++);
		event.message = sqlite3_column_text(stmt.search, i++);
		error = htmlEvent(&html, req, &event);
		if (error) return error;
	}
	if (result != SQLITE_DONE) {
		return 0
			|| khtml_attr(&html, KELEM_TR, KATTR_CLASS, "error", KATTR__MAX)
			|| khtml_elem(&html, KELEM_TH)
			|| khtml_puts(&html, sqlite3_errmsg(db))
			|| htmlFooter(&html, req)
			|| khtml_close(&html);
	}

	if (rows == eventsLimit && !req->fieldmap[Export]) {
		char *href = offsetURL(network, context, query, offset + eventsLimit);
		error = 0
			|| khtml_attr(&html, KELEM_TR, KATTR_CLASS, "page", KATTR__MAX)
			|| khtml_attr(&html, KELEM_TH, KATTR_COLSPAN, "5", KATTR__MAX)
			|| khtml_attr(&html, KELEM_A, KATTR_HREF, href, KATTR__MAX)
			|| khtml_puts(&html, "Earlier results")
			|| khtml_closeelem(&html, 3);
		free(href);
		if (error) return error;
	}

	if (!rows) {
		error = 0
			|| khtml_elem(&html, KELEM_TR)
			|| khtml_elem(&html, KELEM_TH)
			|| khtml_puts(&html, "No matching messages");
		if (error) return error;
	}

	return htmlFooter(&html, req) || khtml_close(&html);
}