/**
 * @file
 *
 * @copyright
 * @verbatim
   Copyright @ 2017 Audi Electronics Venture GmbH. All rights reserved.

       This Source Code Form is subject to the terms of the Mozilla
       Public License, v. 2.0. If a copy of the MPL was not distributed
       with this file, You can obtain one at https://mozilla.org/MPL/2.0/.

   If it is not possible or desirable to put the notice in a particular file, then
   You may include the notice in a location (such as a LICENSE file in a
   relevant directory) where a recipient would be likely to look for such a notice.

   You may add additional accurate notices of copyright ownership.
   @endverbatim
*/

#include "element.h"

using namespace mapping;
using namespace mapping::rt;

namespace mapping
{
namespace rt
{
    //define all needed error types and values locally
    _MAKE_RESULT(-3, ERR_UNEXPECTED)
    _MAKE_RESULT(-5, ERR_INVALID_ARG)
    _MAKE_RESULT(-42, ERR_INVALID_TYPE)
}
}

/// Helper method that sets a casted value in the coder
template <typename T>
static void SetCastedValue(void* pDestination, unsigned int nArrayIndex, T* pData,
    uint32_t type32)
{
    switch (type32)
    {
    case e_uint8:
        {
            uint8_t ui8Temp = static_cast<uint8_t>(*pData);
            a_util::memory::copy((uint8_t*)pDestination + nArrayIndex, sizeof(uint8_t), &ui8Temp, sizeof(uint8_t));
        }
        break;
    case e_uint16:
        {
            uint16_t ui16Temp = static_cast<uint16_t>(*pData);
            a_util::memory::copy((uint16_t*)pDestination + nArrayIndex, sizeof(uint16_t), &ui16Temp, sizeof(uint16_t));
        }
        break;
    case e_uint32:
        {
            uint32_t ui32Temp = static_cast<uint32_t>(*pData);
            a_util::memory::copy((uint32_t*)pDestination + nArrayIndex, sizeof(uint32_t), &ui32Temp, sizeof(uint32_t));
        }
        break;
    case e_uint64:
        {
            uint64_t ui64Temp = static_cast<uint64_t>(*pData);
            a_util::memory::copy((uint64_t*)pDestination + nArrayIndex, sizeof(uint64_t), &ui64Temp, sizeof(uint64_t));
        }
        break;
    case e_int8:
        {
            int8_t i8Temp = static_cast<int8_t>(*pData);
            a_util::memory::copy((int8_t*)pDestination + nArrayIndex, sizeof(int8_t), &i8Temp, sizeof(int8_t));
        }
        break;
    case e_int16:
        {
            int16_t i16Temp = static_cast<int16_t>(*pData);
            a_util::memory::copy((int16_t*)pDestination + nArrayIndex, sizeof(int16_t), &i16Temp, sizeof(int16_t));
        }
        break;
    case e_int32:
        {
            int32_t i32Temp = static_cast<int32_t>(*pData);
            a_util::memory::copy((int32_t*)pDestination + nArrayIndex, sizeof(int32_t), &i32Temp, sizeof(int32_t));
        }
        break;
    case e_int64:
        {
            int64_t i64Temp = static_cast<int64_t>(*pData);
            a_util::memory::copy((int64_t*)pDestination + nArrayIndex, sizeof(int64_t), &i64Temp, sizeof(int64_t));
        }
        break;
    case e_float32:
        {
            float f32Temp = static_cast<float>(*pData);
            a_util::memory::copy((float*)pDestination + nArrayIndex, sizeof(float), &f32Temp, sizeof(float));
        }
        break;
    case e_float64:
        {
            double f64Temp = static_cast<double>(*pData);
            a_util::memory::copy((double*)pDestination + nArrayIndex, sizeof(double), &f64Temp, sizeof(double));
        }
        break;
    case e_bool:
        {
            bool bTemp = *pData != 0 ? true : false;
            a_util::memory::copy((bool*)pDestination + nArrayIndex, sizeof(bool), &bTemp, sizeof(bool));
        }
        break;
    case e_char:
        {
            char cTemp = static_cast<char>(*pData);
            a_util::memory::copy((char*)pDestination + nArrayIndex, sizeof(char), &cTemp, sizeof(char));
        }
        break;
    default:
        assert(false);
        break;
    }
}

