/*
 * Copyright (C) 2007-10 Tony Arcieri
 * You may redistribute this under the terms of the Ruby license.
 * See LICENSE for details
 */

#include "ruby.h"
#include "ev_wrap.h"

#include "cool.io.h"

static VALUE mCoolio = Qnil;
static VALUE cCoolio_Watcher = Qnil;

static VALUE Coolio_Watcher_allocate(VALUE klass);
static void Coolio_Watcher_mark(void *data);

static VALUE Coolio_Watcher_initialize(VALUE self);
static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop);
static VALUE Coolio_Watcher_detach(VALUE self);
static VALUE Coolio_Watcher_enable(VALUE self);
static VALUE Coolio_Watcher_disable(VALUE self);
static VALUE Coolio_Watcher_evloop(VALUE self);
static VALUE Coolio_Watcher_attached(VALUE self);
static VALUE Coolio_Watcher_enabled(VALUE self);

/* 
 * Watchers are Coolio's event observers.  They contain a set of callback
 * methods prefixed by on_* which fire whenever events occur.
 *
 * In order for a watcher to fire events it must be attached to a running
 * loop.  Every watcher has an attach and detach method to control which
 * loop it's associated with.
 *
 * Watchers also have an enable and disable method.  This allows a watcher
 * to temporarily ignore certain events while remaining attached to a given
 * loop.  This is good for watchers which need to be toggled on and off.
 */
void Init_coolio_watcher()
{
  mCoolio = rb_define_module("Coolio");
  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
  rb_define_alloc_func(cCoolio_Watcher, Coolio_Watcher_allocate);

  rb_define_method(cCoolio_Watcher, "initialize", Coolio_Watcher_initialize, 0);
  rb_define_method(cCoolio_Watcher, "attach", Coolio_Watcher_attach, 1);
  rb_define_method(cCoolio_Watcher, "detach", Coolio_Watcher_detach, 0);
  rb_define_method(cCoolio_Watcher, "enable", Coolio_Watcher_enable, 0);
  rb_define_method(cCoolio_Watcher, "disable", Coolio_Watcher_disable, 0);
  rb_define_method(cCoolio_Watcher, "evloop", Coolio_Watcher_evloop, 0);
  rb_define_method(cCoolio_Watcher, "attached?", Coolio_Watcher_attached, 0);
  rb_define_method(cCoolio_Watcher, "enabled?", Coolio_Watcher_enabled, 0);
}

static const rb_data_type_t Coolio_Watcher_type = {
  "Coolio::Watcher",
  {
    Coolio_Watcher_mark,
    RUBY_DEFAULT_FREE,
  },
};

struct Coolio_Watcher *Coolio_Watcher_ptr(VALUE watcher)
{
  struct Coolio_Watcher *watcher_data;

  TypedData_Get_Struct(watcher, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data);
  return watcher_data;
}

static VALUE Coolio_Watcher_allocate(VALUE klass)
{
  struct Coolio_Watcher *watcher_data;
  VALUE watcher = TypedData_Make_Struct(klass, struct Coolio_Watcher, &Coolio_Watcher_type, watcher_data);

  watcher_data->loop = Qnil;
  watcher_data->enabled = 0;

  return watcher;
}

static void Coolio_Watcher_mark(void *data)
{
  struct Coolio_Watcher *watcher_data = data;

  if(watcher_data->loop != Qnil)
    rb_gc_mark(watcher_data->loop);
}

static VALUE Coolio_Watcher_initialize(VALUE self)
{
  rb_raise(rb_eRuntimeError, "watcher base class should not be initialized directly");
}

/**
 *  call-seq:
 *    Coolio::Watcher.attach(loop) -> Coolio::Watcher
 * 
 * Attach the watcher to the given Coolio::Loop.  If the watcher is already attached
 * to a loop, detach it from the old one and attach it to the new one.
 */
static VALUE Coolio_Watcher_attach(VALUE self, VALUE loop)
{
  VALUE loop_watchers, active_watchers;
  struct Coolio_Watcher *watcher_data;

  watcher_data = Coolio_Watcher_ptr(self);
  watcher_data->enabled = 1;
    
  loop_watchers = rb_iv_get(loop, "@watchers");

  if(loop_watchers == Qnil) {
    /* we should never get here */
    loop_watchers = rb_hash_new();
    rb_iv_set(loop, "@watchers", loop_watchers);
  }

  /* Add us to the loop's array of active watchers.  This is mainly done
   * to keep the VM from garbage collecting watchers that are associated
   * with a loop (and also lets you see within Ruby which watchers are
   * associated with a given loop), but isn't really necessary for any 
   * other reason */
  rb_hash_aset(loop_watchers, self, Qtrue);

  active_watchers = rb_iv_get(loop, "@active_watchers");
  if(active_watchers == Qnil)
    active_watchers = INT2NUM(1);
  else
    active_watchers = INT2NUM(NUM2INT(active_watchers) + 1);
  rb_iv_set(loop, "@active_watchers", active_watchers);

  return self;
}

