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

#include "config.h"

#include "fu-bcm57xx-common.h"
#include "fu-bcm57xx-dict-image.h"

struct _FuBcm57xxDictImage {
	FuFirmware parent_instance;
	guint8 target;
	guint8 kind;
};

G_DEFINE_TYPE(FuBcm57xxDictImage, fu_bcm57xx_dict_image, FU_TYPE_FIRMWARE)

static void
fu_bcm57xx_dict_image_export(FuFirmware *firmware, FuFirmwareExportFlags flags, XbBuilderNode *bn)
{
	FuBcm57xxDictImage *self = FU_BCM57XX_DICT_IMAGE(firmware);
	if (self->target != 0xff)
		fu_xmlb_builder_insert_kx(bn, "target", self->target);
	if (self->kind != 0xff)
		fu_xmlb_builder_insert_kx(bn, "kind", self->kind);
}

static gboolean
fu_bcm57xx_dict_image_parse(FuFirmware *firmware,
			    GInputStream *stream,
			    FuFirmwareParseFlags flags,
			    GError **error)
{
	g_autoptr(GInputStream) stream_nocrc = NULL;
	gsize streamsz = 0;

	if (!fu_input_stream_size(stream, &streamsz, error))
		return FALSE;
	if (streamsz < sizeof(guint32)) {
		g_set_error_literal(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_INVALID_DATA,
				    "dict image is too small");
		return FALSE;
	}
	if ((flags & FU_FIRMWARE_PARSE_FLAG_IGNORE_CHECKSUM) == 0) {
		if (!fu_bcm57xx_verify_crc(stream, error))
			return FALSE;
	}
	stream_nocrc = fu_partial_input_stream_new(stream, 0x0, streamsz - sizeof(guint32), error);
	if (stream_nocrc == NULL)
		return FALSE;
	return fu_firmware_set_stream(firmware, stream_nocrc, error);
}

static GByteArray *
fu_bcm57xx_dict_image_write(FuFirmware *firmware, GError **error)
{
	guint32 crc;
	g_autoptr(GByteArray) blob = NULL;
	g_autoptr(GBytes) fw_nocrc = NULL;

	/* get the CRC-less data */
	fw_nocrc = fu_firmware_get_bytes(firmware, error);
	if (fw_nocrc == NULL)
		return NULL;

	/* add to a mutable buffer */
	blob = g_byte_array_sized_new(g_bytes_get_size(fw_nocrc) + sizeof(guint32));
	fu_byte_array_append_bytes(blob, fw_nocrc);

	/* add CRC */
	crc = fu_crc32_bytes(FU_CRC_KIND_B32_STANDARD, fw_nocrc);
	fu_byte_array_append_uint32(blob, crc, G_LITTLE_ENDIAN);
	return g_steal_pointer(&blob);
}

static gboolean
fu_bcm57xx_dict_image_build(FuFirmware *firmware, XbNode *n, GError **error)
{
	FuBcm57xxDictImage *self = FU_BCM57XX_DICT_IMAGE(firmware);
	guint64 tmp;

	/* two simple properties */
	tmp = xb_node_query_text_as_uint(n, "kind", NULL);
	if (tmp != G_MAXUINT64 && tmp <= G_MAXUINT8)
		fu_bcm57xx_dict_image_set_kind(self, tmp);
	tmp = xb_node_query_text_as_uint(n, "target", NULL);
	if (tmp != G_MAXUINT64 && tmp <= G_MAXUINT8)
		fu_bcm57xx_dict_image_set_target(self, tmp);

	/* success */
	return TRUE;
}

static void
fu_bcm57xx_dict_image_ensure_id(FuBcm57xxDictImage *self)
{
	g_autofree gchar *id = NULL;
	struct {
		guint8 target;
		guint8 kind;
		const gchar *id;
	} ids[] = {{0x00, 0x00, "pxe"},
		   {0x0D, 0x00, "ape"},
		   {0x09, 0x00, "iscsi1"},
		   {0x05, 0x00, "iscsi2"},
		   {0x0b, 0x00, "iscsi3"},
		   {0x00, 0x01, "cfg1000"},
		   {0x04, 0x01, "vpd2"},
		   {0xff, 0xff, NULL}};
	if (self->target == 0xff || self->kind == 0xff)
		return;
	for (guint i = 0; ids[i].id != NULL; i++) {
		if (self->target == ids[i].target && self->kind == ids[i].kind) {
			g_debug("using %s for %02x:%02x", ids[i].id, self->target, self->kind);
			fu_firmware_set_id(FU_FIRMWARE(self), ids[i].id);
			return;
		}
	}
	id = g_strdup_printf("dict-%02x-%02x", self->target, self->kind);
	if (g_getenv("FWUPD_FUZZER_RUNNING") == NULL)
		g_warning("falling back to %s, please report", id);
	fu_firmware_set_id(FU_FIRMWARE(self), id);
}

void
fu_bcm57xx_dict_image_set_target(FuBcm57xxDictImage *self, guint8 target)
{
	self->target = target;
	fu_bcm57xx_dict_image_ensure_id(self);
}

guint8
fu_bcm57xx_dict_image_get_target(FuBcm57xxDictImage *self)
{
	return self->target;
}

void
fu_bcm57xx_dict_image_set_kind(FuBcm57xxDictImage *self, guint8 kind)
{
	self->kind = kind;
	fu_bcm57xx_dict_image_ensure_id(self);
}

guint8
fu_bcm57xx_dict_image_get_kind(FuBcm57xxDictImage *self)
{
	return self->kind;
}

static void
fu_bcm57xx_dict_image_init(FuBcm57xxDictImage *self)
{
	self->target = 0xff;
	self->kind = 0xff;
	fu_firmware_set_size_max(FU_FIRMWARE(self), 1 * FU_MB);
}

static void
fu_bcm57xx_dict_image_class_init(FuBcm57xxDictImageClass *klass)
{
	FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
	firmware_class->parse = fu_bcm57xx_dict_image_parse;
	firmware_class->write = fu_bcm57xx_dict_image_write;
	firmware_class->build = fu_bcm57xx_dict_image_build;
	firmware_class->export = fu_bcm57xx_dict_image_export;
}

FuFirmware *
fu_bcm57xx_dict_image_new(void)
{
	return FU_FIRMWARE(g_object_new(FU_TYPE_BCM57XX_DICT_IMAGE, NULL));
}
