#include <QDebug>

#include "Item.h"
#include "EventTools.h"
#include "EventGraphic.h"


#ifdef LTS_DEBUG

#endif


namespace LtsTimelineClassic
{

Item::Item(const QString &name, const QString &identifier)
  : m_name(name)
  , m_identifier(identifier)
  , m_children(nullptr)
  , m_parent(nullptr)
  , m_pevcon(nullptr)
  , m_eventListChanged(true) 
{

}


Item::~Item()
{
  delete m_pevcon;

  if (m_children)
  {
    qDeleteAll(*m_children);
    delete m_children;
  }

  qDeleteAll(m_eventList);
}


PassiveEventContainer *Item::getPevcon()
{
  if (!m_pevcon) 
    m_pevcon = new PassiveEventContainer(m_name == QStringLiteral("Markers")); 

  if (m_eventListChanged)
  {
    m_eventListChanged = false;
    m_pevcon->setEventList(getEventGraphics());
  }

  return m_pevcon;
}


const QString Item::path() const
{
  if (m_parent == nullptr)
    return m_name;

  return QStringLiteral("%1/%2").arg(m_parent->path(), m_name);
}


const QString &Item::getName() const
{
  return m_name;
}


Item *Item::getParent() const
{
  return m_parent;
}


ItemList Item::getFullItemList(bool recursive) const
{
  ItemList il;

  if (m_children == nullptr)
    return il;

  il += *m_children; 

  if (!recursive) 
    return il;

  auto end = m_children->constEnd();
  for (auto i = m_children->constBegin(); i != end; ++i) 
  {
    il += (*i)->getFullItemList(recursive); 
  }

  return il;
}

















const EventGraphicList Item::getCurrentEGLFromPevcon() const 
{
  if (m_pevcon == nullptr)
    return EventGraphicList();
  return m_pevcon->getEventGraphicList();
}


const EventGraphicList Item::getEventGraphics() const 
{
  EventGraphicList egl;
  EventList el = getFullEventList(true, false); 

  std::sort(el.begin(), el.end(), [](const Event *a, const Event *b)
  {
    return a->startTime() < b->startTime();
  });

  for (auto i1 = el.begin(); i1 != el.end(); ++i1)
  {
    Event *e1 = (*i1);

    if (e1->isDeleted())
      continue;

    qint64 egStart = e1->startTime(); 
    qint64 egEnd = egStart + EventTools::getBlockSizeTime(e1->duration()); 
    qint64 blockSizeTime = EventTools::getBlockSizeTime();
    bool egChanged = false;

    EventGraphic *eg = new EventGraphic(e1);
    egl += eg;

    auto i2 = i1 + 1; 
    for (; i2 != el.end(); ++i2)
    {
      if (egChanged)
      {
        egEnd = egStart + eg->getDuration();

        if (egEnd - egStart < blockSizeTime) 
          egEnd = egStart + blockSizeTime;

        egChanged = false;
      }

      Event *e2 = (*i2);

      if (e2->isDeleted())
        continue;

      qint64 start2 = e2->startTime();

      if (start2 >= egStart && egEnd >= start2) 
      {
        eg->addEvent(e2);
        egChanged = true;
      }
      else 
      {
        
        --i2;
        break;
      }
    } 

    if (i2 == el.end()) 
      break;
    i1 = i2; 

  } 

  return egl;
}


EventList Item::getFullEventList(bool recursive, bool getHiddenEvents) const
{
  EventList el;

  if (getHiddenEvents)
  {
    el = m_eventList; 
  }
  else 
  {
    el.reserve(m_eventList.count()); 
    
    for (Event *e : m_eventList)
    {
      if (e == nullptr || !e->isVisible())
        continue;

      el.append(e);
    }
  }

  if (!m_children || !recursive) 
    return el;

  for (const Item *item : qAsConst(*m_children))
    el += item->getFullEventList(recursive, getHiddenEvents);

  return el;
}


void Item::setParent(Item *parent)
{
  m_parent = parent;
}


void Item::addEvent(Event *event) 
{
  m_eventList.append(event);
  setEventListChanged(); 
}


void Item::setEventListChanged()
{
  m_eventListChanged = true;

  if (m_parent != nullptr)
  {
    
    m_parent->setEventListChanged();
  }
}


bool Item::removeEvent(int eventId)
{
  for (auto i = m_eventList.begin(); i != m_eventList.end(); ++i)
  {
    Event *event = *i;

    if (event->uniqueId() == eventId)
    {
      m_eventList.erase(i);
      setEventListChanged();

      return true;
    }
  }

  return false;
}


void Item::addItem(Item *item)
{
  if (!m_children)
    m_children = new ItemList();

  item->setParent(this); 
  m_children->append(item);
}


bool Item::hasVisibleEvents() const
{
  
  if (!m_eventList.isEmpty() &&
      std::find_if(m_eventList.constBegin(), m_eventList.constEnd(), [](Event *e) { return e->isVisible(); }) != m_eventList.constEnd())
    return true;

  
  if (m_children == nullptr)
    return false;

  

  for (auto i = m_children->constBegin(); i != m_children->constEnd(); ++i)
  {
    Item *item = *i;

    if (item->hasVisibleEvents())
      return true;
  }

  
  return false;
}


Item *Item::child(int row) const
{
  if (m_children == nullptr)
    return nullptr;

  int idx = 0;

  
  for (auto i = m_children->constBegin(); i != m_children->constEnd(); ++i)
  {
    Item *item = *i;

    if (item->hasVisibleEvents())
    {
      if (row == idx)
        return item;
      else
        idx++;
    }
  }

  return nullptr;
}


int Item::childCount() const
{
  if (m_children)
    return m_children->count();

  return 0;
}


int Item::visibleChildCount() const
{
  if (m_children == nullptr)
    return 0;

  int result = 0;

  for (auto i = m_children->constBegin(); i != m_children->constEnd(); ++i)
  {
    Item *item = *i;

    if (item->hasVisibleEvents())
      result++;
  }

  return result;
}


ItemList *Item::getChildren()
{
  return m_children; 
}


int Item::indexOfParent() const
{
  if (m_parent == nullptr || m_parent->getChildren() == nullptr)
    return -1;

  int idx = 0;

  ItemList *parentItemList = m_parent->getChildren();

  
  for (auto i = parentItemList->constBegin(); i != parentItemList->constEnd(); ++i)
  {
    Item *item = *i;

    if (item == this)
      return idx;

    idx++;
  }

  Q_ASSERT(false);
  return -1;
}

}