/*
 * File:   TransferContainer.cc
 * Author: jgaebler
 *
 * Created on May 10, 2012, 10:44 AM
 */

#include "TransferContainer.h"

#include "mt/msg/MulticastMessage.h"
#include "serializer_byte_array.h"

namespace ubeeme {
    namespace moversight {

        /**
         * @brief Constructor
         */
        TransferContainer::TransferContainer(): id(UNDEFINED_PEER_ID){
        }

        /**
         * @brief Constructor.
         * @param i The id of the transfering peer
         * @param l The list of messages to transfer
         */
        TransferContainer::TransferContainer(PeerID i, const TransferList & l):id(i), list(l){
        }

        /**
         * @brief Copy constructor
         * @param orig The object to copy
         */
        TransferContainer::TransferContainer(const TransferContainer& orig):id(orig.id), list(orig.list) {
        }

        /**
         * @brief Destructor
         */
        TransferContainer::~TransferContainer(){
        }

        /**
         * @brief Gets the id of the transfering peer
         * @return the id of the transfering peer.
         */
        const PeerID & TransferContainer::getPeerID(){
            return id;
        }

        /**
         * @brief Sets the peer ID of the transfer container
         * @param i The ID to set
         */
        void TransferContainer::setPeerID(PeerID i){
            id = i;
        }


        /**
         * @brief Gets the list of TransferMessages
         * @return the list of TransferMessages
         */
        TransferList TransferContainer::getTransferList(){
            return list;
        }


        /**
         * @brief Sets the transfer list
         * @param tl The list to set
         */
        void
        TransferContainer::setTransferList(TransferList & tl){
            list = tl;
        }

        /**
         * @brief Serialize the message into an array of bytes.
         * @param serializer The serilization destination
         * @return True, in case of success, FALSE otherwise
         */
        bool
        TransferContainer::serialize(SerializerByteArray & serializer) {

            //the id of the storing peer
            serializer<<id;
            //the the number of stored messages
            size_t listSize = list.size();
            serializer << listSize;

            //serialize the messages
            for(size_t i=0; i<list.size(); i++){

                TransferMessage msg = list.get(i);
                ByteArray serializedMsg;
                bool retVal = msg.serialize(serializedMsg);

                if(retVal != true){
                    return false;
                }

                //append the message
                serializer<<serializedMsg;

            }//end for

            return ! serializer.failed();

        }


        /**
         * @brief Deserializes the message from the given char buffer.
         * @param buffer Buffer to deserialize from.
         * @param size Size of buffer to deserialize from.
         * @param checkSize If true the deserialization compares the deserialized size and buffer size.
         * @return True if serialization was successful. False if the given buffer was to small or is not exactly the same size as the serialized message.
         * @note The buffer has to point to the payload of the network message.
         * @note Derived from GenericMessage
         * @see GenericMessage::deserialize in ubeeme/core/network
         */
        bool
        TransferContainer::deserialize(byte const * buffer, int size, bool /* checkSize */) {

#if OMNETPP
            ByteArray array(buffer, buffer+size);
#else
            ByteArray array(buffer, size);
#endif
            SerializerByteArray serializer(array);

            serializer >> id;

            size_t msgCnt;
            serializer>>msgCnt;

            for(size_t i=0; i< msgCnt; i++){

                ByteArray serializedMsg;
                serializer >> serializedMsg;

                //extract the message
                TransferMessage msg;
                bool retVal = msg.deserialize(serializedMsg.data(), serializedMsg.size());

                if(retVal != true){
                    return false;
                }//End if

                list.add(msg);

            }//end for

            return ! serializer.failed();

        }
    }
}