#include "dbcc/signal_processor.h"

#include <tuple>

namespace ad {
namespace dbcc {

size_t SignalProcessor::_signalIndex(uint32_t msgId, const std::string &signalName)
{
    auto msgIter = m_dbcIter.find(msgId);

    if (msgIter == m_dbcIter.end())
    {
        return InvalidIndex;
    }

    if (!msgIter->contains(signalName))
    {
        return InvalidIndex;
    }

    return (*msgIter)[signalName];
}

bool SignalProcessor::decodeMessage(uint32_t msgId, const uint8_t *data, size_t length)
{
    ad::dbcc::ParsedValue pv;

    auto iter = m_decoderMap.find(msgId);

    if (iter == m_decoderMap.end())
    {
        return false;
    }

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    for (size_t i = 0; i < vt.size(); i++)
    {
        auto & sig = msg[vt[i]];

        if (sig.decode(data, length, pv))
        {
            sig.getDecodeDelegate()->onDecoded(msgId, sig.name(), pv);
        }
        else
        {
            std::cout << "[WARNING] Failed to decode: " << msgId << ":" << sig.name() << std::endl;

            return false;
        }
    }

    return true;
}

bool SignalProcessor::encodeMessage(uint32_t msgId, const SignalValues &pvs, uint8_t *data, size_t length)
{
    auto iter = m_encoderMap.find(msgId);

    if (iter == m_encoderMap.end())
    {
        return false;
    }

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    for (size_t i = 0; i < pvs.size(); i++)
    {
        auto &pv = pvs[i];
        auto idx = msg[pv.first];
        if (idx != InvalidIndex)
        {
            auto &sig = msg[idx];
            if (sig.encode(pv.second, data, length))
            {
                if (!sig.getEncodeDelegate()->onEncoded(msgId, sig.name(), data, length, pv.second, i == pvs.size() - 1))
                {
                    break;
                }
            }
            else
            {
                std::cout << "[WARNING] Failed to encode: " << msgId << ":" << sig.name() << std::endl;

                return false;
            }
        }
        else
        {
            std::cout << "[WARNING] The signal (" << msgId << ":" << pv.first << ") does not exist!" << std::endl;

            return false;
        }
    }

    return true;
}

bool SignalProcessor::encodeMessage(uint32_t msgId, const SignalValuesVector &pvs, uint8_t *data, size_t length)
{
    auto iter = m_encoderMap.find(msgId);

    if (iter == m_encoderMap.end())
    {
        return false;
    }

    ParsedValue rpv;

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    for (size_t i = 0; i < pvs.size(); i++)
    {
        auto &pv = pvs[i];
        auto idx = msg[pv.first];
        if (idx != InvalidIndex)
        {
            auto &sig = msg[idx];
            if (sig.encode(pv.second, data, length))
            {
                rpv.isInteger = !sig.isFloat();
                if (rpv.isInteger)
                {
                    rpv.i = static_cast<int32_t>(pv.second);
                }
                else
                {
                    rpv.f = static_cast<float>(pv.second);
                }

                if (!sig.getEncodeDelegate()->onEncoded(msgId, sig.name(), data, length, rpv, i == pvs.size() - 1))
                {
                    break;
                }
            }
            else
            {
                std::cout << "[WARNING] Failed to encode: " << msgId << ":" << sig.name() << std::endl;

                return false;
            }
        }
        else
        {
            std::cout << "[WARNING] The signal (" << msgId << ":" << pv.first << ") does not exist!" << std::endl;

            return false;
        }
    }

    return true;
}

bool SignalProcessor::encodeMessage(uint32_t msgId, const SignalValuesMap &pvs, uint8_t *data, size_t length)
{
    auto iter = m_encoderMap.find(msgId);

    if (iter == m_encoderMap.end())
    {
        return false;
    }

    ParsedValue rpv;

    ad::dbcc::Message msg;
    std::vector<size_t> vt;

    std::tie(msg, vt) = iter->second;

    size_t i = 0;

    for (auto &kv : pvs)
    {
        auto idx = msg[kv.first];
        if (idx != InvalidIndex)
        {
            auto &sig = msg[idx];
            if (sig.encode(kv.second, data, length))
            {
                rpv.isInteger = !sig.isFloat();
                if (rpv.isInteger)
                {
                    rpv.i = static_cast<int32_t>(kv.second);
                }
                else
                {
                    rpv.f = static_cast<float>(kv.second);
                }

                if (!sig.getEncodeDelegate()->onEncoded(msgId, sig.name(), data, length, rpv, i == pvs.size() - 1))
                {
                    break;
                }
            }
            else
            {
                std::cout << "[WARNING] Failed to encode: " << msgId << ":" << sig.name() << std::endl;

                return false;
            }
        }
        else
        {
            std::cout << "[WARNING] The signal (" << msgId << ":" << kv.first << ") does not exist!" << std::endl;

            return false;
        }

        ++i;
    }

    return true;
}

} // namespace dbcc
} // namespace ad