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

#include "config.h"

#include <string.h>

#include "fu-synaptics-prometheus-firmware.h"
#include "fu-synaptics-prometheus-struct.h"

struct _FuSynapticsPrometheusFirmware {
	FuFirmware parent_instance;
	guint32 product_id;
	guint32 signature_size;
};

G_DEFINE_TYPE(FuSynapticsPrometheusFirmware, fu_synaptics_prometheus_firmware, FU_TYPE_FIRMWARE)

/* use only first 12 bit of 16 bits as tag value */
#define FU_SYNAPTICS_PROMETHEUS_FIRMWARE_TAG_MAX 0xfff0

#define FU_SYNAPTICS_PROMETHEUS_FIRMWARE_COUNT_MAX 64

guint32
fu_synaptics_prometheus_firmware_get_product_id(FuSynapticsPrometheusFirmware *self)
{
	g_return_val_if_fail(FU_IS_SYNAPTICS_PROMETHEUS_FIRMWARE(self), 0x0);
	return self->product_id;
}

gboolean
fu_synaptics_prometheus_firmware_set_signature_size(FuSynapticsPrometheusFirmware *self,
						    guint32 signature_size)
{
	g_return_val_if_fail(FU_IS_SYNAPTICS_PROMETHEUS_FIRMWARE(self), FALSE);
	self->signature_size = signature_size;
	return TRUE;
}

static void
fu_synaptics_prometheus_firmware_export(FuFirmware *firmware,
					FuFirmwareExportFlags flags,
					XbBuilderNode *bn)
{
	FuSynapticsPrometheusFirmware *self = FU_SYNAPTICS_PROMETHEUS_FIRMWARE(firmware);
	fu_xmlb_builder_insert_kx(bn, "product_id", self->product_id);
}

static gboolean
fu_synaptics_prometheus_firmware_parse(FuFirmware *firmware,
				       GInputStream *stream,
				       FuFirmwareParseFlags flags,
				       GError **error)
{
	FuSynapticsPrometheusFirmware *self = FU_SYNAPTICS_PROMETHEUS_FIRMWARE(firmware);
	gsize offset = 0;
	gsize streamsz = 0;

	if (!fu_input_stream_size(stream, &streamsz, error))
		return FALSE;
	if (streamsz < self->signature_size + FU_STRUCT_SYNAPTICS_PROMETHEUS_HDR_SIZE) {
		g_set_error_literal(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_INVALID_DATA,
				    "blob is too small to be firmware");
		return FALSE;
	}
	streamsz -= self->signature_size;

	/* parse each chunk */
	while (offset < streamsz) {
		guint32 hdrsz;
		guint32 tag;
		g_autoptr(FuFirmware) img = fu_firmware_new();
		g_autoptr(FuFirmware) img_old = NULL;
		g_autoptr(FuStructSynapticsPrometheusHdr) st_hdr = NULL;
		g_autoptr(GInputStream) partial_stream = NULL;

		/* verify item header */
		st_hdr = fu_struct_synaptics_prometheus_hdr_parse_stream(stream, offset, error);
		if (st_hdr == NULL)
			return FALSE;
		tag = fu_struct_synaptics_prometheus_hdr_get_tag(st_hdr);
		if (tag >= FU_SYNAPTICS_PROMETHEUS_FIRMWARE_TAG_MAX) {
			g_set_error(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_INVALID_DATA,
				    "tag 0x%04x is too large",
				    tag);
			return FALSE;
		}

		/* sanity check */
		img_old = fu_firmware_get_image_by_idx(firmware, tag, NULL);
		if (img_old != NULL) {
			g_set_error(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_INVALID_DATA,
				    "tag 0x%04x already present in image",
				    tag);
			return FALSE;
		}
		hdrsz = fu_struct_synaptics_prometheus_hdr_get_bufsz(st_hdr);
		if (hdrsz == 0) {
			g_set_error(error,
				    FWUPD_ERROR,
				    FWUPD_ERROR_INVALID_DATA,
				    "empty header for tag 0x%04x",
				    tag);
			return FALSE;
		}
		if (!fu_size_checked_inc(&offset, st_hdr->buf->len, error)) {
			g_prefix_error(error, "overflow at tag 0x%04x: ", tag);
			return FALSE;
		}
		partial_stream = fu_partial_input_stream_new(stream, offset, hdrsz, error);
		if (partial_stream == NULL)
			return FALSE;
		if (!fu_firmware_parse_stream(img, partial_stream, 0x0, flags, error))
			return FALSE;
		g_debug("adding 0x%04x (%s) with size 0x%04x",
			tag,
			fu_synaptics_prometheus_firmware_tag_to_string(tag),
			hdrsz);
		fu_firmware_set_idx(img, tag);
		fu_firmware_set_id(img, fu_synaptics_prometheus_firmware_tag_to_string(tag));
		if (!fu_firmware_add_image(firmware, img, error))
			return FALSE;

		/* metadata */
		if (tag == FU_SYNAPTICS_PROMETHEUS_FIRMWARE_TAG_MFW_UPDATE_HEADER) {
			g_autofree gchar *version = NULL;
			g_autoptr(FuStructSynapticsPrometheusMfwHdr) st_mfw = NULL;
			st_mfw = fu_struct_synaptics_prometheus_mfw_hdr_parse_stream(stream,
										     offset,
										     error);
			if (st_mfw == NULL)
				return FALSE;
			self->product_id =
			    fu_struct_synaptics_prometheus_mfw_hdr_get_product(st_mfw);
			version = g_strdup_printf(
			    "%u.%u",
			    fu_struct_synaptics_prometheus_mfw_hdr_get_vmajor(st_mfw),
			    fu_struct_synaptics_prometheus_mfw_hdr_get_vminor(st_mfw));
			fu_firmware_set_version(firmware, version);
		}

		/* next item */
		if (!fu_size_checked_inc(&offset, hdrsz, error))
			return FALSE;
	}
	return TRUE;
}

