/****************************************************************************
 * This file is part of the project AqHome.
 * AqHome (c) by 2023 Martin Preuss, all rights reserved.
 *
 * The license for this file can be found in the file COPYING which you
 * should have received along with this file.
 ****************************************************************************/

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif


#include <aqhome/ipc/data/ipc_data.h>
#include <aqhome/ipc/msg_ipc_tag16.h>
#include <aqhome/data/value.h>

#include <gwenhywfar/debug.h>
#include <gwenhywfar/tag16.h>


/* ------------------------------------------------------------------------------------------------
 * defines
 * ------------------------------------------------------------------------------------------------
 */

#define AQH_IPCDATA_VALUE_TAGS_ID             0x01
#define AQH_IPCDATA_VALUE_TAGS_DRIVER         0x02
#define AQH_IPCDATA_VALUE_TAGS_NAMEFORDRIVER  0x03
#define AQH_IPCDATA_VALUE_TAGS_NAMEFORSYSTEM  0x04
#define AQH_IPCDATA_VALUE_TAGS_TYPE           0x05
#define AQH_IPCDATA_VALUE_TAGS_UNITS          0x06
#define AQH_IPCDATA_VALUE_TAGS_TIMEOFCREATION 0x07
#define AQH_IPCDATA_VALUE_TAGS_DEVFORDRIVER   0x08
#define AQH_IPCDATA_VALUE_TAGS_DEVFORSYSTEM   0x09



/* ------------------------------------------------------------------------------------------------
 * forward declarations
 * ------------------------------------------------------------------------------------------------
 */

static void _writeValueFieldsAsTagsToBuffer(const AQH_VALUE *value, GWEN_BUFFER *buf);
static AQH_VALUE *_readValueFromTag(const uint8_t *ptr, uint32_t len);



/* ------------------------------------------------------------------------------------------------
 * code
 * ------------------------------------------------------------------------------------------------
 */



int AQH_DataIpc_WriteValueListAsTagsToBuffer(unsigned int tagType, const AQH_VALUE_LIST *valueList, GWEN_BUFFER *buf)
{
  if (valueList) {
    const AQH_VALUE *value;

    value=AQH_Value_List_First(valueList);
    while(value) {
      int rv;

      rv=AQH_DataIpc_WriteValueAsTagToBuffer(tagType, value, buf);
      if (rv<0) {
        DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
        GWEN_Buffer_free(buf);
        return rv;
      }

      value=AQH_Value_List_Next(value);
    }
  }
  return 0;
}



int AQH_DataIpc_WriteValueAsTagToBuffer(unsigned int tagType, const AQH_VALUE *value, GWEN_BUFFER *buf)
{
  int startPos;
  int rv;

  startPos=GWEN_Tag16_StartTagInBuffer(tagType, buf);
  if (startPos<0) {
    DBG_INFO(AQH_LOGDOMAIN, "here (%d)", startPos);
    return startPos;
  }

  _writeValueFieldsAsTagsToBuffer(value, buf);

  rv=GWEN_Tag16_EndTagInBuffer(startPos, buf);
  if (rv<0) {
    DBG_INFO(AQH_LOGDOMAIN, "here (%d)", rv);
    return rv;
  }

  return 0;
}



void _writeValueFieldsAsTagsToBuffer(const AQH_VALUE *value, GWEN_BUFFER *buf)
{
  const char *s;

  GWEN_Tag16_WriteUint64TagToBuffer(AQH_IPCDATA_VALUE_TAGS_ID, AQH_Value_GetId(value), buf);

  s=AQH_Value_GetDriver(value);
  if (s && *s)
    GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_DRIVER, s, buf);

  s=AQH_Value_GetNameForDriver(value);
  if (s && *s)
    GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_NAMEFORDRIVER, s, buf);

  s=AQH_Value_GetNameForSystem(value);
  if (s && *s)
    GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_NAMEFORSYSTEM, s, buf);

  GWEN_Tag16_WriteUint32TagToBuffer(AQH_IPCDATA_VALUE_TAGS_TYPE, AQH_Value_GetValueType(value), buf);

  s=AQH_Value_GetValueUnits(value);
  if (s && *s)
    GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_UNITS, s, buf);

  GWEN_Tag16_WriteUint64TagToBuffer(AQH_IPCDATA_VALUE_TAGS_TIMEOFCREATION, AQH_Value_GetTimestampCreation(value), buf);

  s=AQH_Value_GetDeviceNameForDriver(value);
  if (s && *s)
    GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_DEVFORDRIVER, s, buf);

  s=AQH_Value_GetDeviceNameForSystem(value);
  if (s && *s)
    GWEN_Tag16_WriteStringTagToBuffer(AQH_IPCDATA_VALUE_TAGS_DEVFORSYSTEM, s, buf);
}






