#include "CANSignal.h"
#include "defines.h"
#include <QtEndian>


CCANSignal::CCANSignal():
    mRawValue(0),
    mPhysicalValue(0.0)
{
    mEncoding = CAN_SIGNAL_ENCODING_INVALID;

}

int CCANSignal::ComputeNewSignalValue(quint64 NewValue, quint16 MessageSize)
{
    if(mEncoding == CAN_SIGNAL_ENCODING_INTEL)
    {

        mRawValue = qFromBigEndian(NewValue);
//        mRawValue = NewValue;
        mRawValue >>= mStartBit;
        quint64 mask = 1;
        mask <<= mSignalSize;
        mask -= 1;
        mRawValue &= mask;

    }
    else if(mEncoding == CAN_SIGNAL_ENCODING_MOTOROLA)
    {
        mRawValue = NewValue;
        int StartIndex = mStartBit - (mStartBit % 8) + 7 - (mStartBit % 8);
        int shift = ((MessageSize * 8) - StartIndex -1);
        mRawValue >>= shift;
        quint64 mask = 1;
        mask <<= mSignalSize;
        mask -= 1;
        mRawValue &= mask;
    }
    else
    {
        //TODO: À faire!!!
        return RET_GENERAL_ERROR;
    }


    //JFM 2023-06-13 - Ajout casting des variables en fonction du data size.
    //L'idée c'est de contenir la valeur physique dans un double, ce qui permet de ne pas avoir à gérer le type
    //à chaque fois qu'on accède à la donnée.  Mais pour que ça marche, il faut initialiser ce double comme il faut
    //en castant en fonction de la taille et du signe de la donnée
    qint64 SignedRawValue = 0;
    if(mSignalSize <= 8)
    {
        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
        {
            SignedRawValue = (double)((qint8)mRawValue);
        }
        else
        {
            SignedRawValue = (double)((quint8)mRawValue);
        }

    }
    else if(mSignalSize <= 16)
    {
        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
        {
            SignedRawValue = (double)((qint16)mRawValue);
        }
        else
        {
            SignedRawValue = (double)((quint16)mRawValue);
        }
//        qint16 RawShort = (qint16)mRawValue;
//        SignedRawValue = (double)RawShort;
    }
    else if(mSignalSize <= 32)
    {
        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
        {
            SignedRawValue = (double)((qint32)mRawValue);
        }
        else
        {
            SignedRawValue = (double)((quint32)mRawValue);
        }
        //SignedRawValue = (signed)mRawValue;
    }
    else
    {
        if(mValueType == CAN_SIGNAL_TYPE_SIGNED_INT)
        {
            SignedRawValue = (double)((signed)mRawValue);
        }
        else
        {
            SignedRawValue = (double)(mRawValue);
        }
    }
    mPhysicalValue = (double)SignedRawValue;
    mPhysicalValue *= mValueFactor;
    mPhysicalValue += mValueOffset;

    //JFM 2023-06-13 tentative de corriger le casting avec la vraie patente
    //mPhysicalValue = ((signed) mRawValue * mValueFactor) + mValueOffset;



    return RET_OK;

}

CCANSignal& CCANSignal::operator=(const CCANSignal &source)
{
    if(&source == this)
    {
        return *this;
    }
    qDebug("CANSignal Equal operator");
    this->mSignalName = source.mSignalName;
    this->mSignalComment = source.mSignalComment;
    this->mEncoding = source.mEncoding;
    this->mMultiplexing = source. mMultiplexing;
    this->mStartBit = source. mStartBit;
    this->mSignalSize = source. mSignalSize;
    this->mValueType = source. mValueType;
    this->mValueFactor = source.mValueFactor;
    this->mValueOffset = source. mValueOffset;
    this->mMinValue = source.mMinValue;
    this->mMaxValue = source.mMaxValue;
    this->mSignalUnit = source.mSignalUnit;

    return *this;
}