#include "stdafx.h"

#include "common.h"

#include "sabbu.h"

#include "gui_event_list.h"

extern struct sabbu app;

/*
 * Adds an event to the Event Tree and calculates collisions for this event.
 */
void gui_event_tree_add_event(kryEventDetailed *event)
{
  if(event->GetType() != kryEvent::EVENT_DIALOG)
    return;

  kry_region_fixed_list_add(app.ui.region_list, event->GetStart(), event->GetEnd());

  if(app.opts.disable_collisions)
    return;

  /* first we check if there are any events that are equal to this one (start at the same time),
     if so they are put in the same node, if not the event is inserted as a new node */
/*  kryEventDetailed *line = NULL;
  struct event_node_data *event_node_data = new struct event_node_data;
  event_node_data->events = g_list_append(NULL, event);

  if(!this->m_tree_events)
    this->m_tree_events = pavl_create(kryScript::EventNodeCompare, NULL, NULL);*/

  /* we only track collisions for dialog events so bail out */
  /*if(event->GetType() != kryEvent::EVENT_DIALOG)
  {
    g_list_free(event_node_data->events);
    delete event_node_data;
    return;
  }

  struct event_node_data *rv = (struct event_node_data *) pavl_find(this->m_tree_events, event_node_data);
  if(rv)
    rv->events = g_list_append(rv->events, event);
  else
    pavl_insert(this->m_tree_events, event_node_data);


  kryList<kryEventDetailed *> just_added;

  struct pavl_traverser trav, trav2;
  pavl_t_find(&trav, this->m_tree_events, event_node_data);
  pavl_t_copy(&trav2, &trav);
  if(!pavl_t_cur(&trav))
    g_warning("failed to find...");*/

  /* There are three cases when checking for conditions.
     The event right before this one overlaps the current one.
     The current event overlaps the next event (or more than one event).
     The current event is overlapped by some previous event. 
     If we check all three we can be sure of whether or not there is a collision.
     */

  /*
   * First we check if the line right before (chronologically) overlaps the current line.
   * If so we must add both of the lines into the collision list.
   */
  /*if(pavl_t_prev(&trav) != NULL)
  {
    line = (kryEventDetailed *) (((struct event_node_data *) pavl_t_cur(&trav))->events->data);
    if(line && line->GetEnd() > event->GetStart() && line->GetLayer() == event->GetLayer())
    {
      line->SetCollisionJustAdded(TRUE);
      just_added.Append(line);

      line->IncreaseCollisionCount();
      if(!line->GetCollisionAdded())
      {
        this->m_collisions.Append(line);
        this->InvokeSignal(kryScript::SIGNAL_COLLISION, (void *) line->GetIndex());
        line->SetCollisionAdded(TRUE);
      }

      event->IncreaseCollisionCount();
      if(!event->GetCollisionAdded())
      {
        this->InvokeSignal(kryScript::SIGNAL_COLLISION, (void *) event->GetIndex());
        this->m_collisions.Append(event);
        event->SetCollisionAdded(TRUE);
      }
    }
    line = NULL;
  }*/
   
  /*
   * Next we check the lines after (chronologically) to see if the current lines overlaps them.
   * We continue checking until we encounter an event that the current event does not overlap.
   */
  /*while(pavl_t_next(&trav2))
  {
    line = (kryEventDetailed *) (((struct event_node_data *) pavl_t_cur(&trav2))->events->data);
    if(line && line->GetStart() < event->GetEnd() && line->GetLayer() == event->GetLayer())
    {
      line->SetCollisionJustAdded(TRUE);
      just_added.Append(line);

      line->IncreaseCollisionCount();
      if(!line->GetCollisionAdded())
      {
        this->InvokeSignal(kryScript::SIGNAL_COLLISION, (void *) line->GetIndex());
        this->m_collisions.Append(line);
        line->SetCollisionAdded(TRUE);
      }

      event->IncreaseCollisionCount();
      if(!event->GetCollisionAdded())
      {
        this->InvokeSignal(kryScript::SIGNAL_COLLISION, (void *) event->GetIndex());
        this->m_collisions.Append(event);
        event->SetCollisionAdded(TRUE);
      }
    }
    else
    {
      break;
    }
  }*/

  /*
   * Lastly we check the list of all the collisions in the script to see if any of the events
   * overlaps this one. */
  /*{
    kryList<kryEventDetailed *> add_list;
    kryListIterator<kryEventDetailed *> iter;
    kryEventDetailed *line;
    this->m_collisions.GetIterator(&iter);
    while((line = iter.GetNext()))
    {
      kryEventDetailed *line = iter.GetData();
      if(line->GetStart() < event->GetStart() && line->GetEnd() > event->GetStart() && line->GetLayer() == event->GetLayer())
      {
        if(!line->GetCollisionJustAdded())
        {
          line->IncreaseCollisionCount();
          event->IncreaseCollisionCount();
        }

        if(!event->GetCollisionAdded())
        {
          this->InvokeSignal(kryScript::SIGNAL_COLLISION, (void *) event->GetIndex());
          add_list.Append(event);
          event->SetCollisionAdded(TRUE);
        }
      }
    }

    add_list.GetIterator(&iter);
    while((line = iter.GetNext()))
      this->m_collisions.Append(line);
  }


  kryListIterator<kryEventDetailed *> iter;
  just_added.GetIterator(&iter);
  while((line = iter.GetNext()))
    line->SetCollisionJustAdded(FALSE);

  if(rv)
  {
    g_list_free(event_node_data->events);
    delete event_node_data;
  }*/
}

