/*
 * Copyright 2023 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1-or-later
 */

#include "config.h"

#include "fu-byte-array.h"
#include "fu-common.h"
#include "fu-csv-entry.h"
#include "fu-csv-firmware-private.h"
#include "fu-string.h"

/**
 * FuCsvFirmware:
 *
 * A comma seporated value file.
 *
 * See also: [class@FuFirmware]
 */

typedef struct {
	GPtrArray *column_ids;
	gboolean write_column_ids;
} FuCsvFirmwarePrivate;

G_DEFINE_TYPE_WITH_PRIVATE(FuCsvFirmware, fu_csv_firmware, FU_TYPE_FIRMWARE)
#define GET_PRIVATE(o) (fu_csv_firmware_get_instance_private(o))

/**
 * fu_csv_firmware_add_column_id:
 * @self: a #FuFirmware
 * @column_id: (not nullable): string, e.g. `component_generation`
 *
 * Adds a column ID.
 *
 * There are several optional magic column IDs that map to #FuFirmware properties:
 *
 * * `$id` sets the firmware ID
 * * `$idx` sets the firmware index
 * * `$version` sets the firmware version
 * * `$version_raw` sets the raw firmware version
 *
 * Since: 1.9.3
 **/
void
fu_csv_firmware_add_column_id(FuCsvFirmware *self, const gchar *column_id)
{
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_return_if_fail(FU_IS_CSV_FIRMWARE(self));
	g_return_if_fail(column_id != NULL);
	g_ptr_array_add(priv->column_ids, g_strdup(column_id));
}

/**
 * fu_csv_firmware_get_column_id:
 * @self: a #FuFirmware
 * @idx: column ID idx
 *
 * Gets the column ID for a specific index position.
 *
 * Returns: a string, or %NULL if not found
 *
 * Since: 1.9.3
 **/
const gchar *
fu_csv_firmware_get_column_id(FuCsvFirmware *self, guint idx)
{
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_return_val_if_fail(FU_IS_CSV_FIRMWARE(self), NULL);

	if (idx >= priv->column_ids->len)
		return NULL;
	return g_ptr_array_index(priv->column_ids, idx);
}

/**
 * fu_csv_firmware_get_idx_for_column_id:
 * @self: a #FuFirmware
 * @column_id: (not nullable): string, e.g. `component_generation`
 *
 * Gets the column index for a given column ID.
 *
 * Returns: position, or %G_MAXUINT if unset
 *
 * Since: 1.9.3
 **/
guint
fu_csv_firmware_get_idx_for_column_id(FuCsvFirmware *self, const gchar *column_id)
{
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_return_val_if_fail(FU_IS_CSV_FIRMWARE(self), G_MAXUINT);
	g_return_val_if_fail(column_id != NULL, G_MAXUINT);
	for (guint i = 0; i < priv->column_ids->len; i++) {
		const gchar *column_id_tmp = g_ptr_array_index(priv->column_ids, i);
		if (g_strcmp0(column_id_tmp, column_id) == 0)
			return i;
	}
	return G_MAXUINT;
}

/**
 * fu_csv_firmware_set_write_column_ids:
 * @self: a #FuFirmware
 * @write_column_ids: boolean
 *
 * Sets if we should write the column ID headers on export.
 *
 * Since: 2.0.0
 **/
void
fu_csv_firmware_set_write_column_ids(FuCsvFirmware *self, gboolean write_column_ids)
{
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_return_if_fail(FU_IS_CSV_FIRMWARE(self));
	priv->write_column_ids = write_column_ids;
}

/**
 * fu_csv_firmware_get_write_column_ids:
 * @self: a #FuFirmware
 *
 * Gets if we should write the column ID headers on export.
 *
 * Returns: boolean.
 *
 * Since: 2.0.0
 **/
gboolean
fu_csv_firmware_get_write_column_ids(FuCsvFirmware *self)
{
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_return_val_if_fail(FU_IS_CSV_FIRMWARE(self), FALSE);
	return priv->write_column_ids;
}

static gboolean
fu_csv_firmware_parse_token_cb(GString *token, guint token_idx, gpointer user_data, GError **error)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(user_data);
	fu_csv_firmware_add_column_id(self, token->str);
	return TRUE;
}

