/*
 * Copyright (c) 2023 Yonatan Schachter
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <zephyr/bindesc.h>
#include <zephyr/sys/util.h>
#include <zephyr/logging/log.h>
#include <zephyr/drivers/flash.h>

LOG_MODULE_REGISTER(bindesc_read, CONFIG_BINDESC_READ_LOG_LEVEL);

struct find_user_data {
	const void *result;
	size_t size;
	uint16_t tag;
};

/**
 * A callback used by the bindesc_find_* functions.
 */
static int find_callback(const struct bindesc_entry *entry, void *user_data)
{
	struct find_user_data *data = (struct find_user_data *)user_data;

	if (data->tag == entry->tag) {
		data->result = (const void *)&(entry->data);
		data->size = entry->len;
		return 1;
	}

	return 0;
}

/**
 * A callback used by the bindesc_get_size function.
 */
static int get_size_callback(const struct bindesc_entry *entry, void *user_data)
{
	size_t *result = (size_t *)user_data;

	*result += WB_UP(BINDESC_ENTRY_HEADER_SIZE + entry->len);

	return 0;
}

/**
 * This helper function is used to abstract the different methods of reading
 * data from the binary descriptors.
 * For RAM and memory mapped flash, the implementation is very simple, as both
 * are memory mapped and can simply return a pointer to the data.
 * Flash is more complex because it needs to read the data from flash, and do
 * error checking.
 */
static inline int get_entry(struct bindesc_handle *handle, const uint8_t *address,
			    const struct bindesc_entry **entry)
{
	int retval = 0;

	/*
	 * The flash backend requires reading data into a buffer and uses struct
	 * members (flash_device, buffer) that only exist when CONFIG_BINDESC_READ_FLASH
	 * is enabled. We must use preprocessor conditionals here, not IS_ENABLED()
	 * in an if statement, because the compiler still type-checks code in both
	 * branches even when the condition is known false at compile time.
	 */
#if IS_ENABLED(CONFIG_BINDESC_READ_FLASH)
	if (handle->type == BINDESC_HANDLE_TYPE_FLASH) {
		int flash_retval;

		flash_retval = flash_read(handle->flash_device, (size_t)address,
					  handle->buffer, BINDESC_ENTRY_HEADER_SIZE);
		if (flash_retval) {
			LOG_ERR("Flash read error: %d", flash_retval);
			return -EIO;
		}

		/* Make sure buffer is large enough for the data */
		if (((const struct bindesc_entry *)handle->buffer)->len + BINDESC_ENTRY_HEADER_SIZE
				> sizeof(handle->buffer)) {
			LOG_WRN("Descriptor too large to copy, skipping");
			retval = -ENOMEM;
		} else {
			flash_retval = flash_read(handle->flash_device,
					(size_t)address + BINDESC_ENTRY_HEADER_SIZE,
					handle->buffer + BINDESC_ENTRY_HEADER_SIZE,
					((const struct bindesc_entry *)handle->buffer)->len);
			if (flash_retval) {
				LOG_ERR("Flash read error: %d", flash_retval);
				return -EIO;
			}
		}
		*entry = (const struct bindesc_entry *)handle->buffer;
	} else
#endif /* CONFIG_BINDESC_READ_FLASH */
	{
		*entry = (const struct bindesc_entry *)address;
	}

	return retval;
}

#if IS_ENABLED(CONFIG_BINDESC_READ_MEMORY_MAPPED_FLASH)
int bindesc_open_memory_mapped_flash(struct bindesc_handle *handle, size_t offset)
{
	uint8_t *address = (uint8_t *)CONFIG_FLASH_BASE_ADDRESS + offset;

	if (*(uint64_t *)address != BINDESC_MAGIC) {
		LOG_ERR("Magic not found in given address");
		return -ENOENT;
	}

	handle->address = address;
	handle->type = BINDESC_HANDLE_TYPE_MEMORY_MAPPED_FLASH;
	handle->size_limit = UINT16_MAX;
	return 0;
}
#endif /* IS_ENABLED(CONFIG_BINDESC_READ_RAM) */

