/**
  * Json <-> DDS conversion routines
  * $Id$
  * $HeadURL$
  * $Author$
  * Created by Christian Ehrlicher, SLSE, 2017-11-30
  */

{% autoescape off %}
// filename: {{ namespace_abbr }}_json.cpp

#include "{{ namespace_abbr }}_json.h"
#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>
#include <LtsUtilsCore/dds_vector.h>
#include <dds/core/String.hpp>

namespace {{ namespace }}
{
template<>
int fromJson(const QJsonValue &val, type<int>)
{
  return val.toInt();
}

template<>
double fromJson(const QJsonValue &val, type<double>)
{
  return val.toDouble();
}

template<>
qint64 fromJson(const QJsonValue &val, type<qint64>)
{
  return val.toString().toLongLong();
}

QJsonValue toJson(int vec)
{
  return QJsonValue(vec);
}
QJsonValue toJson(double vec)
{
  return QJsonValue(vec);
}
QJsonValue toJson(qint64 vec)
{
  return QJsonValue(QString::number(vec));
}

// std::string
QJsonValue toJson(const std::string &element)
{
  return QJsonValue(QString::fromStdString(element));
}
template<>
std::string fromJson(const QJsonValue &val, type<std::string>)
{
  return val.toString().toStdString();
}

// std::vector<T>
template<typename T>
QJsonArray toJson(const std::vector<T> &vec)
{
  QJsonArray arr;
  for (const auto &element : vec)
    arr.push_back(toJson(element));
  return arr;
}

template<typename T>
std::vector<T> fromJson(const QJsonValue &val, type<std::vector<T>>)
{
  std::vector<T> ret;
  if (!val.isArray())
    return ret;
  const QJsonArray array(val.toArray());
  ret.reserve(array.size());
  for(int i = 0; i < array.size(); ++i)
    ret.push_back(fromJson(array.at(i), type<T>{}));
  return ret;
}

// dds::core:vector<uint8_t> (bytestream)
inline QJsonValue toJson(const std::vector<uint8_t> &element)
{
  return QJsonValue(QString::fromLatin1(QByteArray::fromRawData(reinterpret_cast<const char *>(&element.at(0)),
                                                                static_cast<int>(element.size())).toBase64()));
}
template<>
std::vector<uint8_t> fromJson(const QJsonValue &val, type<std::vector<uint8_t>>)
{
  const QByteArray ba(QByteArray::fromBase64(val.toString().toLatin1()));
  return LtsUtils::convert<std::vector<uint8_t>>(ba);
}

{% for dt in jsonTopics %}
// {{ dt.name }}
QJsonObject toJson(const {{ dt.name }} &element)
{
  QJsonObject obj;
  {% for row in dt.cppMember %}
  {{ row.ddsToJsonElement }};
  {% endfor %}
  return obj;
}

template<>
{{ dt.name }} fromJson(const QJsonValue &value, type<{{ dt.name }}>)
{
  const QJsonObject objElement(value.toObject());
  {{ dt.name }} element;

  {% for row in dt.cppMember %}
  { {{ row.jsonElementToDds }}; } {% endfor %}

  return element;
}

//
// extensions to support sequence of seqence of Non-POD :
//

QJsonValue toJson(const std::vector <{{ dt.name }} > &element)
{

  if (element.size() == 0)
    return QJsonValue();
  QJsonArray array;
  for(size_t i = 0; i < element.size(); ++i)
  array.push_back(toJson(element.at(i)));

  return array;
}

template<>
std::vector<{{ dt.name }}> fromJson(const QJsonValue &value, type< std::vector <{{ dt.name }} > >)
{
  std::vector < {{ dt.name }} > ret;
  if (value.isNull())
    return ret;
  if (!value.isArray())
    return ret;

  const QJsonArray array = value.toArray();
  ret.reserve(array.size());
  for(const auto &ele : array)
    ret.push_back(fromJson(ele, type<{{ dt.name }}>{}));
  return ret;
}



{% endfor %}

} // namespace {{ namespace }}

{% endautoescape %}