/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2005,2006 INRIA
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 */
#ifndef BUFFER_H
#define BUFFER_H

#include <stdint.h>
#include <vector>

namespace ns3 {

/**
 * \brief automatically resized byte buffer
 *
 * This represents a buffer of bytes. Its size is
 * automatically adjusted to hold any data prepended
 * or appended by the user. Its implementation is optimized
 * to ensure that the number of buffer resizes is minimized,
 * by creating new Buffers of the maximum size ever used.
 * The correct maximum size is learned at runtime during use by 
 * recording the maximum size of each packet.
 */
class Buffer {
public:
  /**
   * \brief iterator in a Buffer instance
   */
  class Iterator {
  public:
      inline Iterator ();
      /**
       * go forward by one byte
       */
      inline void Next (void);
      /**
       * go backward by one byte
       */
      inline void Prev (void);
      /**
       * \param delta number of bytes to go forward
       */
      inline void Next (uint32_t delta);
      /**
       * \param delta number of bytes to go backward
       */
      inline void Prev (uint32_t delta);
      /**
       * \param o the second iterator
       * \return number of bytes included between the two iterators
       *
       * This method works only if the two iterators point
       * to the same underlying buffer. Debug builds ensure
       * this with an assert.
       */
      inline int32_t GetDistanceFrom (Iterator const &o) const;
      
      /**
       * \return true if this iterator points to the end of the byte array.
       *     false otherwise.
       */
      inline bool IsEnd (void) const;
      /**
       * \return true if this iterator points to the start of the byte array.
       *     false otherwise.
       */
      inline bool IsStart (void) const;

      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by one byte.
       */
      inline void WriteU8 (uint8_t  data);
      /**
       * \param data data to write in buffer
       * \param len number of times data must be written in buffer
       *
       * Write the data in buffer len times and avance the iterator position
       * by len byte.
       */
      inline void WriteU8 (uint8_t data, uint32_t len);
      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by two bytes. The format of the data written in the byte
       * buffer is non-portable. We only ensure that readU16 will
       * return exactly what we wrote with writeU16 if the program
       * is run on the same machine.
       */
      inline void WriteU16 (uint16_t data);
      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by four bytes. The format of the data written in the byte
       * buffer is non-portable. We only ensure that readU32 will
       * return exactly what we wrote with writeU32 if the program
       * is run on the same machine.
       */
      inline void WriteU32 (uint32_t data);
      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by eight bytes. The format of the data written in the byte
       * buffer is non-portable. We only ensure that readU64 will
       * return exactly what we wrote with writeU64 if the program
       * is run on the same machine.
       */
      inline void WriteU64 (uint64_t data);
      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by two bytes. The data is written in network order and the
       * input data is expected to be in host order.
       */
      inline void WriteHtonU16 (uint16_t data);
      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by four bytes. The data is written in network order and the
       * input data is expected to be in host order.
       */
      inline void WriteHtonU32 (uint32_t data);
      /**
       * \param data data to write in buffer
       *
       * Write the data in buffer and avance the iterator position
       * by eight bytes. The data is written in network order and the
       * input data is expected to be in host order.
       */
      inline void WriteHtonU64 (uint64_t data);
      /**
       * \param buffer a byte buffer to copy in the internal buffer.
       * \param size number of bytes to copy.
       *
       * Write the data in buffer and avance the iterator position
       * by size bytes.
       */
      inline void Write (uint8_t const*buffer, uint32_t size);
      /**
       * \param start the start of the data to copy
       * \param end the end of the data to copy
       *
       * Write the data delimited by start and end in internal buffer 
       * and avance the iterator position by the number of bytes
       * copied.
       * The input interators _must_ not point to the same Buffer as
       * we do to avoid overlapping copies. This is enforced 
       * in debug builds by asserts.
       */
      inline void Write (Iterator start, Iterator end);

      /**
       * \return the byte read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       */
      inline uint8_t  ReadU8 (void);
      /**
       * \return the two bytes read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       * The data is read in the format written by writeU16.
       */
      inline uint16_t ReadU16 (void);
      /**
       * \return the four bytes read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       * The data is read in the format written by writeU32.
       */
      inline uint32_t ReadU32 (void);
      /**
       * \return the eight bytes read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       * The data is read in the format written by writeU64.
       */
      inline uint64_t ReadU64 (void);
      /**
       * \return the two bytes read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       * The data is read in network format and return in host format.
       */
      inline uint16_t ReadNtohU16 (void);
      /**
       * \return the four bytes read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       * The data is read in network format and return in host format.
       */
      inline uint32_t ReadNtohU32 (void);
      /**
       * \return the eight bytes read in the buffer.
       *
       * Read data and advance the Iterator by the number of bytes
       * read.
       * The data is read in network format and return in host format.
       */
      inline uint64_t ReadNtohU64 (void);
      /**
       * \param buffer buffer to copy data into
       * \param size number of bytes to copy
       *
       * Copy size bytes of data from the internal buffer to the
       * input buffer and avance the Iterator by the number of
       * bytes read.
       */
      inline void Read (uint8_t *buffer, uint16_t size);
  private:
      friend class Buffer;
      inline Iterator (Buffer const*buffer, uint32_t m_current);
      inline uint32_t GetIndex (uint32_t n);
      uint32_t m_zeroStart;
      uint32_t m_zeroEnd;
      uint32_t m_dataEnd;
      uint32_t m_current;
      uint8_t *m_data;
  };

