/*
  pdu.cpp

  Copyright (c) 2020 Kevin Matz (kevin.matz@gmail.com)

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/

#include "pdu.h"

#include <cmath>

namespace ACN {
namespace PDU {

/**
 * @brief Pdu::Pdu
 * @param vector_size
 */
Pdu::Pdu(size_t vector_size)
  : vector_size_(vector_size)
{
}


/**
 * @brief Pdu::~Pdu
 */
Pdu::~Pdu()
{
  if (header_) delete header_;
  if (data_) delete data_;
}


/**
 * @brief Pdu::vector
 * @return
 */
uint32_t Pdu::vector()
{
  if (flags_.hasVector)
    return vector_;
  if (inherit_)
    return inherit_->vector();
  return 0;
}


/**
 * @brief Pdu::header
 * @return
 */
pdu_header * Pdu::header()
{
  if (flags_.hasHeader)
    return header_;
  if (inherit_)
    return inherit_->header();
  return nullptr;
}


/**
 * @brief Pdu::data
 * @return
 */
pdu_data * Pdu::data()
{
  if (flags_.hasData)
    return data_;
  if (inherit_)
    return inherit_->data();
  return nullptr;
}


/**
 * @brief Pdu::parent
 * @return
 */
Message<Pdu> Pdu::parent()
{
  return parent_;
}


/**
 * @brief Pdu::stream
 * @return
 */
Stream Pdu::stream()
{
  return stream_;
}


/**
 * @brief Pdu::streamSize
 * @return
 *
 * The maximum buffer size that could be required to buffer this PDU
 */
size_t Pdu::streamSize() const
{
  size_t s = 2; // flength is at least 2 octets

  // plus the length of the vector
  if (flags_.hasVector) {
      if (inherit_) {
          if (vector_ != inherit_->vector())
            s += vector_size_;
        } else {
          s += vector_size_;
        }
    }

  // plus the length of the header
  if (header_) {
      if (inherit_) {
          if (header_ != inherit_->header())
            s += header_->streamSize();
        } else {
          s += header_->streamSize();
        }
    }

  // plus the lenth of the data
  if (data_) {
      if (inherit_) {
          if (data_ != inherit_->data())
            s += data_->streamSize();
        } else {
          s += data_->streamSize();
        }
    }

  // and another bit if the length needs it
  if (s > 0x0fff)
    s++;
  return s;
}


/**
 * @brief Pdu::iStream
 * @param stream
 */
void Pdu::iStream(Stream stream)
{
  // get the flags
  flags_.set(stream->peek());

  // get the length
  size_t length;
  length = stream->readType<uint16_t>() & 0x0fff; // high 4 bits are flags
  if (flags_.hasLength)
    length = (length << 8 ) | stream->readType<uint8_t>();

  // get the vector
  if (flags_.hasVector)
    switch (vector_size_) {
      case 1:
        vector_ = stream->readType<uint8_t>();
        break;
      case 2:
        vector_ = stream->readType<uint16_t>();
        break;
      case 4:
        vector_ = stream->readType<uint32_t>();
        break;
      default:
        stream->setstate(std::ios_base::failbit);
        return;
      }

  // length includes the flags, length, and vector.
  // the remainder of the length of header and data
  uint hd_length = length - (flags_.hasLength ? 3 : 2) - vector_size_;

  // abort if the remaining PDU length isn't available
  if (!stream->good() || stream->available() < hd_length)
      return stream->setstate(std::ios_base::failbit);

  // create a stream buffer for the header and data
  stream_ = Stream(new pdu_stream(stream->data(), hd_length));
  if (stream_->available() != hd_length)
      return stream->setstate(std::ios_base::failbit);

  // fast-forward the input stream
  stream->ignore(hd_length);

  if (!stream->available())
    return stream->setstate(std::ios_base::eofbit);
}


/**
 * @brief Pdu::oStream
 * @param stream
 */
void Pdu::oStream(Stream stream) const
{
  pdu_flags flags = flags_;
  size_t length = streamSize();

  // check if length flag need to be set
  if (length > 0x0fff)
    flags.hasLength = true;

  // see if we can inherit members
  if (inherit_) {
      if (flags.hasVector)
        if (vector_ == inherit_->vector())
          flags.hasVector = false;
      if (flags.hasHeader)
        if (header_ == inherit_->header())
          flags.hasHeader = false;
      if (flags.hasData)
        if (data_ == inherit_->data())
          flags.hasData = false;
    }

  // inject flags onto the high 4 bits of the length
  auto flength = reinterpret_cast<uint8_t*>(length);
  if (flags.hasLength)
    flength[2] = (flength[2] & 0x0f) | (uint8_t)flags;
  else
    flength[1] = (flength[1] & 0x0f) | (uint8_t)flags;

  // write the flength to stream
  stream->write(flength, (flags.hasLength ? 3 : 2));

  // write the vector to stream
  if (flags.hasVector)
    switch (vector_size_) {
      case 1:
        stream->writeType<uint8_t>(vector_);
        break;
      case 2:
        stream->writeType<uint16_t>(vector_);
        break;
      case 4:
        stream->writeType<uint32_t>(vector_);
        break;
      default:
        stream->setstate(std::ios_base::failbit);
        return;
      }

  // write the header to stream
  if (flags.hasHeader)
    header_->oStream(stream);

  // write the data to steam
  if (flags.hasData)
    data_->oStream(stream);
}


/**
 * @brief Pdu::setVector
 * @param v
 */
void Pdu::setVector (const uint32_t v)
{
  vector_ = v; flags_.hasVector = true;
}


/**
 * @brief Pdu::setHeader
 * @param h
 */
void Pdu::setHeader (pdu_header * h)
{
  header_ = h; flags_.hasHeader = true;
}


/**
 * @brief Pdu::setData
 * @param d
 */
void Pdu::setData   (pdu_data * d)
{
  data_   = d; flags_.hasData   = true;
}


/**
 * @brief Pdu::setParent
 * @param pdu
 */
void Pdu::setParent (Message<Pdu> pdu)
{
  parent_ = pdu;
}


/**
 * @brief Pdu::setInherit
 * @param pdu
 */
void Pdu::setInherit(Message<Pdu> pdu)
{
  inherit_ = pdu;
}



/**
 * @brief pdu_flags::set
 * @param val
 */
void pdu_flags::set(const uint8_t val)
{
  hasLength = (val >> 7) & 0b1;
  hasVector = (val >> 6) & 0b1;
  hasHeader = (val >> 5) & 0b1;
  hasData   = (val >> 4) & 0b1;
};

} // PDU
} // ACN