static gboolean
fu_csv_firmware_parse_line_cb(GString *token, guint token_idx, gpointer user_data, GError **error)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(user_data);
	g_autoptr(FuFirmware) entry = fu_csv_entry_new();
	g_autoptr(GBytes) fw = NULL;

	/* ignore blank lines */
	if (token->len == 0)
		return TRUE;

	/* title */
	if (g_str_has_prefix(token->str, "#")) {
		return fu_strsplit_full(token->str + 1,
					token->len - 1,
					",",
					fu_csv_firmware_parse_token_cb,
					self,
					error);
	}

	/* parse entry */
	fw = g_bytes_new(token->str, token->len);
	fu_firmware_set_idx(entry, token_idx);
	if (!fu_firmware_add_image(FU_FIRMWARE(self), entry, error))
		return FALSE;
	if (!fu_firmware_parse_bytes(entry, fw, 0x0, FU_FIRMWARE_PARSE_FLAG_NONE, error))
		return FALSE;
	return TRUE;
}

static gboolean
fu_csv_firmware_parse(FuFirmware *firmware,
		      GInputStream *stream,
		      FuFirmwareParseFlags flags,
		      GError **error)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(firmware);
	return fu_strsplit_stream(stream, 0x0, "\n", fu_csv_firmware_parse_line_cb, self, error);
}

static GByteArray *
fu_csv_firmware_write(FuFirmware *firmware, GError **error)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(firmware);
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_autoptr(GByteArray) buf = g_byte_array_new();
	g_autoptr(GPtrArray) imgs = fu_firmware_get_images(firmware);

	/* title section */
	if (priv->write_column_ids) {
		g_autoptr(GString) str = g_string_new("#");
		for (guint i = 0; i < priv->column_ids->len; i++) {
			const gchar *column_id = g_ptr_array_index(priv->column_ids, i);
			if (str->len > 1)
				g_string_append(str, ",");
			g_string_append(str, column_id);
		}
		g_string_append(str, "\n");
		g_byte_array_append(buf, (const guint8 *)str->str, str->len);
	}

	/* each entry */
	for (guint i = 0; i < imgs->len; i++) {
		FuFirmware *img = g_ptr_array_index(imgs, i);
		g_autoptr(GBytes) img_blob = fu_firmware_write(img, error);
		if (img_blob == NULL)
			return NULL;
		fu_byte_array_append_bytes(buf, img_blob);
	}

	/* success */
	return g_steal_pointer(&buf);
}

static void
fu_csv_firmware_export(FuFirmware *firmware, FuFirmwareExportFlags flags, XbBuilderNode *bn)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(firmware);
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	fu_xmlb_builder_insert_kb(bn, "write_column_ids", priv->write_column_ids);
}

static gboolean
fu_csv_firmware_build(FuFirmware *firmware, XbNode *n, GError **error)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(firmware);
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	const gchar *tmp;

	/* optional properties */
	tmp = xb_node_query_text(n, "write_column_ids", NULL);
	if (tmp != NULL) {
		if (!fu_strtobool(tmp, &priv->write_column_ids, error))
			return FALSE;
	}

	/* success */
	return TRUE;
}

static void
fu_csv_firmware_init(FuCsvFirmware *self)
{
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	priv->column_ids = g_ptr_array_new_with_free_func(g_free);
	priv->write_column_ids = TRUE;
	fu_firmware_add_flag(FU_FIRMWARE(self), FU_FIRMWARE_FLAG_NO_AUTO_DETECTION);
	fu_firmware_set_images_max(FU_FIRMWARE(self), 10000);
	fu_firmware_set_size_max(FU_FIRMWARE(self), 16 * FU_MB);
	fu_firmware_add_image_gtype(FU_FIRMWARE(self), FU_TYPE_CSV_ENTRY);
}

static void
fu_csv_firmware_finalize(GObject *object)
{
	FuCsvFirmware *self = FU_CSV_FIRMWARE(object);
	FuCsvFirmwarePrivate *priv = GET_PRIVATE(self);
	g_ptr_array_unref(priv->column_ids);
	G_OBJECT_CLASS(fu_csv_firmware_parent_class)->finalize(object);
}

static void
fu_csv_firmware_class_init(FuCsvFirmwareClass *klass)
{
	FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
	GObjectClass *object_class = G_OBJECT_CLASS(klass);
	object_class->finalize = fu_csv_firmware_finalize;
	firmware_class->parse = fu_csv_firmware_parse;
	firmware_class->write = fu_csv_firmware_write;
	firmware_class->export = fu_csv_firmware_export;
	firmware_class->build = fu_csv_firmware_build;
}

/**
 * fu_csv_firmware_new:
 *
 * Creates a new #FuFirmware
 *
 * Since: 1.9.3
 **/
FuFirmware *
fu_csv_firmware_new(void)
{
	return FU_FIRMWARE(g_object_new(FU_TYPE_CSV_FIRMWARE, NULL));
}
