/* 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 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

#include <err.h>
#include <inttypes.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sysexits.h>

#include "archive.h"
#include "imap.h"

static uint32_t threadRoot(struct List thread) {
	if (!thread.len) errx(EX_PROTOCOL, "empty thread");
	while (thread.ptr[0].type == List) {
		thread = thread.ptr[0].list;
		if (!thread.len) errx(EX_PROTOCOL, "empty subthread");
	}
	return dataCheck(thread.ptr[0], Number).number;
}

static struct List threadFind(struct List threads, uint32_t root) {
	for (size_t i = 0; i < threads.len; ++i) {
		struct List thread = dataCheck(threads.ptr[i], List).list;
		if (threadRoot(thread) == root) return thread;
	}
	errx(EX_TEMPFAIL, "no thread with root UID %" PRIu32, root);
}

void concatFetch(FILE *imap, enum Atom tag, struct List threads) {
	fprintf(imap, "%s UID FETCH ", Atoms[tag]);
	for (size_t i = 0; i < threads.len; ++i) {
		uint32_t root = threadRoot(dataCheck(threads.ptr[i], List).list);
		fprintf(imap, "%s%" PRIu32, (i ? "," : ""), root);
	}
	fprintf(imap, " (UID ENVELOPE)\r\n");
}

static time_t uidNewest(struct List uids, const char *type) {
	char path[PATH_MAX];
	time_t newest = 0;
	for (size_t i = 0; i < uids.len; ++i) {
		pathUID(path, dataCheck(uids.ptr[i], Number).number, type);
		struct stat file;
		int error = stat(path, &file);
		if (error) err(EX_DATAERR, "%s", path);
		if (file.st_mtime > newest) newest = file.st_mtime;
	}
	return newest;
}

static int concatFile(FILE *dst, const char *path) {
	char buf[4096];
	FILE *src = fopen(path, "r");
	if (!src) err(EX_DATAERR, "%s", path);
	for (size_t len; (len = fread(buf, 1, sizeof(buf), src));) {
		size_t n = fwrite(buf, len, 1, dst);
		if (!n) return -1;
	}
	fclose(src);
	return 0;
}

static int concatHTML(FILE *file, struct List thread) {
	static char path[PATH_MAX];
	int error;
	for (size_t i = 0; i < thread.len; ++i) {
		error = htmlThreadOpen(file);
		if (error) return error;
		if (thread.ptr[i].type == List) {
			error = concatHTML(file, thread.ptr[i].list);
		} else {
			uint32_t uid = dataCheck(thread.ptr[i], Number).number;
			error = concatFile(file, pathUID(path, uid, "html"));
		}
		if (error) return error;
	}
	for (size_t i = 0; i < thread.len; ++i) {
		error = htmlThreadClose(file);
		if (error) return error;
	}
	return 0;
}

void concatData(struct List threads, struct List items) {
	uint32_t uid = 0;
	struct Envelope envelope = {0};
	for (size_t i = 0; i + 1 < items.len; i += 2) {
		enum Atom name = dataCheck(items.ptr[i], Atom).atom;
		struct Data data = items.ptr[i + 1];
		switch (name) {
			break; case AtomUID:
				uid = dataCheck(data, Number).number;
			break; case AtomEnvelope:
				parseEnvelope(&envelope, dataCheck(data, List).list);
			break; default:;
		}
	}
	if (!uid) errx(EX_PROTOCOL, "missing UID data item");
	if (!envelope.subject) errx(EX_PROTOCOL, "missing ENVELOPE data item");

	struct List thread = threadFind(threads, uid);
	struct List flat = {0};
	listFlatten(&flat, thread);

	int error;
	FILE *file;
	struct stat status;
	char dst[PATH_MAX];
	char src[PATH_MAX];

	error = stat(pathThread(dst, envelope.messageID, "mbox"), &status);
	if (error || status.st_mtime < uidNewest(flat, "mbox")) {
		file = fopen(dst, "w");
		if (!file) err(EX_CANTCREAT, "%s", dst);

		for (size_t i = 0; i < flat.len; ++i) {
			uint32_t uid = dataCheck(flat.ptr[i], Number).number;
			error = concatFile(file, pathUID(src, uid, "mbox"));
			if (error) err(EX_IOERR, "%s", dst);
		}

		error = fclose(file);
		if (error) err(EX_IOERR, "%s", dst);
	}

	error = stat(pathThread(dst, envelope.messageID, "atom"), &status);
	if (error || status.st_mtime < uidNewest(flat, "atom")) {
		FILE *file = fopen(dst, "w");
		if (!file) err(EX_CANTCREAT, "%s", dst);

		error = atomFeedHead(file, &envelope);
		if (error) err(EX_IOERR, "%s", dst);

		for (size_t i = 0; i < flat.len; ++i) {
			uint32_t uid = dataCheck(flat.ptr[i], Number).number;
			error = concatFile(file, pathUID(src, uid, "atom"));
			if (error) err(EX_IOERR, "%s", dst);
		}

		error = atomFeedTail(file) || fclose(file);
		if (error) err(EX_IOERR, "%s", dst);
	}

	error = stat(pathThread(dst, envelope.messageID, "html"), &status);
	if (error || status.st_mtime < uidNewest(flat, "html")) {
		FILE *file = fopen(dst, "w");
		if (!file) err(EX_CANTCREAT, "%s", dst);

		error = 0
			|| htmlThreadHead(file, &envelope) // TODO: Include -h file.
			|| htmlThreadHeader(file, &envelope)
			|| concatHTML(file, thread)
			|| htmlThreadTail(file)
			|| fclose(file);
		if (error) err(EX_IOERR, "%s", dst);
	}

	listFree(flat);
}