/*!
 *
 * Copyright (c) 2019-2020 Diality Inc. - All Rights Reserved.
 * \copyright
 *          THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM,
 *          IN PART OR IN WHOLE,
 *          WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
 *
 * \file    format.cpp
 * \date    12/16/2019
 * \author  Behrouz NematiPour
 *
 */
#include "format.h"

// Qt

// Project
#include <types.h>

Format::Format() { }

QString Format::toHexString(quint16 vValue, bool vWith0x, quint8 vLen) {
    if ( vWith0x ) {
        return "0x" + QString("%1").arg(vValue,0,16).rightJustified(vLen, '0').toUpper();
    } else {
        return        QString("%1").arg(vValue,0,16).rightJustified(vLen, '0').toUpper();
    }
}

QByteArray Format::toHexByteArray(const QByteArray &vData, char separator)
{
    return vData.toHex(separator).toUpper();
}

QString    Format::toHexString(const QByteArray &vData, char separator)
{
    QString string = toHexByteArray(vData, separator);
    return string;
}

/*!
 * \brief   Format::fromVariant
 * \details This static method converts the defined types into QByteArray
 * \param   vData - The value
 * \return  The QByteAttay of the value vData if can't be converted 0x00 will be returned
 * \note    Regarding the QVariant type conversion, if cannot be converted 0 will be returned
 *          This rule has been used and also to be consistent followed the sae rule.
 * \note    This method converts both float and double to F32 and returns its QByteArray representation.
 */
QByteArray Format::fromVariant(const QVariant &vData)
{
    QByteArray mData;
    if(vData.type() == QVariant::String) {
        mData += vData.toByteArray();
        return mData;
    }

    if(vData.type() == QVariant::ByteArray) {
        mData += vData.toByteArray();
        return mData;
    }

    if ( vData.type() == static_cast<QVariant::Type>(QMetaType::Float) ||
         vData.type() == QVariant::Double ) {
        Types::F32 f32;
        f32.value = vData.toFloat();
        Types::setValue(f32, mData);
        return mData;
    }

    if ( vData.type() == QVariant::UInt ) {
        Types::U32 u32;
        u32.value = vData.toUInt();
        Types::setValue(u32, mData);
        return mData;
    }

    if ( vData.type() == QVariant::Int ) {
        Types::S32 s32;
        s32.value = vData.toInt();
        Types::setValue(s32, mData);
        return mData;
    }

    if ( vData.type() == QVariant::List ) {
        QVariantList list = vData.toList();
        for(auto item: list) {
            mData += fromVariant(item);
        }
        return mData;
    }

    if ( vData.type() == QVariant::Bool ) {
        mData += vData.toUInt();
        return mData;
    }

    mData += '\0';
    return mData;
}

QStringList Format::toStringList(const QList<const char *> vList, bool vRemoveDuplicate, QString vPrefix)
{
    QStringList list;
    for (const auto &listItem : vList) {
        auto item = vPrefix + listItem;
        if ( vRemoveDuplicate ) {
            if ( ! list.contains(item) ) {
                list += item;
            }
        }
        else
            list += item;
    }
    return list;
}