static GByteArray *
fu_synaptics_prometheus_firmware_write(FuFirmware *firmware, GError **error)
{
	FuSynapticsPrometheusFirmware *self = FU_SYNAPTICS_PROMETHEUS_FIRMWARE(firmware);
	g_autoptr(GByteArray) buf = g_byte_array_new();
	g_autoptr(FuStructSynapticsPrometheusHdr) st_hdr = fu_struct_synaptics_prometheus_hdr_new();
	g_autoptr(FuStructSynapticsPrometheusMfwHdr) st_mfw =
	    fu_struct_synaptics_prometheus_mfw_hdr_new();
	g_autoptr(GBytes) payload = NULL;

	/* add header */
	fu_struct_synaptics_prometheus_hdr_set_tag(
	    st_hdr,
	    FU_SYNAPTICS_PROMETHEUS_FIRMWARE_TAG_MFW_UPDATE_HEADER);
	fu_struct_synaptics_prometheus_hdr_set_bufsz(st_hdr, st_mfw->buf->len);
	g_byte_array_append(buf, st_hdr->buf->data, st_hdr->buf->len);
	fu_struct_synaptics_prometheus_mfw_hdr_set_product(st_mfw, self->product_id);
	fu_byte_array_append_array(buf, st_mfw->buf);

	/* add payload */
	payload = fu_firmware_get_bytes_with_patches(firmware, error);
	if (payload == NULL)
		return NULL;
	fu_struct_synaptics_prometheus_hdr_set_tag(
	    st_hdr,
	    FU_SYNAPTICS_PROMETHEUS_FIRMWARE_TAG_MFW_UPDATE_PAYLOAD);
	fu_struct_synaptics_prometheus_hdr_set_bufsz(st_hdr, g_bytes_get_size(payload));
	g_byte_array_append(buf, st_hdr->buf->data, st_hdr->buf->len);
	fu_byte_array_append_bytes(buf, payload);

	/* add signature */
	for (guint i = 0; i < self->signature_size; i++)
		fu_byte_array_append_uint8(buf, 0xff);
	return g_steal_pointer(&buf);
}

static gboolean
fu_synaptics_prometheus_firmware_build(FuFirmware *firmware, XbNode *n, GError **error)
{
	FuSynapticsPrometheusFirmware *self = FU_SYNAPTICS_PROMETHEUS_FIRMWARE(firmware);
	guint64 tmp;

	/* simple properties */
	tmp = xb_node_query_text_as_uint(n, "product_id", NULL);
	if (tmp != G_MAXUINT64 && tmp <= G_MAXUINT32)
		self->product_id = tmp;

	/* success */
	return TRUE;
}

static void
fu_synaptics_prometheus_firmware_init(FuSynapticsPrometheusFirmware *self)
{
	fu_firmware_add_flag(FU_FIRMWARE(self), FU_FIRMWARE_FLAG_HAS_VID_PID);
	fu_firmware_add_image_gtype(FU_FIRMWARE(self), FU_TYPE_FIRMWARE);
	fu_firmware_set_images_max(FU_FIRMWARE(self), FU_SYNAPTICS_PROMETHEUS_FIRMWARE_COUNT_MAX);
	fu_firmware_set_size_max(FU_FIRMWARE(self), 16 * FU_MB);
	self->signature_size = FU_SYNAPTICS_PROMETHEUS_FIRMWARE_PROMETHEUS_SIGSIZE;
}

static void
fu_synaptics_prometheus_firmware_class_init(FuSynapticsPrometheusFirmwareClass *klass)
{
	FuFirmwareClass *firmware_class = FU_FIRMWARE_CLASS(klass);
	firmware_class->parse = fu_synaptics_prometheus_firmware_parse;
	firmware_class->write = fu_synaptics_prometheus_firmware_write;
	firmware_class->export = fu_synaptics_prometheus_firmware_export;
	firmware_class->build = fu_synaptics_prometheus_firmware_build;
}

FuFirmware *
fu_synaptics_prometheus_firmware_new(void)
{
	return FU_FIRMWARE(g_object_new(FU_TYPE_SYNAPTICS_PROMETHEUS_FIRMWARE, NULL));
}
