/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

#include <map>

#include <goocanvas.h>

#include <glib/gthread.h>

#include "mobility-visualizer.h"

#include <map>

#include "ns3/simulator.h"

#define MAX_QUEUE_LENGTH 100

#define MAX_EVENTS 20

#define LOOKAHEAD_SECONDS 10

GtkWidget *g_canvas;

int model_init (int argc, char *argv[]);

struct Node

{

  GooCanvasItem *m_item;

  GooCanvasItem *m_vector;

  void create ()

  {

    GooCanvasItem *root = goo_canvas_get_root_item (GOO_CANVAS (g_canvas));

    m_item = goo_canvas_ellipse_new (root, 0, 0, 2.0, 2.0,

                                     "line_width", 0.5,

                                     "stroke_color", "black",

                                     "fill_color", "red",

                                     NULL);

    m_vector = goo_canvas_polyline_new (root, FALSE, 0,

                                        "line_width", 0.3,

                                        "stroke_color", "black",

                                        "end-arrow", TRUE,

                                        "arrow-length", 10.0,

                                        "arrow-width", 10.0,

                                        NULL);

  }

  void update (double x, double y, double vx, double vy)

  {

    g_object_set (m_item, "center_x", x, "center_y", y, NULL);

    if (vx == 0 && vy == 0)

      {

        GooCanvasPoints *points = goo_canvas_points_new (0);

        g_object_set (m_vector, "points", points, NULL);

        goo_canvas_points_unref (points);

      }

    else

      {

        GooCanvasPoints *points = goo_canvas_points_new (2);

        points->coords[0] = x;

        points->coords[1] = y;

        points->coords[2] = x + vx;

        points->coords[3] = y + vy;

        g_object_set (m_vector, "points", points, NULL);

        goo_canvas_points_unref (points);

      }

  }

};

std::map<void*, Node> g_nodes;

GTimeVal initialTime = {-1, -1};

gboolean firstTime = TRUE;

double g_lookaheadTime = 0;

GStaticMutex g_lookaheadTimeMux = G_STATIC_MUTEX_INIT;

ViewUpdateData *g_nextData = NULL;

GAsyncQueue *queue;

#define TIME_SCALE 1

double get_current_time ()

{

  GTimeVal currTime;

  g_get_current_time (&currTime);

  GTimeVal relativeTime;

  relativeTime.tv_sec = currTime.tv_sec - initialTime.tv_sec + LOOKAHEAD_SECONDS;

  relativeTime.tv_usec = currTime.tv_usec;

  g_time_val_add (&relativeTime, -initialTime.tv_usec);

  return (relativeTime.tv_sec + 1.0e-6*relativeTime.tv_usec)*TIME_SCALE;

}

// called from the simulation thread

void view_update (ViewUpdateData *updateData)

{

  while ((g_static_mutex_lock (&g_lookaheadTimeMux), g_lookaheadTime) != 0 and updateData->time >= g_lookaheadTime)

    {

      g_static_mutex_unlock (&g_lookaheadTimeMux);

      g_usleep ((gulong) 10e3);

    }

  g_static_mutex_unlock (&g_lookaheadTimeMux);

  g_async_queue_push (queue, updateData);

}

void view_update_process (ViewUpdateData *updateData)

{

  for (std::vector<NodeUpdate>::const_iterator update

         = updateData->updateList.begin ();

       update != updateData->updateList.end ();

       update++)

    {

      if (g_nodes.find (update->node) == g_nodes.end ())

        {

          g_nodes[update->node].create ();

        }

      g_nodes[update->node].update (update->x, update->y, update->vx, update->vy);

    }

  delete updateData;

}

gboolean view_update_consumer ()

{

  if (firstTime)

    {

      firstTime = FALSE;

      g_get_current_time (&initialTime);

    }

  double now = get_current_time ();

  g_static_mutex_lock (&g_lookaheadTimeMux);

  g_lookaheadTime = now + LOOKAHEAD_SECONDS;

  g_static_mutex_unlock (&g_lookaheadTimeMux);

  if (!g_nextData)

    g_nextData = (ViewUpdateData *) g_async_queue_try_pop (queue);

  if (!g_nextData)

    return TRUE;

  if (g_nextData->time > now)

    return TRUE;

  do

    {

      view_update_process (g_nextData);

      g_nextData = (ViewUpdateData *) g_async_queue_try_pop (queue);

    }

  while (g_nextData && g_nextData->time <= now);

  return TRUE;

}

void zoom_changed (GtkAdjustment *adj)

{

  goo_canvas_set_scale (GOO_CANVAS (g_canvas), gtk_adjustment_get_value (adj));

}

int main (int argc, char *argv[])

{

  g_thread_init (NULL);

  gtk_init (&argc, &argv);

  double x1 = 0, y1 = 0, x2 = 0, y2 = 0;

  model_init (argc, argv, &x1, &y1, &x2, &y2);

  GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_window_set_default_size (GTK_WINDOW (window), 640, 600);

  gtk_widget_show (window);

  g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);

  GtkWidget *scrolled_win = gtk_scrolled_window_new (NULL, NULL);

  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_win), GTK_SHADOW_IN);

  gtk_widget_show (scrolled_win);

  GtkWidget *vbox = gtk_vbox_new (FALSE, 4);

  gtk_widget_show (vbox);

  gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, 1, 1, 4);

  gtk_container_add (GTK_CONTAINER (window), vbox);

  GtkWidget *hbox = gtk_hbox_new (FALSE, 4);

  gtk_widget_show (hbox);

  gtk_box_pack_start (GTK_BOX (vbox), hbox, false, false, 4);

  GtkObject *zoom = gtk_adjustment_new (3.0, 0.1, 10.0, 0.2, 1.0, 1.0);

  gtk_box_pack_start(GTK_BOX (hbox),

                     GTK_WIDGET (g_object_new (GTK_TYPE_SPIN_BUTTON, "adjustment", zoom,

                                               "visible", true, "digits", 2, NULL)),

                     false, false, 4);

  g_canvas = goo_canvas_new ();

  gtk_widget_set_size_request (GTK_WIDGET (g_canvas), 600, 450);

  goo_canvas_set_bounds (GOO_CANVAS (g_canvas), -500, -500, 500, 500);

  g_signal_connect (zoom, "value-changed", G_CALLBACK (zoom_changed), NULL);

  gtk_adjustment_value_changed (GTK_ADJUSTMENT (zoom));

  gtk_widget_show (g_canvas);

  gtk_container_add (GTK_CONTAINER (scrolled_win), g_canvas);

  goo_canvas_scroll_to (GOO_CANVAS (g_canvas), 0, 0);

  // create the bounds rectangle

  if (x1 != x2)

    {

      GooCanvasItem *item = 

        goo_canvas_rect_new (goo_canvas_get_root_item (GOO_CANVAS (g_canvas)),

                                                 x1, y1, x2-x1, y2-y1, NULL);

        g_object_set (item, "line-width", 1.0, "stroke-color", "grey", NULL);

    }

  queue = g_async_queue_new ();

  g_timeout_add ((guint) (SAMPLE_INTERVAL*1000), (GSourceFunc) view_update_consumer, NULL);

  g_thread_create (GThreadFunc (ns3::Simulator::Run), NULL, FALSE, NULL);

  gtk_main ();

  return 0;

}