#include <e.h>
#include "e_mod_main.h"

#include <E_Hal.h>
#include <stdlib.h>
#include <stdio.h>


// forward declarations
typedef struct Block Block;


/** Prototype **/
static void _mount_down(void *data, Evas *e, Evas_Object *obj, void *event_info);
static void cb_signal_device_added(void *data, DBusMessage *msg);
static void cb_is_block_device(void *user_data, void *reply_data, DBusError *error);
static void cb_block_device_properties(void *data, void *reply_data, DBusError *error);

void mount_block_device(Block *b);



/////////////////////////////////////////
struct Block {
  char *device;
  char is_volume;
          
};

Block *
block_new(void)
{
  Block *b;
  b = calloc(1, sizeof(Block));
    
  return b;
}
//////////////////////////////////////////

static E_DBus_Connection *conn = NULL;

/**/
/* gadcon requirements */
static E_Gadcon_Client *_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style);
static void _gc_shutdown(E_Gadcon_Client *gcc);
static void _gc_orient(E_Gadcon_Client *gcc);
static char *_gc_label(void);
static Evas_Object *_gc_icon(Evas *evas);

static E_Module *mount_module = NULL;

/* and actually define the gadcon class that this module provides (just 1) */
static const E_Gadcon_Client_Class _gadcon_class =
{
   GADCON_CLIENT_CLASS_VERSION,
     "Mount",
     {
	_gc_init, _gc_shutdown, _gc_orient, _gc_label, _gc_icon
     },
   E_GADCON_CLIENT_STYLE_PLAIN
};
EAPI E_Module_Api e_modapi = {
  E_MODULE_API_VERSION,
  "Mount"
};


/**/
/* actual module specifics */
typedef struct _Mount Mount;
typedef struct _Instance Instance;

struct _Instance
{
   E_Gadcon_Client *gcc;
   Evas_Object     *o_mount;
   Mount           *mount;
   Evas_Object     *o_box;   
}; 

struct _Mount 
{
	Instance     *inst;
	Evas_Object  *o_mount;
	Evas_Object  *o_box;
	
};

Instance *mod_inst = NULL;


static E_Gadcon_Client *
_gc_init(E_Gadcon *gc, const char *name, const char *id, const char *style)
{
   Evas_Object *o;
   E_Gadcon_Client *gcc;
   Instance *inst;
   
   char buf[4096];
   
   inst = E_NEW(Instance, 1);
   
   o = edje_object_add(gc->evas);
   
   snprintf (buf, sizeof (buf), "%s/mount.edj",
	    e_module_dir_get (mount_module));
   
   edje_object_file_set (o, buf, "modules/mount/main");
   
   evas_object_show(o);
   
   evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_DOWN, _mount_down, o);
   gcc = e_gadcon_client_new(gc, name, id, style, o);
   gcc->data = inst;
   
   inst->gcc = gcc;
   inst->o_mount = o;
   
   e_gadcon_client_util_menu_attach(gcc);
   
   mod_inst = inst;
   
   return gcc;
}

static void
_gc_shutdown(E_Gadcon_Client *gcc)
{
   Instance *inst;
   
   inst = gcc->data;
   evas_object_del(inst->o_mount);
   free(inst);
}

static void
_gc_orient(E_Gadcon_Client *gcc)
{
   Instance *inst;
   
   inst = gcc->data;
   e_gadcon_client_aspect_set(gcc, 16, 16);
   e_gadcon_client_min_size_set(gcc, 16, 16);
}

static char *
_gc_label(void)
{
   return _("Mount");
}

static Evas_Object *
_gc_icon(Evas *evas)
{
   Evas_Object *o;
   char buf[4096];
   
   o = edje_object_add(evas);
   snprintf(buf, sizeof(buf), "%s/e-module-mount.edj",
	    e_module_dir_get(mount_module));
   edje_object_file_set(o, buf, "icon");
   return o;
}

EAPI void *
e_modapi_init (E_Module * m)
{
  bindtextdomain (PACKAGE, LOCALEDIR);
  bind_textdomain_codeset (PACKAGE, "UTF-8");

//  e_module_dialog_show (m, D_ ("Enlightenment Mount Module"),
//			D_ ("Init was called!. 12345"));
  
  mount_module = m;

  e_dbus_init();
  conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
 
  if(!conn) 
  {
    
    e_module_dialog_show (m, D_ ("Enlightenment Mount Module"),
			D_ ("Error connecting to dbus!."));
  
    
	  
  }
  
  
  e_dbus_signal_handler_add(conn, "org.freedesktop.Hal", "/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager", "DeviceAdded", cb_signal_device_added, NULL);
  //e_dbus_signal_handler_add(conn, "org.freedesktop.Hal", "/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager", "DeviceRemoved", cb_signal_device_removed, NULL);
  //e_dbus_signal_handler_add(conn, "org.freedesktop.Hal", "/org/freedesktop/Hal/Manager", "org.freedesktop.Hal.Manager", "NewCapability", cb_signal_new_capability, NULL);
  printf("*********************************** e_modapi_init() ");
  
  e_gadcon_provider_register(&_gadcon_class);
  return m;
}