template <>
void SetCastedValue<bool>(void* pDestination, unsigned int nArrayIndex, bool* pData,
    uint32_t type32)
{
    int nBool = *pData ? 1 : 0;
    switch (type32)
    {
    case e_uint8:
        {
            uint8_t ui8Temp = static_cast<uint8_t>(nBool);
            a_util::memory::copy((uint8_t*)pDestination + nArrayIndex, sizeof(uint8_t), &ui8Temp, sizeof(uint8_t));
        }
        break;
    case e_uint16:
        {
            uint16_t ui16Temp = static_cast<uint16_t>(nBool);
            a_util::memory::copy((uint16_t*)pDestination + nArrayIndex, sizeof(uint16_t), &ui16Temp, sizeof(uint16_t));
        }
        break;
    case e_uint32:
        {
            uint32_t ui32Temp = static_cast<uint32_t>(nBool);
            a_util::memory::copy((uint32_t*)pDestination + nArrayIndex, sizeof(uint32_t), &ui32Temp, sizeof(uint32_t));
        }
        break;
    case e_uint64:
        {
            uint64_t ui64Temp = static_cast<uint64_t>(nBool);
            a_util::memory::copy((uint64_t*)pDestination + nArrayIndex, sizeof(uint64_t), &ui64Temp, sizeof(uint64_t));
        }
        break;
    case e_int8:
        {
            int8_t i8Temp = static_cast<int8_t>(nBool);
            a_util::memory::copy((int8_t*)pDestination + nArrayIndex, sizeof(int8_t), &i8Temp, sizeof(int8_t));
        }
        break;
    case e_int16:
        {
            int16_t i16Temp = static_cast<int16_t>(nBool);
            a_util::memory::copy((int16_t*)pDestination + nArrayIndex, sizeof(int16_t), &i16Temp, sizeof(int16_t));
        }
        break;
    case e_int32:
        {
            int32_t i32Temp = static_cast<int32_t>(nBool);
            a_util::memory::copy((int32_t*)pDestination + nArrayIndex, sizeof(int32_t), &i32Temp, sizeof(int32_t));
        }
        break;
    case e_int64:
        {
            int64_t i64Temp = static_cast<int64_t>(nBool);
            a_util::memory::copy((int64_t*)pDestination + nArrayIndex, sizeof(int64_t), &i64Temp, sizeof(int64_t));
        }
        break;
    case e_float32:
        {
            float f32Temp = static_cast<float>(nBool);
            a_util::memory::copy((float*)pDestination + nArrayIndex, sizeof(float), &f32Temp, sizeof(float));
        }
        break;
    case e_float64:
        {
            double f64Temp = static_cast<double>(nBool);
            a_util::memory::copy((double*)pDestination + nArrayIndex, sizeof(double), &f64Temp, sizeof(double));
        }
        break;
    case e_bool:
        a_util::memory::copy((bool*)pDestination + nArrayIndex, sizeof(bool), pData, sizeof(bool));
        break;
    case e_char:
        {
            char cTemp = static_cast<char>(nBool);
            a_util::memory::copy((char*)pDestination + nArrayIndex, sizeof(char), &cTemp, sizeof(char));
        }
        break;
    default:
        assert(false);
        break;
    }
}

template <typename T>
static inline void TransformAndSetValueImpl(const void* pData, void* pDestination,
    unsigned int nArraySize, const oo::MapTransformationBase* pTrans, uint32_t type32)
{
    assert(pTrans);
    assert(pData);
    for(unsigned int i = 0; i < nArraySize; i++)
    {
        double fValue = pTrans->evaluate(static_cast<double>(*((T*)pData + i)));
        SetCastedValue(pDestination, i, &fValue, type32);
    }
}

template <typename T>
static inline void SetValueImpl(const void* pData, void* pDestination, unsigned int nArraySize,
    uint32_t type32)
{
    assert(pData);
    for(unsigned int i = 0; i < nArraySize; i++)
    {
        SetCastedValue<T>(pDestination, i, (T*)pData + i, type32);
    }
}

TargetElement::TargetElement(Target* pTarget) :
    _target(pTarget), _element_ptr(NULL), _type_int(0),
    _type(NULL), _struct(NULL),
    _array_size(0), _transformation(NULL)
{
    _type_map["tUInt8"] =   e_uint8;
    _type_map["tUInt16"] =  e_uint16;
    _type_map["tUInt32"] =  e_uint32;
    _type_map["tUInt64"] =  e_uint64;
    _type_map["tInt8"] =    e_int8;
    _type_map["tInt16"] =   e_int16;
    _type_map["tInt32"] =   e_int32;
    _type_map["tInt64"] =   e_int64;
    _type_map["tFloat32"] = e_float32;
    _type_map["tFloat64"] = e_float64;
    _type_map["tBool"] =    e_bool;
    _type_map["tChar"] =    e_char;
}

