/* lib9p_util/static.c - Serve static files over 9P
 *
 * Copyright (C) 2024-2025  Luke T. Shumaker <lukeshu@lukeshu.com>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

#include <libmisc/assert.h>
#include <libmisc/macro.h>

#include <util9p/static.h>

LO_IMPLEMENTATION_C(lib9p_srv_file, struct util9p_static_dir, util9p_static_dir, static);
LO_IMPLEMENTATION_C(lib9p_srv_file, struct util9p_static_file, util9p_static_file, static);

/* dir ************************************************************************/

static void util9p_static_dir_free(struct util9p_static_dir *self) {
	assert(self);
}
static struct lib9p_qid util9p_static_dir_qid(struct util9p_static_dir *self) {
	assert(self);

	return (struct lib9p_qid){
		.type = LIB9P_QT_DIR,
		.vers = 1,
		.path = self->pathnum,
	};
}
static uint32_t util9p_static_dir_chio(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx, bool, bool, bool) {
	assert(self);
	assert(ctx);
	return 0;
}

static struct lib9p_stat util9p_static_dir_stat(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx) {
	assert(self);
	assert(ctx);

	return (struct lib9p_stat){
		.kern_type                = 0,
		.kern_dev                 = 0,
		.file_qid                 = util9p_static_dir_qid(self),
		.file_mode                = LIB9P_DM_DIR | (self->perm & 0555),
		.file_atime               = self->atime,
		.file_mtime               = self->mtime,
		.file_size                = 0,
		.file_name                = lib9p_str(self->name),
		.file_owner_uid           = lib9p_str(self->u_name),
		.file_owner_gid           = lib9p_str(self->g_name),
		.file_last_modified_uid   = lib9p_str(self->m_name),
		.file_extension           = lib9p_str(NULL),
		.file_owner_n_uid         = self->u_num,
		.file_owner_n_gid         = self->g_num,
		.file_last_modified_n_uid = self->m_num,
	};
}
static void util9p_static_dir_wstat(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx,
                                    struct lib9p_stat) {
	assert(self);
	assert(ctx);

	lib9p_error(&ctx->basectx, LINUX_EROFS, "read-only part of filesystem");
}
static void util9p_static_dir_remove(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx) {
	assert(self);
	assert(ctx);

	lib9p_error(&ctx->basectx, LINUX_EROFS, "read-only part of filesystem");
}

static lo_interface lib9p_srv_file util9p_static_dir_dopen(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx,
                                                           struct lib9p_s childname) {
	assert(self);
	assert(ctx);

	for (size_t i = 0; !LO_IS_NULL(self->members[i]); i++) {
		lo_interface lib9p_srv_file file = self->members[i];
		struct lib9p_stat stat = LO_CALL(file, stat, ctx);
		if (lib9p_ctx_has_error(&ctx->basectx))
			break;
		lib9p_stat_assert(stat);
		if (lib9p_str_eq(stat.file_name, childname))
			return file;
	}
	lib9p_error(&ctx->basectx,
	            LINUX_ENOENT, "no such file or directory");
	return LO_NULL(lib9p_srv_file);
}

static lo_interface lib9p_srv_file util9p_static_dir_dcreate(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx,
                                                             struct lib9p_s LM_UNUSED(childname),
                                                             lib9p_dm_t LM_UNUSED(perm), lib9p_o_t LM_UNUSED(flags)) {
	assert(self);
	assert(ctx);

	lib9p_error(&ctx->basectx, LINUX_EROFS, "read-only part of filesystem");
	return LO_NULL(lib9p_srv_file);
}

static size_t util9p_static_dir_dread(struct util9p_static_dir *self, struct lib9p_srv_ctx *ctx,
                                      uint8_t *buf,
                                      uint32_t byte_count,
                                      size_t _obj_offset) {
	assert(self);
	assert(ctx);

	uint32_t byte_offset = 0;
	size_t obj_offset = _obj_offset;
	while (!LO_IS_NULL(self->members[obj_offset])) {
		lo_interface lib9p_srv_file file = self->members[obj_offset];
		struct lib9p_stat stat = LO_CALL(file, stat, ctx);
		if (lib9p_ctx_has_error(&ctx->basectx))
			break;
		lib9p_stat_assert(stat);
		uint32_t nbytes = lib9p_stat_marshal(&ctx->basectx, byte_count-byte_offset, &stat,
		                                     &buf[byte_offset]);
		if (!nbytes) {
			if (obj_offset == _obj_offset)
				lib9p_error(&ctx->basectx,
				            LINUX_ERANGE, "stat object does not fit into negotiated max message size");
			break;
		}
		byte_offset += nbytes;
		obj_offset++;
	}
	return obj_offset - _obj_offset;
}

