/*
 *
 *  D-Bus++ - C++ bindings for D-Bus
 *
 *  Copyright (C) 2005-2007  Paolo Durante <shackan@gmail.com>
 *
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <dbus-c++/ecore-integration.h>

#include <dbus/dbus.h> // for DBUS_WATCH_*

using namespace DBus;

Dispatcher *gdispatcher = NULL;

Ecore::BusTimeout::BusTimeout( Timeout::Internal* ti)
: Timeout(ti)
{
  if (Timeout::enabled())
  {
	  _enable();
  }
}

Ecore::BusTimeout::~BusTimeout()
{
	_disable();
}

void Ecore::BusTimeout::toggle()
{
	debug_log("ecore: timeout %p toggled (%s)", this, Timeout::enabled() ? "on":"off");

	if(Timeout::enabled())
  {
    _enable();
  }
	else
  {
    _disable();
  }
}

Eina_Bool Ecore::BusTimeout::timeout_handler( void *data )
{
	Ecore::BusTimeout* t = reinterpret_cast<Ecore::BusTimeout*>(data);

	debug_log("Ecore::BusTimeout::timeout_handler( void *data )");

	t->handle();

	return ECORE_CALLBACK_RENEW;
}

void Ecore::BusTimeout::_enable()
{
  debug_log("Ecore::BusTimeout::_enable()");
  
  _etimer = ecore_timer_add (((double)Timeout::interval())/1000, timeout_handler, this);
}

void Ecore::BusTimeout::_disable()
{
  debug_log("Ecore::BusTimeout::_disable()");

  ecore_timer_del (_etimer);
}

Ecore::BusWatch::BusWatch( Watch::Internal* wi)
: Watch(wi), fd_handler (NULL), _bd (NULL)
{  
  if (Watch::enabled())
  {
	  _enable();
  }
}

Ecore::BusWatch::~BusWatch()
{
	_disable();
}

void Ecore::BusWatch::toggle()
{
	debug_log("ecore: watch %p toggled (%s)", this, Watch::enabled() ? "on":"off");

	if(Watch::enabled())	_enable();
	else			_disable();
}

Eina_Bool Ecore::BusWatch::watch_dispatch( void *data, Ecore_Fd_Handler *fdh  )
{
	Ecore::BusWatch* w = reinterpret_cast<Ecore::BusWatch*>(data);

	debug_log("Ecore::BusWatch watch_handler");

	int flags = w->flags();

	if (w->flags() & DBUS_WATCH_READABLE)
		ecore_main_fd_handler_active_set(w->fd_handler, ECORE_FD_READ);
	if (w->flags() & DBUS_WATCH_WRITABLE)
		ecore_main_fd_handler_active_set(w->fd_handler, ECORE_FD_WRITE);

  w->handle(flags);
  w->_bd->dispatch_pending();

	return 1;
}

void Ecore::BusWatch::_enable()
{
  debug_log("Ecore::BusWatch::_enable()");

  fd_handler = ecore_main_fd_handler_add (descriptor(),
                                          (Ecore_Fd_Handler_Flags) (ECORE_FD_READ | ECORE_FD_WRITE),
                                          watch_dispatch, this,
                                          NULL, NULL);
}

void Ecore::BusWatch::_disable()
{
  if (fd_handler)
  {
    ecore_main_fd_handler_del (fd_handler);
    fd_handler = NULL;
  }
}

void Ecore::BusWatch::data (Ecore::BusDispatcher *bd)
{
  _bd = bd;
}

Ecore::BusDispatcher::BusDispatcher()
{
}

Eina_Bool Ecore::BusDispatcher::check ( void *data, Ecore_Fd_Handler *fdh)
{
  return 0;
}

Timeout* Ecore::BusDispatcher::add_timeout( Timeout::Internal* wi )
{
	Timeout* t = new Ecore::BusTimeout( wi );

	debug_log("ecore: added timeout %p (%s)", t, t->enabled() ? "on":"off");

	return t;
}

void Ecore::BusDispatcher::rem_timeout( Timeout* t )
{
	debug_log("ecore: removed timeout %p", t);

	delete t;
}

Watch* Ecore::BusDispatcher::add_watch( Watch::Internal* wi )
{
  Ecore::BusWatch* w = new Ecore::BusWatch(wi);
  w->data (this);

	debug_log("ecore: added watch %p (%s) fd=%d flags=%d",
		w, w->enabled() ? "on":"off", w->descriptor(), w->flags()
	);
	return w;
}

void Ecore::BusDispatcher::rem_watch( Watch* w )
{
	debug_log("ecore: removed watch %p", w);

	delete w;
}