#if IS_ENABLED(CONFIG_BINDESC_READ_RAM)
int bindesc_open_ram(struct bindesc_handle *handle, const uint8_t *address, size_t max_size)
{
	if (!IS_ALIGNED(address, BINDESC_ALIGNMENT)) {
		LOG_ERR("Given address is not aligned");
		return -EINVAL;
	}

	if (*(uint64_t *)address != BINDESC_MAGIC) {
		LOG_ERR("Magic not found in given address");
		return -ENOENT;
	}

	handle->address = address;
	handle->type = BINDESC_HANDLE_TYPE_RAM;
	handle->size_limit = max_size;
	return 0;
}
#endif /* IS_ENABLED(CONFIG_BINDESC_READ_RAM) */

#if IS_ENABLED(CONFIG_BINDESC_READ_FLASH)
int bindesc_open_flash(struct bindesc_handle *handle, size_t offset,
		       const struct device *flash_device)
{
	int retval;

	retval = flash_read(flash_device, offset, handle->buffer, sizeof(BINDESC_MAGIC));
	if (retval) {
		LOG_ERR("Flash read error: %d", retval);
		return -EIO;
	}

	if (*(uint64_t *)handle->buffer != BINDESC_MAGIC) {
		LOG_ERR("Magic not found in given address");
		return -ENOENT;
	}

	handle->address = (uint8_t *)offset;
	handle->type = BINDESC_HANDLE_TYPE_FLASH;
	handle->flash_device = flash_device;
	handle->size_limit = UINT16_MAX;
	return 0;
}
#endif /* IS_ENABLED(CONFIG_BINDESC_READ_FLASH) */

int bindesc_foreach(struct bindesc_handle *handle, bindesc_callback_t callback, void *user_data)
{
	const struct bindesc_entry *entry;
	const uint8_t *address = handle->address;
	int retval;

	address += sizeof(BINDESC_MAGIC);

	do {
		retval = get_entry(handle, address, &entry);
		if (retval == -EIO) {
			return -EIO;
		}
		address += WB_UP(BINDESC_ENTRY_HEADER_SIZE + entry->len);
		if (retval) {
			continue;
		}

		retval = callback(entry, user_data);
		if (retval) {
			return retval;
		}
	} while ((entry->tag != BINDESC_TAG_DESCRIPTORS_END) &&
		((address - handle->address) <= handle->size_limit));

	return 0;
}

int bindesc_find_str(struct bindesc_handle *handle, uint16_t id, const char **result)
{
	struct find_user_data data = {
		.tag = BINDESC_TAG(STR, id),
	};

	if (!bindesc_foreach(handle, find_callback, &data)) {
		LOG_WRN("The requested descriptor was not found");
		return -ENOENT;
	}
	*result = (char *)data.result;
	return 0;
}

int bindesc_find_uint(struct bindesc_handle *handle, uint16_t id, const uint32_t **result)
{
	struct find_user_data data = {
		.tag = BINDESC_TAG(UINT, id),
	};

	if (!bindesc_foreach(handle, find_callback, &data)) {
		LOG_WRN("The requested descriptor was not found");
		return -ENOENT;
	}
	*result = (const uint32_t *)data.result;
	return 0;
}

int bindesc_find_bytes(struct bindesc_handle *handle, uint16_t id, const uint8_t **result,
		       size_t *result_size)
{
	struct find_user_data data = {
		.tag = BINDESC_TAG(BYTES, id),
	};

	if (!bindesc_foreach(handle, find_callback, &data)) {
		LOG_WRN("The requested descriptor was not found");
		return -ENOENT;
	}
	*result = (const uint8_t *)data.result;
	*result_size = data.size;
	return 0;
}

int bindesc_get_size(struct bindesc_handle *handle, size_t *result)
{
	*result = sizeof(BINDESC_MAGIC);

	return bindesc_foreach(handle, get_size_callback, result);
}