AQH_VALUE_LIST *AQH_DataIpc_ReadValuesFromTagList(const GWEN_TAG16_LIST *tagList, unsigned int wantedTagType)
{
  AQH_VALUE_LIST *valueList;
  const GWEN_TAG16 *tag;

  valueList=AQH_Value_List_new();
  tag=GWEN_Tag16_List_First(tagList);
  while(tag) {
    unsigned int tagType;
    AQH_VALUE *value;

    tagType=GWEN_Tag16_GetTagType(tag);
    if (tagType==wantedTagType) {
      value=_readValueFromTag((const uint8_t*) GWEN_Tag16_GetTagData(tag), (uint32_t) GWEN_Tag16_GetTagLength(tag));
      if (value)
        AQH_Value_List_Add(value, valueList);
    }

    tag=GWEN_Tag16_List_Next(tag);
  }

  if (AQH_Value_List_GetCount(valueList)<1) {
    AQH_Value_List_free(valueList);
    return NULL;
  }

  return valueList;
}



AQH_VALUE *AQH_DataIpc_ReadValueFromTagList(const GWEN_TAG16_LIST *tagList, unsigned int wantedTagType)
{
  if (tagList) {
    const GWEN_TAG16 *tag;

    tag=GWEN_Tag16_List_FindFirstByTagType(tagList, wantedTagType);
    return tag?_readValueFromTag((const uint8_t*) GWEN_Tag16_GetTagData(tag), (uint32_t) GWEN_Tag16_GetTagLength(tag)):NULL;
  }
  return NULL;
}



AQH_VALUE *_readValueFromTag(const uint8_t *ptr, uint32_t len)
{
  GWEN_TAG16_LIST *tagList;

  tagList=GWEN_Tag16_List_fromBuffer(ptr, len, 0);
  if (tagList) {
    GWEN_TAG16 *tag;
    AQH_VALUE *value;

    value=AQH_Value_new();
    tag=GWEN_Tag16_List_First(tagList);
    while(tag) {
      unsigned int tagType;
      char *s;

      tagType=GWEN_Tag16_GetTagType(tag);
      switch(tagType) {
      case AQH_IPCDATA_VALUE_TAGS_ID:
        AQH_Value_SetId(value, GWEN_Tag16_GetTagDataAsUint64(tag, 0));
        break;
      case AQH_IPCDATA_VALUE_TAGS_DRIVER:
        s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
        AQH_Value_SetDriver(value, s);
        free(s);
        break;
      case AQH_IPCDATA_VALUE_TAGS_NAMEFORDRIVER:
        s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
        AQH_Value_SetNameForDriver(value, s);
        free(s);
        break;
      case AQH_IPCDATA_VALUE_TAGS_NAMEFORSYSTEM:
        s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
        AQH_Value_SetNameForSystem(value, s);
        free(s);
        break;
      case AQH_IPCDATA_VALUE_TAGS_TYPE:
        AQH_Value_SetValueType(value, GWEN_Tag16_GetTagDataAsUint32(tag, 0));
        break;
      case AQH_IPCDATA_VALUE_TAGS_UNITS:
        s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
        AQH_Value_SetValueUnits(value, s);
        free(s);
        break;
      case AQH_IPCDATA_VALUE_TAGS_TIMEOFCREATION:
        AQH_Value_SetTimestampCreation(value, GWEN_Tag16_GetTagDataAsUint64(tag, 0));
        break;
      case AQH_IPCDATA_VALUE_TAGS_DEVFORDRIVER:
        s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
        AQH_Value_SetDeviceNameForDriver(value, s);
        free(s);
        break;
      case AQH_IPCDATA_VALUE_TAGS_DEVFORSYSTEM:
        s=GWEN_Tag16_GetTagDataAsNewString(tag, NULL);
        AQH_Value_SetDeviceNameForSystem(value, s);
        free(s);
        break;
      default:
        DBG_INFO(AQH_LOGDOMAIN, "Unhandled tag typ %d (%02x)", tagType, tagType);
        break;
      }
      tag=GWEN_Tag16_List_Next(tag);
    }
    GWEN_Tag16_List_free(tagList);
    return value;
  }

  return NULL;
}