/**
 *  call-seq:
 *    Coolio::Watcher.detach -> Coolio::Watcher
 * 
 * Detach the watcher from its current Coolio::Loop.
 */
static VALUE Coolio_Watcher_detach(VALUE self)
{
  struct Coolio_Watcher *watcher_data;
  struct Coolio_Loop *loop_data;
  VALUE loop_watchers;
  int i;

  watcher_data = Coolio_Watcher_ptr(self);

  if(watcher_data->loop == Qnil)
    rb_raise(rb_eRuntimeError, "not attached to a loop");

  loop_watchers = rb_iv_get(watcher_data->loop, "@watchers");

  /* Remove us from the loop's array of active watchers.  This likely
   * has negative performance and scalability characteristics as this
   * isn't an O(1) operation.  Hopefully there's a better way...
   * Trying a hash for now... */
  rb_hash_delete(loop_watchers, self);

  if(watcher_data->enabled) {
    rb_iv_set(
        watcher_data->loop, 
        "@active_watchers",
        INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) - 1)
    );
  }

  watcher_data->enabled = 0;

  loop_data = Coolio_Loop_ptr(watcher_data->loop);

  /* Iterate through the events in the loop's event buffer.  If there
   * are any pending events from this watcher, mark them NULL.  The
   * dispatch loop will skip them.  This prevents watchers earlier
   * in the event buffer from detaching others which may have pending
   * events in the buffer but get garbage collected in the meantime */
  for(i = 0; i < loop_data->events_received; i++) {
    if(loop_data->eventbuf[i].watcher == self)
      loop_data->eventbuf[i].watcher = Qnil;
  }

  watcher_data->loop = Qnil;

  return self;
}

/**
 *  call-seq:
 *    Coolio::Watcher.enable -> Coolio::Watcher
 * 
 * Re-enable a watcher which has been temporarily disabled.  See the
 * disable method for a more thorough explanation.
 */
static VALUE Coolio_Watcher_enable(VALUE self)
{
  struct Coolio_Watcher *watcher_data;
  watcher_data = Coolio_Watcher_ptr(self);

  if(watcher_data->enabled)
    rb_raise(rb_eRuntimeError, "already enabled");

  watcher_data->enabled = 1;

  rb_iv_set(
      watcher_data->loop, 
      "@active_watchers",
      INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) + 1)
  );

  return self;
}

/**
 *  call-seq:
 *    Coolio::Watcher.disable -> Coolio::Watcher
 * 
 * Temporarily disable an event watcher which is attached to a loop.  
 * This is useful if you wish to toggle event monitoring on and off.  
 */
static VALUE Coolio_Watcher_disable(VALUE self)
{
  struct Coolio_Watcher *watcher_data;
  watcher_data = Coolio_Watcher_ptr(self);

  if(!watcher_data->enabled)
    rb_raise(rb_eRuntimeError, "already disabled");

  watcher_data->enabled = 0;

  rb_iv_set(
      watcher_data->loop, 
      "@active_watchers",
      INT2NUM(NUM2INT(rb_iv_get(watcher_data->loop, "@active_watchers")) - 1)
  );

  return self;
}

/**
 *  call-seq:
 *    Coolio::Watcher.evloop -> Coolio::Loop
 * 
 * Return the loop to which we're currently attached
 */
static VALUE Coolio_Watcher_evloop(VALUE self)
{
  struct Coolio_Watcher *watcher_data;

  watcher_data = Coolio_Watcher_ptr(self);
  return watcher_data->loop;
}

/**
 *  call-seq:
 *    Coolio::Watcher.attached? -> Boolean
 * 
 * Is the watcher currently attached to an event loop?
 */
static VALUE Coolio_Watcher_attached(VALUE self)
{
  return Coolio_Watcher_evloop(self) != Qnil;
}

/**
 *  call-seq:
 *    Coolio::Watcher.enabled? -> Boolean
 * 
 * Is the watcher currently enabled?
 */
static VALUE Coolio_Watcher_enabled(VALUE self)
{
	struct Coolio_Watcher *watcher_data;
  watcher_data = Coolio_Watcher_ptr(self);
  
	return watcher_data->enabled ? Qtrue : Qfalse;
}