/*
 * Removes the event from the Event Tree and fixes the collision list.
 */
void gui_event_tree_remove_event(kryEventDetailed *event)
{
  kry_region_fixed_list_remove(app.ui.region_list, event->GetStart(), event->GetEnd());

/*  if(this->m_disable_collisions)
    return;

  struct event_node_data *event_node_data = new struct event_node_data;
  event_node_data->events = g_list_append(NULL, event);

  struct event_node_data *rv = (struct event_node_data *) pavl_find(this->m_tree_events, event_node_data);
  if(!rv)
  {
    g_warning("collision data for event '%s' was not found. Collision display may not be correct", event->GetText());
    g_list_free(event_node_data->events);
    delete event_node_data;
    return;
  }
  
  g_list_free(event_node_data->events);
  delete event_node_data;*/

  /* first we remove the event from the tree */
  /*for(GList *ptr = rv->events; ptr; ptr=ptr->next)
  {
    kryEvent *event_sub = (kryEvent *) ptr->data;
    if(event_sub == event)
    {
      kryEvent *line = (kryEvent *) ptr->data;
      rv->events = g_list_remove(rv->events, line);
      if(rv->events == NULL)
      {*/
        /* the node comparison function uses the events to match nodes, so we must temporarily
           put it back */
        /*rv->events = g_list_append(rv->events, line);
        if(!pavl_delete(this->m_tree_events, rv))
          g_warning("failed to delete from pavl tree");
      }

      break;
    }
  }

  kryListIterator <kryEventDetailed *> iter;
  kryEventDetailed *line;

  if(event->GetCollisionCount())
  {
    this->GetCollisionIterator(&iter);*/

    /* we look for events that this event overlapped and update their collision status appropriately */
    /*while((line = iter.GetNext()))
    {
      if(line->GetStart() < event->GetStart() && line->GetEnd() > event->GetStart()
        || line->GetStart() > event->GetStart() && line->GetStart() < event->GetEnd())
      {
        line->DecreaseCollisionCount();
        event->DecreaseCollisionCount();

        if(line->GetCollisionCount() == 0)
        {
          gui_event_list_set_row_color(app.ui.event_list, line->GetIndex(), LIST_COLOR_NONE);
          if(line->GetCollisionAdded())
          {
            iter.Remove();
            line->SetCollisionAdded(FALSE);
          }

          line->SetCollisionHighlighted(FALSE);
        }
      }
    }

    gui_event_list_set_row_color(app.ui.event_list, event->GetIndex(), LIST_COLOR_NONE);
    if(event->GetCollisionAdded())
    {
      this->m_collisions.Remove(event);
      event->SetCollisionAdded(FALSE);
    }

    event->SetCollisionHighlighted(FALSE);

    if(event->GetCollisionCount() != 0)
    {
      g_warning("collision count is not correct (%d) (should be 0).", event->GetCollisionCount());
    }
  }*/

}

void gui_event_tree_fill_from_script()
{
  kry_waveform_group_disable_draw(app.ui.waveform_group);
  kryListIterator<kryEventDetailed *> iter;

  app.script->GetEventIterator(&iter);
  while(kryEventDetailed *event = iter.GetNext())
    gui_event_tree_add_event(event);

  kry_waveform_group_enable_draw(app.ui.waveform_group);
}

void gui_event_tree_remove_all()
{
  kryListIterator<kryEventDetailed *> iter;
  app.script->GetEventIterator(&iter);
  while(kryEventDetailed *event = iter.GetNext())
  {
    if(event->GetCollisionCount())
    {
      event->SetCollisionCount(0);
      event->SetCollisionAdded(FALSE);
      event->SetCollisionHighlighted(FALSE);
      gui_event_list_set_row_color(app.ui.event_list, event->GetIndex(), LIST_COLOR_NONE);
    }
  }

  /*if(this->m_tree_events)
    pavl_destroy(this->m_tree_events, (pavl_item_func*) kryScript::EventNodeFree);

  this->m_tree_events = NULL;
  this->m_collisions.Clear();*/
}