LIB9P_SRV_NOTFILE(struct util9p_static_dir, util9p_static_dir)

/* file ***********************************************************************/

static void util9p_static_file_free(struct util9p_static_file *self) {
	assert(self);
}
static struct lib9p_qid util9p_static_file_qid(struct util9p_static_file *self) {
	assert(self);

	return (struct lib9p_qid){
		.type = LIB9P_QT_FILE,
		.vers = 1,
		.path = self->pathnum,
	};
}
static uint32_t util9p_static_file_chio(struct util9p_static_file *self, struct lib9p_srv_ctx *ctx, bool, bool, bool) {
	assert(self);
	assert(ctx);
	return 0;
}

static inline size_t util9p_static_file_size(struct util9p_static_file *file) {
	assert(file);

#if __unix__
	assert(file->data_start);
#endif
	if (!file->data_end)
		return file->data_size;
	return (size_t)((uintptr_t)file->data_end - (uintptr_t)file->data_start);
}


static struct lib9p_stat util9p_static_file_stat(struct util9p_static_file *self, struct lib9p_srv_ctx *ctx) {
	assert(self);
	assert(ctx);

	return (struct lib9p_stat){
		.kern_type                = 0,
		.kern_dev                 = 0,
		.file_qid                 = util9p_static_file_qid(self),
		.file_mode                = self->perm & 0444,
		.file_atime               = self->atime,
		.file_mtime               = self->mtime,
		.file_size                = (uint64_t)util9p_static_file_size(self),
		.file_name                = lib9p_str(self->name),
		.file_owner_uid           = lib9p_str(self->u_name),
		.file_owner_gid           = lib9p_str(self->g_name),
		.file_last_modified_uid   = lib9p_str(self->m_name),
		.file_extension           = lib9p_str(NULL),
		.file_owner_n_uid         = self->u_num,
		.file_owner_n_gid         = self->g_num,
		.file_last_modified_n_uid = self->m_num,
	};
}
static void util9p_static_file_wstat(struct util9p_static_file *self, struct lib9p_srv_ctx *ctx,
                                    struct lib9p_stat) {
	assert(self);
	assert(ctx);

	lib9p_error(&ctx->basectx, LINUX_EROFS, "read-only part of filesystem");
}
static void util9p_static_file_remove(struct util9p_static_file *self, struct lib9p_srv_ctx *ctx) {
	assert(self);
	assert(ctx);

	lib9p_error(&ctx->basectx, LINUX_EROFS, "read-only part of filesystem");
}

LIB9P_SRV_NOTDIR(struct util9p_static_file, util9p_static_file)

static uint32_t util9p_static_file_pread(struct util9p_static_file *self, struct lib9p_srv_ctx *ctx,
                                         void *buf,
                                         uint32_t byte_count,
                                         uint64_t byte_offset) {
	assert(self);
	assert(ctx);

	size_t data_size = util9p_static_file_size(self);

	if (byte_offset > (uint64_t)data_size) {
		lib9p_error(&ctx->basectx,
		            LINUX_EINVAL, "offset is past end-of-file length");
		return 0;
	}

	size_t beg_off = (size_t)byte_offset;
	size_t end_off = beg_off + (size_t)byte_count;
	if (end_off > data_size)
		end_off = data_size;
	memcpy(buf, &self->data_start[beg_off], end_off-beg_off);
	return (uint32_t)(end_off-beg_off);
}

static uint32_t util9p_static_file_pwrite(struct util9p_static_file *self, struct lib9p_srv_ctx *ctx,
                                          void *LM_UNUSED(buf),
                                          uint32_t LM_UNUSED(byte_count),
                                          uint64_t LM_UNUSED(byte_offset)) {
	assert(self);
	assert(ctx);

	lib9p_error(&ctx->basectx, LINUX_EROFS, "read-only part of filesystem");
	return 0;
}