/*

 * Copyright 2021 Jimmy Yu <Jimmy_yu@pixart.com>

 * Copyright 2021 Richard Hughes <richard@hughsie.com>

 *

 * SPDX-License-Identifier: LGPL-2.1-or-later

 */

#include "config.h"

#include "fu-pixart-rf-common.h"

#include "fu-pixart-rf-struct.h"

void

fu_pixart_rf_ota_fw_state_to_string(FuPixartRfOtaFwState *fwstate, guint idt, GString *str)

{

  fwupd_codec_string_append_hex(str, idt, "Status", fwstate->status);

  fwupd_codec_string_append_hex(str, idt, "NewFlow", fwstate->new_flow);

  fwupd_codec_string_append_hex(str, idt, "CurrentObjectOffset", fwstate->offset);

  fwupd_codec_string_append_hex(str, idt, "CurrentChecksum", fwstate->checksum);

  fwupd_codec_string_append_hex(str, idt, "MaxObjectSize", fwstate->max_object_size);

  fwupd_codec_string_append_hex(str, idt, "MtuSize", fwstate->mtu_size);

  fwupd_codec_string_append_hex(str,

              idt,

              "PacketReceiptNotificationThreshold",

              fwstate->prn_threshold);

  fwupd_codec_string_append(

      str,

      idt,

      "SpecCheckResult",

      fu_pixart_rf_ota_spec_check_result_to_string(fwstate->spec_check_result));

}

gboolean

fu_pixart_rf_ota_fw_state_parse(FuPixartRfOtaFwState *fwstate,

        const guint8 *buf,

        gsize bufsz,

        gsize offset,

        GError **error)

{

  g_autoptr(FuStructPixartRfOtaFwState) st = NULL;

  st = fu_struct_pixart_rf_ota_fw_state_parse(buf, bufsz, offset, error);

  if (st == NULL)

    return FALSE;

  fwstate->status = fu_struct_pixart_rf_ota_fw_state_get_status(st);

  fwstate->new_flow = fu_struct_pixart_rf_ota_fw_state_get_new_flow(st);

  fwstate->offset = fu_struct_pixart_rf_ota_fw_state_get_offset(st);

  fwstate->checksum = fu_struct_pixart_rf_ota_fw_state_get_checksum(st);

  fwstate->max_object_size = fu_struct_pixart_rf_ota_fw_state_get_max_object_size(st);

  fwstate->mtu_size = fu_struct_pixart_rf_ota_fw_state_get_mtu_size(st);

  fwstate->prn_threshold = fu_struct_pixart_rf_ota_fw_state_get_prn_threshold(st);

  fwstate->spec_check_result = fu_struct_pixart_rf_ota_fw_state_get_spec_check_result(st);

  /* success */

  return TRUE;

}

gboolean

fu_pixart_rf_composite_receiver_cmd(guint8 opcode,

            guint8 sn,

            guint8 target,

            GByteArray *wireless_mod_cmd,

            GByteArray *ota_cmd,

            GError **error)

{

  guint8 checksum = 0x0;

  guint8 hid_sn = sn;

  guint8 len = 0x0;

  guint8 ota_sn = sn + 1;

  guint8 rf_cmd_code = FU_PIXART_RF_BLE_DEVICE_RF_CMD_CODE;

  guint8 rid = PIXART_RF_HID_WIRELESS_DEV_OTA_REPORT_ID;

  if (ota_cmd == NULL) {

    g_set_error_literal(error, FWUPD_ERROR, FWUPD_ERROR_INTERNAL, "ota cmd is NULL");

    return FALSE;

  }

  /* append ota dispatch header */

  fu_byte_array_append_uint8(wireless_mod_cmd, opcode); /* wireless module ota op code */

  fu_byte_array_append_uint8(wireless_mod_cmd, ota_sn); /* wireless module ota command sn */

  /* append ota command length and content  */

  for (guint idx = 0; idx < ota_cmd->len; idx++)

    fu_byte_array_append_uint8(wireless_mod_cmd, ota_cmd->data[idx]);

  /* append target of wireless module and hid command serial number */

  g_byte_array_prepend(wireless_mod_cmd, &target, 0x01); /* target */

  g_byte_array_prepend(wireless_mod_cmd, &hid_sn, 0x01); /* hid command sn */

  /* prepend length and rf command code, the param len not include "hid_sn" byte and "target"

   * byte */

  len = wireless_mod_cmd->len - 2;

  g_byte_array_prepend(wireless_mod_cmd, &len, 0x01);

  g_byte_array_prepend(wireless_mod_cmd, &rf_cmd_code, 0x01); /* command code */

  /* prepend checksum */

  checksum = fu_sum8(wireless_mod_cmd->data, wireless_mod_cmd->len);

  g_byte_array_prepend(wireless_mod_cmd, &checksum, 0x01);

  /* prepend feature report id */

  g_byte_array_prepend(wireless_mod_cmd, &rid, 0x01);

  return TRUE;

}

gchar *

fu_pixart_rf_hpac_version_info_parse(const guint16 hpac_ver)

{

  return g_strdup_printf("%u%u.%u%u.%u",

             (guint)(hpac_ver / 10000),

             (guint)((hpac_ver / 1000) % 10),

             (guint)((hpac_ver / 100) % 10),

             (guint)((hpac_ver / 10) % 10),

             (guint)(hpac_ver % 10));

}