  /**
   * \return the number of bytes stored in this buffer.
   */
  inline uint32_t GetSize (void) const;

  /**
   * \return a pointer to the start of the internal 
   * byte buffer.
   *
   * The returned pointer points to an area of
   * memory which is ns3::Buffer::GetSize () bytes big.
   * Please, try to never ever use this method. It is really
   * evil and is present only for a few specific uses.
   */
  uint8_t const*PeekData (void) const;

  /**
   * \param start size to reserve
   *
   * Add bytes at the start of the Buffer. The
   * content of these bytes is undefined but debugging
   * builds initialize them to 0x33.
   * Any call to this method invalidates any Iterator
   * pointing to this Buffer.
   */
  void AddAtStart (uint32_t start);
  /**
   * \param end size to reserve
   *
   * Add bytes at the end of the Buffer. The
   * content of these bytes is undefined but debugging
   * builds initialize them to 0x33.
   * Any call to this method invalidates any Iterator
   * pointing to this Buffer.
   */
  void AddAtEnd (uint32_t end);
  /**
   * \param start size to remove
   *
   * Remove bytes at the start of the Buffer.
   * Any call to this method invalidates any Iterator
   * pointing to this Buffer.
   */
  void RemoveAtStart (uint32_t start);
  /**
   * \param end size to remove
   *
   * Remove bytes at the end of the Buffer.
   * Any call to this method invalidates any Iterator
   * pointing to this Buffer.
   */
  void RemoveAtEnd (uint32_t end);

  /**
   * \param start offset from start of packet
   * \param length
   *
   * \return a fragment of size length starting at offset
   * start.
   */
  Buffer CreateFragment (uint32_t start, uint32_t length) const;

  /**
   * \return an Iterator which points to the
   * start of this Buffer.
   */
  inline Buffer::Iterator Begin (void) const;
  /**
   * \return an Iterator which points to the
   * end of this Buffer.
   */
  inline Buffer::Iterator End (void) const;

  Buffer CreateFullCopy (void) const;

  inline Buffer (Buffer const &o);
  inline Buffer &operator = (Buffer const &o);
  inline Buffer ();
  inline Buffer (uint32_t dataSize);
  inline ~Buffer ();
private:
  struct BufferData {
      uint32_t m_count;
      uint32_t m_size;
      uint32_t m_initialStart;
      uint32_t m_dirtyStart;
      uint32_t m_dirtySize;
      uint8_t m_data[1];
  };
  class BufferDataList : public std::vector<struct Buffer::BufferData*>
  {
  public:
    ~BufferDataList ();
  };

  inline uint8_t *GetStart (void) const;
  void TransformIntoRealBuffer (void) const;
  static void Recycle (struct Buffer::BufferData *data);
  static struct Buffer::BufferData *Create (void);
  static struct Buffer::BufferData *Allocate (uint32_t size, uint32_t start);
  static void Deallocate (struct Buffer::BufferData *data);

  static BufferDataList m_freeList;
  static uint32_t m_maxTotalAddStart;
  static uint32_t m_maxTotalAddEnd;

  struct BufferData *m_data;
  uint32_t m_zeroAreaSize;
  uint32_t m_start;
  uint32_t m_size;
};

}; // namespace ns3


/**************************************************
   Start of implementation of methods which 
   need to be inline for performance reasons.
 *************************************************/

#include "ns3/assert.h"