EAPI int
e_modapi_shutdown (E_Module * m)
{

   mount_module = NULL;
   
   e_gadcon_provider_unregister(&_gadcon_class);
   return 1;
}

EAPI int
e_modapi_save (E_Module * m)
{
  return 1;
}

EAPI int
e_modapi_about (E_Module * m)
{
  e_module_dialog_show (m, D_ ("Enlightenment Mount Module"),
			D_ ("This module is used to mount removable devices."));
  return 1;
}

static void
_mount_down(void *data, Evas *e, Evas_Object *obj, void *event_info) 
{
          e_module_dialog_show (mount_module, D_ ("Enlightenment Mount Module"),
			D_ ("Mouse down!!!"));
 
	 
}

/**
 * Dbus/hal callback functions 
 */

static void 
cb_signal_device_added(void *data, DBusMessage *msg)
{
	
	DBusError err;
	char *udi;
	int ret;
	printf("********************* cb_signal_device_added()");
//	 e_module_dialog_show (mount_module, D_ ("Enlightenment Mount Module"),
//			D_ ("cb_signal_device_added."));
	
    dbus_error_init(&err);
    dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &udi, DBUS_TYPE_INVALID);
    
	udi = strdup(udi);

	ret = e_hal_device_query_capability(conn, udi, "block", cb_is_block_device, strdup(udi));
	
	
      
}

static void
cb_is_block_device(void *user_data, void *reply_data, DBusError *error)
{
  char *udi = user_data;
  E_Hal_Device_Query_Capability_Return *ret = reply_data;

   
  printf("cb_is_block_device()");
  
  if (dbus_error_is_set(error)) 
  {
    printf("Error encountered during block_device check.");
    
    dbus_error_free(error);
    goto error;
  }
  
  printf("Is block device ? %d", ret->boolean);
  
  if (ret && ret->boolean) {
    int err =0;
    E_Hal_Properties *ret;
    
    Block *b = block_new();
    e_hal_device_get_all_properties(conn, udi, cb_block_device_properties, b);
  
    e_module_dialog_show (mount_module, D_ ("Enlightenment Mount Module"),
			D_ ("Block device was detected and added."));
	
  } else {
	  printf("Block device not found, ignoring.");
  }

error:
  free(udi);
}
        

static void
cb_block_device_properties(void *data, void *reply_data, DBusError *error)
{
  Block *b = data;
  
  E_Hal_Device_Get_All_Properties_Return *ret = reply_data;
  int err = 0;
  char *str = NULL;
  
  printf("\ncb_block_device_properties() : invoked\n");
  
  if (dbus_error_is_set(error)) 
  {
    printf("\n\nError found cb_block_device_properties\n\n");
    dbus_error_free(error);
    goto error;
  }

  b->device = e_hal_property_string_get(ret, "block.device", &err);
  b->is_volume = e_hal_property_bool_get(ret, "block.is_volume", &err);
  
  if(err) {
    printf("\n\nError encountered while getting property block.device\n\n");       
          
  } else {
          
          printf("\n\nblock device found at: %s\n\n",b->device);
          
          if(b->is_volume) {
              printf("[*] Device is volume, attempting to mount.");    
			  
			  mount_block_device(b);
          }
          
  }
  
error:
  if(str) free(str);
  str = NULL;
  
}

/**
 * Mount unmount functions
 */
 
void
mount_block_device(Block *b) 
{
  
  //Evas_List *l;
   char buf[4096];
   Evas_Object *icon = NULL ;
   char buf2[4096];
 
  // Ecore_Exe *ex;
   printf("\n\n[*]Mounting device...\n\n");
   snprintf(buf, sizeof(buf),
	   "pmount  %s", b->device);

	  
	  icon = edje_object_add( evas_object_evas_get(mod_inst->o_mount));
	  
	  if(!icon) {
		
		  printf("Failed to create edje_object, not displaying icon.");
		  
	  }
	  else {
		  printf("[*] Created icon, displaying icon\n");
	  snprintf (buf2, sizeof (buf2), "%s/mount.edj",
	    e_module_dir_get (mount_module));
      
	  edje_object_file_set (icon, buf2, "modules/mount/usb");
	  
      evas_object_show(icon);
	  }
        
}