TargetElement::~TargetElement()
{
    delete _transformation;
    _transformation = NULL;
}

a_util::result::Result TargetElement::create(void* pElementPtr, ddl::IDDLDataType* pDataType,
    const unsigned int nArraySize, const std::string& strElementName)
{
    _element_ptr = pElementPtr;
    _array_size = nArraySize;
    _element_name = strElementName;

    _type = dynamic_cast<ddl::DDLDataType*>(pDataType);
    _struct = dynamic_cast<ddl::DDLComplex*>(pDataType);
    _enum = dynamic_cast<ddl::DDLEnum*>(pDataType);

    if (_enum)
    {
        _type = dynamic_cast<ddl::DDLDataType*>(_enum->getTypeObject());
        if (!_type)
        {
            return  ERR_UNEXPECTED;
        }

        _enum = NULL;
    }

    if(_type)
    {
        TypeMap::const_iterator it = _type_map.find(_type->getName());
        if(it != _type_map.end())
        {
            _type_int = it->second;
        }
    }

    return a_util::result::SUCCESS;
}

a_util::result::Result TargetElement::setTransformation(const oo::MapTransformationBase* pTransformation)
{
    if (_transformation)
    {
        delete _transformation;
        _transformation = NULL;
    }

    if (pTransformation)
    {
        _transformation = pTransformation->clone();
    }

    return a_util::result::SUCCESS;
}

a_util::result::Result TargetElement::setValue(const void* pData, uint32_t ui32SrcType, size_t szMem)
{
    // Scalars (and enums converted to scalars)
    if(_type)
    {
        if(_transformation)
        {
            switch(ui32SrcType)
            {
            case e_uint8:
                TransformAndSetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_uint16:
                TransformAndSetValueImpl<uint16_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_uint32:
                TransformAndSetValueImpl<uint32_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_uint64:
                TransformAndSetValueImpl<uint64_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_int8:
                TransformAndSetValueImpl<int8_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_int16:
                TransformAndSetValueImpl<int16_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_int32:
                TransformAndSetValueImpl<int32_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_int64:
                TransformAndSetValueImpl<int64_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_float32:
                TransformAndSetValueImpl<float>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_float64:
                TransformAndSetValueImpl<double>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_bool:
                TransformAndSetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            case e_char:
                TransformAndSetValueImpl<char>(pData, _element_ptr, _array_size, _transformation, _type_int);
                break;
            default: 
                return ERR_INVALID_TYPE;
            }
        }
        else if(_type_int == ui32SrcType)
        {
            // Source and target have the same type
            a_util::memory::copy(_element_ptr, szMem, pData, szMem);
        }
        else
        {
            // Source and target have different types
            switch(ui32SrcType)
            {
            case e_uint8:
                SetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_uint16:
                SetValueImpl<uint16_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_uint32:
                SetValueImpl<uint32_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_uint64:
                SetValueImpl<uint64_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_int8:
                SetValueImpl<int8_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_int16:
                SetValueImpl<int16_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_int32:
                SetValueImpl<int32_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_int64:
                SetValueImpl<int64_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_float32:
                SetValueImpl<float>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_float64:
                SetValueImpl<double>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_bool:
                SetValueImpl<uint8_t>(pData, _element_ptr, _array_size, _type_int);
                break;
            case e_char:
                SetValueImpl<char>(pData, _element_ptr, _array_size, _type_int);
                break;
            default: 
                return ERR_INVALID_TYPE;
            }
        }
    }
    else if(_struct) // Structures
    {
        // Transformations are not allowed
        a_util::memory::copy(_element_ptr, szMem, pData, szMem);
    }
    else
    {
        return ERR_INVALID_ARG;
    }

    return a_util::result::SUCCESS;
}

Target* TargetElement::getTarget()
{
    return _target;
}

a_util::result::Result TargetElement::setDefaultValue(const std::string& strDefault)
{
    // Scalars and  arrays
    if(_type)
    {
        double fVal = 0;
        if(!strDefault.empty() && a_util::strings::isDouble(strDefault))
        {
            fVal = a_util::strings::toDouble(strDefault);
        }
        
        for(unsigned int i = 0; i < _array_size; i++)
        {
            SetCastedValue<double>(_element_ptr, i, &fVal, _type_int);
        }
    }

    //Structures
    if(_struct)
    {
        //TODO: What is default value for a structure?
        return ERR_INVALID_ARG;
    }

    return a_util::result::SUCCESS;
}