namespace ns3 {

Buffer::Buffer ()
  : m_data (Buffer::Create ()),
    m_zeroAreaSize (0),
    m_start (m_maxTotalAddStart),
    m_size (0)
{
  if (m_start > m_data->m_size) 
    {
      m_start = 0;
    }
  NS_ASSERT (m_start <= m_data->m_size);
}

Buffer::Buffer (uint32_t dataSize)
  : m_data (Buffer::Create ()),
    m_zeroAreaSize (dataSize),
    m_start (m_maxTotalAddStart),
    m_size (0)
{
  if (m_start > m_data->m_size) 
    {
      m_start = 0;
    }
  NS_ASSERT (m_start <= m_data->m_size);
}


Buffer::Buffer (Buffer const&o)
  : m_data (o.m_data),
    m_zeroAreaSize (o.m_zeroAreaSize),
    m_start (o.m_start),
    m_size (o.m_size)
{
  m_data->m_count++;
  NS_ASSERT (m_start <= m_data->m_size);
}

Buffer &
Buffer::operator = (Buffer const&o)
{
  if (m_data != o.m_data) 
    {
      // not assignment to self.
      m_data->m_count--;
      if (m_data->m_count == 0) 
        {
          Recycle (m_data);
        }
      m_data = o.m_data;
      m_data->m_count++;
    }
  m_zeroAreaSize = o.m_zeroAreaSize;
  m_start = o.m_start;
  m_size = o.m_size;
  NS_ASSERT (m_start <= m_data->m_size);
  return *this;
}

Buffer::~Buffer ()
{
  m_data->m_count--;
  if (m_data->m_count == 0) 
    {
      Recycle (m_data);
    }
}


uint8_t *
Buffer::GetStart (void) const
{
  return m_data->m_data + m_start;
}

uint32_t 
Buffer::GetSize (void) const
{
  return m_size + m_zeroAreaSize;
}

Buffer::Iterator 
Buffer::Begin (void) const
{
  return Buffer::Iterator (this, 0);
}
Buffer::Iterator 
Buffer::End (void) const
{
  return Buffer::Iterator (this, GetSize ());
}


Buffer::Iterator::Iterator ()
  : m_zeroStart (0),
    m_zeroEnd (0),
    m_dataEnd (0),
    m_current (0),
    m_data (0)
{}
Buffer::Iterator::Iterator (Buffer const*buffer, uint32_t current)
  : m_zeroStart (buffer->m_data->m_initialStart-buffer->m_start),
    m_zeroEnd (m_zeroStart+buffer->m_zeroAreaSize),
    m_dataEnd (buffer->GetSize ()),
    m_current (current),
    m_data (buffer->m_data->m_data+buffer->m_start)
{}

void 
Buffer::Iterator::Next (void)
{
  NS_ASSERT (m_current + 1 <= m_dataEnd);
  m_current++;
}
void 
Buffer::Iterator::Prev (void)
{
  NS_ASSERT (m_current >= 1);
  m_current--;
}
void 
Buffer::Iterator::Next (uint32_t delta)
{
  NS_ASSERT (m_current + delta <= m_dataEnd);
  m_current += delta;
}
void 
Buffer::Iterator::Prev (uint32_t delta)
{
  NS_ASSERT (m_current >= delta);
  m_current -= delta;
}
int32_t
Buffer::Iterator::GetDistanceFrom (Iterator const &o) const
{
  NS_ASSERT (m_data == o.m_data);
  int32_t start = m_current;
  int32_t end = o.m_current;
  return end - start;
}

bool 
Buffer::Iterator::IsEnd (void) const
{
  return m_current == m_dataEnd;
}
bool 
Buffer::Iterator::IsStart (void) const
{
  return m_current == 0;
}

uint32_t
Buffer::Iterator::GetIndex (uint32_t n)
{
  NS_ASSERT ( 
      (m_current + n <= m_dataEnd) &&
      ((m_current + n <= m_zeroStart) ||
       (m_current >= m_zeroEnd) ||
       m_zeroStart == m_zeroEnd)
      );
  uint32_t index;
  if (m_current < m_zeroStart) 
    {
      index = m_current;
    } 
  else 
    {
      index = m_current - (m_zeroEnd-m_zeroStart);
    }
  return index;
}


void 
Buffer::Iterator::Write (Iterator start, Iterator end)
{
  NS_ASSERT (start.m_data == end.m_data);
  NS_ASSERT (start.m_current <= end.m_current);
  NS_ASSERT (start.m_zeroStart == end.m_zeroStart);
  NS_ASSERT (start.m_zeroEnd == end.m_zeroEnd);
  NS_ASSERT (m_data != start.m_data);
  uint32_t size = end.m_current - start.m_current;
  uint8_t *src = start.m_data + start.GetIndex (size);
  uint8_t *dest = m_data + GetIndex (size);
  memcpy (dest, src, size);
  m_current += size;
}

void 
Buffer::Iterator::WriteU8 (uint8_t  data, uint32_t len)
{
  uint8_t *current = m_data + GetIndex (len);
  memset (current, data, len);
  m_current += len;
}
void 
Buffer::Iterator::WriteU8  (uint8_t  data)
{
  m_data[GetIndex (1)] = data;
  m_current++;
}
void 
Buffer::Iterator::WriteU16 (uint16_t data)
{
  uint16_t *buffer = (uint16_t *)(m_data + GetIndex (2));
  *buffer = data;
  m_current += 2;
}
void 
Buffer::Iterator::WriteU32 (uint32_t data)
{
  uint32_t *buffer = (uint32_t *)(m_data + GetIndex (4));
  *buffer = data;
  m_current += 4;
}
void 
Buffer::Iterator::WriteU64 (uint64_t data)
{
  uint64_t *buffer = (uint64_t *)(m_data + GetIndex (8));
  *buffer = data;
  m_current += 8;
}
void 
Buffer::Iterator::WriteHtonU16 (uint16_t data)
{
  uint8_t *current = m_data + GetIndex (2);
  *(current+0) = (data >> 8) & 0xff;
  *(current+1) = (data >> 0) & 0xff;
  m_current += 2;
}
void 
Buffer::Iterator::WriteHtonU32 (uint32_t data)
{
  uint8_t *current = m_data + GetIndex (4);
  *(current+0) = (data >> 24) & 0xff;
  *(current+1) = (data >> 16) & 0xff;
  *(current+2) = (data >> 8) & 0xff;
  *(current+3) = (data >> 0) & 0xff;
  m_current += 4;
}
void 
Buffer::Iterator::WriteHtonU64 (uint64_t data)
{
  uint8_t *current = m_data + GetIndex (8);
  *(current+0) = (data >> 56) & 0xff;
  *(current+1) = (data >> 48) & 0xff;
  *(current+2) = (data >> 40) & 0xff;
  *(current+3) = (data >> 32) & 0xff;
  *(current+4) = (data >> 24) & 0xff;
  *(current+5) = (data >> 16) & 0xff;
  *(current+6) = (data >> 8) & 0xff;
  *(current+7) = (data >> 0) & 0xff;
  m_current += 8;
}
void 
Buffer::Iterator::Write (uint8_t const*buffer, uint32_t size)
{
  uint8_t *current = m_data + GetIndex (size);
  memcpy (current, buffer, size);
  m_current += size;
}

uint8_t  
Buffer::Iterator::ReadU8 (void)
{
  uint8_t data = m_data[GetIndex(1)];
  m_current++;
  return data;
}
uint16_t 
Buffer::Iterator::ReadU16 (void)
{
  uint16_t *buffer = reinterpret_cast<uint16_t *>(m_data + GetIndex (2));
  m_current += 2;
  return *buffer;
}
uint32_t 
Buffer::Iterator::ReadU32 (void)
{
  uint32_t *buffer = reinterpret_cast<uint32_t *>(m_data + GetIndex (4));
  m_current += 4;
  return *buffer;
}
uint64_t 
Buffer::Iterator::ReadU64 (void)
{
  uint64_t *buffer = reinterpret_cast<uint64_t *>(m_data + GetIndex (8));
  m_current += 8;
  return *buffer;
}
uint16_t 
Buffer::Iterator::ReadNtohU16 (void)
{
  uint8_t *current = m_data + GetIndex (2);
  uint16_t retval = 0;
  retval |= static_cast<uint16_t> (current[0]) << 8;
  retval |= static_cast<uint16_t> (current[1]) << 0;
  m_current += 2;
  return retval;
}
uint32_t 
Buffer::Iterator::ReadNtohU32 (void)
{
  uint8_t *current = m_data + GetIndex (4);
  uint32_t retval = 0;
  retval |= static_cast<uint32_t> (current[0]) << 24;
  retval |= static_cast<uint32_t> (current[1]) << 16;
  retval |= static_cast<uint32_t> (current[2]) << 8;
  retval |= static_cast<uint32_t> (current[3]) << 0;
  m_current += 4;
  return retval;
}
uint64_t 
Buffer::Iterator::ReadNtohU64 (void)
{
  uint8_t *current = m_data + GetIndex (8);
  uint64_t retval = 0;
  retval |= static_cast<uint64_t> (current[0]) << 56;
  retval |= static_cast<uint64_t> (current[1]) << 48;
  retval |= static_cast<uint64_t> (current[2]) << 40;
  retval |= static_cast<uint64_t> (current[3]) << 32;
  retval |= static_cast<uint64_t> (current[4]) << 24;
  retval |= static_cast<uint64_t> (current[5]) << 16;
  retval |= static_cast<uint64_t> (current[6]) << 8;
  retval |= static_cast<uint64_t> (current[7]) << 0;
  m_current += 8;
  return retval;
}
void 
Buffer::Iterator::Read (uint8_t *buffer, uint16_t size)
{
  uint8_t *current = m_data + GetIndex (size);
  memcpy (buffer, current, size);
  m_current += size;
}

}; // namespace ns3


#endif /* BUFFER_H */