#include "tag-list.h"

namespace ns3 {

TagList::Iterator::Item::Item (TagBuffer buf_)
    : buf (buf_)
{}

bool 
TagList::Iterator::HasNext (void) const
{
  return m_current < m_end;
}
struct TagList::Iterator::Item 
TagList::Iterator::Next (void)
{
  NS_ASSERT (HasNext ());
  struct Item item = Item (TagBuffer (m_current, m_end));
  item.tid.SetUid (item.buf.ReadU32 ());
  item.size = item.buf.ReadU32 ();
  item.start = item.buf.ReadU32 ();
  item.end = item.buf.ReadU32 ();
  item.start = std::max (item.start, m_offsetStart);
  item.end = std::min (item.end, m_offsetEnd);
  m_current += 4 + 4 + 4 + 4 + item.size;
  item.buf.TrimAtEnd (m_end - m_current);
  PrepareForNext ();
  return item;
}
void
TagList::Iterator::PrepareForNext (void)
{
  while (m_current < m_end)
    {
      struct Item item = Item (TagBuffer (m_current, m_end));
      item.tid.SetUid (item.buf.ReadU32 ());
      item.size = item.buf.ReadU32 ();
      item.start = item.buf.ReadU32 ();
      item.end = item.buf.ReadU32 ();
      if (item.start > m_offsetEnd || item.end < m_offsetStart)
	{
	  m_current += 4 + 4 + 4 + 4 + item.size;
	}
      else
	{
	  break;
	}
    }
}
TagList::Iterator::Iterator (uint8_t *start, uint8_t *end, uint32_t offsetStart, uint32_t offsetEnd)
  : m_current (start),
    m_end (end),
    m_offsetStart (offsetStart),
    m_offsetEnd (offsetEnd)
{
  PrepareForNext ();
}

uint32_t 
TagList::Iterator::GetOffsetStart (void) const
{
  return m_offsetStart;
}


TagList::TagList ()
  : m_buffer (0),
    m_size (0)
{}
TagList::TagList (const TagList &o)
  : m_size (o.m_size)
{
  m_buffer = new uint8_t [o.m_size] ();
  memcpy (m_buffer, o.m_buffer, o.m_size);
}
TagList &
TagList::operator = (const TagList &o)
{
  delete [] m_buffer;
  m_buffer = new uint8_t [o.m_size] ();
  memcpy (m_buffer, o.m_buffer, m_size);
  m_size = o.m_size;
  return *this;
}
TagList::~TagList ()
{
  delete [] m_buffer;
  m_buffer = 0;
  m_size = 0;
}

TagBuffer
TagList::Add (TypeId tid, uint32_t bufferSize, uint32_t start, uint32_t end)
{
  uint32_t newSize = m_size + bufferSize + 4 + 4 + 4 + 4;
  uint8_t *newBuffer = new uint8_t [newSize] ();
  memcpy (newBuffer, m_buffer, m_size);
  TagBuffer tag = TagBuffer (newBuffer + m_size, newBuffer + newSize);
  tag.WriteU32 (tid.GetUid ());
  tag.WriteU32 (bufferSize);
  tag.WriteU32 (start);
  tag.WriteU32 (end);
  delete [] m_buffer;
  m_buffer = newBuffer;
  m_size = newSize;
  return tag;
}

void 
TagList::Add (const TagList &o)
{
  TagList::Iterator i = o.Begin (0, 0xffffffff);
  while (i.HasNext ())
    {
      TagList::Iterator::Item item = i.Next ();
      TagBuffer buf = Add (item.tid, item.size, item.start, item.end);
      buf.CopyFrom (item.buf);
    }
}

void 
TagList::Remove (const Iterator &i)
{
  // XXX: more complex to implement.
}

void 
TagList::RemoveAll (void)
{
  delete [] m_buffer;
  m_buffer = 0;
  m_size = 0;  
}

TagList::Iterator 
TagList::Begin (uint32_t offsetStart, uint32_t offsetEnd) const
{
  return Iterator (m_buffer, m_buffer + m_size, offsetStart, offsetEnd);
}

bool 
TagList::IsDirtyAtEnd (uint32_t appendOffset)
{
  TagList::Iterator i = Begin (0, 0xffffffff);
  while (i.HasNext ())
    {
      TagList::Iterator::Item item = i.Next ();
      if (item.end > appendOffset)
	{
	  return true;
	}
    }
  return false;
}

bool 
TagList::IsDirtyAtStart (uint32_t prependOffset)
{
  TagList::Iterator i = Begin (0, 0xffffffff);
  while (i.HasNext ())
    {
      TagList::Iterator::Item item = i.Next ();
      if (item.start < prependOffset)
	{
	  return true;
	}
    }
  return false;
}

void 
TagList::AddAtEnd (int32_t adjustment, uint32_t appendOffset)
{
  if (adjustment == 0 && !IsDirtyAtEnd (appendOffset))
    {
      return;
    }
  TagList list;
  TagList::Iterator i = Begin (0, 0xffffffff);
  while (i.HasNext ())
    {
      TagList::Iterator::Item item = i.Next ();
      item.start += adjustment;
      item.end += adjustment;

      if (item.start > appendOffset)
	{
	  continue;
	}
      else if (item.start < appendOffset && item.end > appendOffset)
	{
	  item.end = appendOffset;
	}
      else
	{
	  // nothing to do.
	}
      TagBuffer buf = list.Add (item.tid, item.size, item.start, item.end);
      buf.CopyFrom (item.buf);
    }
  *this = list;  
}

void 
TagList::AddAtStart (int32_t adjustment, uint32_t prependOffset)
{
  if (adjustment == 0 && !IsDirtyAtStart (prependOffset))
    {
      return;
    }
  TagList list;
  TagList::Iterator i = Begin (0, 0xffffffff);
  while (i.HasNext ())
    {
      TagList::Iterator::Item item = i.Next ();
      item.start += adjustment;
      item.end += adjustment;

      if (item.end < prependOffset)
	{
	  continue;
	}
      else if (item.end > prependOffset && item.start < prependOffset)
	{
	  item.start = prependOffset;
	}
      else
	{
	  // nothing to do.
	}
      TagBuffer buf = list.Add (item.tid, item.size, item.start, item.end);
      buf.CopyFrom (item.buf);
    }
  *this = list;    
}

} // namespace ns3