/*
 * search-mixin.c - Source for GabbleSearchMixin
 * Copyright (C) 2006 Collabora Ltd.
 * 
 *   @author Ole Andre Vadla Ravnaas <ole.andre.ravnaas@collabora.co.uk>
 *   @author Robert McQueen <robert.mcqueen@collabora.co.uk>
 *   @author Senko Rasic <senko@senko.net>
 *
 * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */


#include "loudmouth/loudmouth.h"
#include <dbus/dbus-glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#include "telepathy-constants.h"
#include "telepathy-errors.h"


#include "debug.h"
#include "gabble-connection.h"
#include "namespaces.h"
#include "roster.h"
#include "util.h"


#include "search-mixin.h"
#include "search-mixin-signals-marshal.h"


#include "gabble_enums.h"

#define _GNU_SOURCE /* Needed for strptime (_XOPEN_SOURCE can also be used). */

#define DEBUG_FLAG GABBLE_DEBUG_SEARCH


/* allocator */

#ifdef DEBUG_FLAG
//#define DEBUG(format, ...)
#define DEBUGGING 0
#define NODE_DEBUG(n, s)
#endif /* DEBUG_FLAG */


#ifdef EMULATOR
#include "libgabble_wsd_solution.h"

	GET_STATIC_VAR_FROM_TLS(offset_quark1,gabble_search_mixin,GQuark)
	#define offset_quark1 (*GET_WSD_VAR_NAME(offset_quark1,gabble_search_mixin, s)())	
	
	GET_STATIC_VAR_FROM_TLS(offset_quark,gabble_search_mixin,GQuark)
	#define offset_quark (*GET_WSD_VAR_NAME(offset_quark,gabble_search_mixin, s)())	
	
	GET_STATIC_VAR_FROM_TLS(alloc1,gabble_search_mixin,GabbleAllocator)
	#define alloc1 (*GET_WSD_VAR_NAME(alloc1,gabble_search_mixin, s)())		
	
#endif

/*
Moved to gabble_enums.h
typedef struct _GabbleAllocator GabbleAllocator;
struct _GabbleAllocator
{
  gulong size;
  guint limit;
  guint count;
};*/


typedef struct _IsKeyValidUserData IsKeyValidUserData;

struct _IsKeyValidUserData
{
  GError **error;
  gchar **search_key_names;
  gboolean is_key_found;
};


typedef struct _SearchKeyVarUserData SearchKeyVarUserData;

struct _SearchKeyVarUserData
{
  LmMessageNode *x_node;
  GabbleConnection *conn;
  
};


#define ga_new0(alloc, type) \
    ((type *) gabble_allocator_alloc0 (alloc))

static void
gabble_allocator_init (GabbleAllocator *alloc, gulong size, guint limit)
{
  g_assert (alloc != NULL);
  g_assert (size > 0);
  g_assert (limit > 0);

  alloc->size = size;
  alloc->limit = limit;
}

static gpointer gabble_allocator_alloc0 (GabbleAllocator *alloc)
{
  gpointer ret;

  g_assert (alloc != NULL);
  g_assert (alloc->count <= alloc->limit);

  if (alloc->count == alloc->limit)
    {
      ret = NULL;
    }
  else
    {
      ret = g_malloc0 (alloc->size);
      alloc->count++;
    }

  return ret;
}

static void gabble_allocator_free (GabbleAllocator *alloc, gpointer thing)
{
  g_assert (alloc != NULL);
  g_assert (thing != NULL);

  g_free (thing);
  alloc->count--;
}


/**
 * gabble_search_mixin_class_get_offset_quark:
 *
 * Returns: the quark used for storing mixin offset on a GObjectClass
 */
GQuark
gabble_search_mixin_class_get_offset_quark ()
{
#ifndef EMULATOR  
  static GQuark offset_quark1 = 0;
#endif
  
  if (!offset_quark1)
    offset_quark1 = g_quark_from_static_string("SearchMixinClassOffsetQuark");
  return offset_quark1;
}

/**
 * gabble_search_mixin_get_offset_quark:
 *
 * Returns: the quark used for storing mixin offset on a GObject
 */
GQuark
gabble_search_mixin_get_offset_quark ()
{
#ifndef EMULATOR  
  static GQuark offset_quark = 0;
#endif
  
  if (!offset_quark)
    offset_quark = g_quark_from_static_string("SearchMixinOffsetQuark");
  return offset_quark;
}


/* GabbleSearchMixin */
void
gabble_search_mixin_class_init (GObjectClass *obj_cls, glong offset)
{
  GabbleSearchMixinClass *mixin_cls;

  g_assert (G_IS_OBJECT_CLASS (obj_cls));

  g_type_set_qdata (G_OBJECT_CLASS_TYPE (obj_cls),
      GABBLE_SEARCH_MIXIN_CLASS_OFFSET_QUARK,
      GINT_TO_POINTER (offset));

  mixin_cls = GABBLE_SEARCH_MIXIN_CLASS (obj_cls);


  mixin_cls->search_result_received_signal_id = g_signal_new ("search-result-received",
                G_OBJECT_CLASS_TYPE (obj_cls),
                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
                0,
                NULL, NULL,
                search_mixin_marshal_VOID__UINT_BOXED,
                G_TYPE_NONE,
                2, G_TYPE_UINT, dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE ));

  mixin_cls->search_state_changed_signal_id = g_signal_new ("search-state-changed",
                G_OBJECT_CLASS_TYPE (obj_cls),
                G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
                0,
                NULL, NULL,
                g_cclosure_marshal_VOID__UINT,
                G_TYPE_NONE, 1, G_TYPE_UINT );

}

void
gabble_search_mixin_init (GObject *obj,
                        	glong offset )
{
  GabbleSearchMixin *mixin;

  g_assert (G_IS_OBJECT (obj));

  g_type_set_qdata (G_OBJECT_TYPE (obj),
                    GABBLE_SEARCH_MIXIN_OFFSET_QUARK,
                    GINT_TO_POINTER (offset));

  mixin = GABBLE_SEARCH_MIXIN (obj);
  
  mixin->search_state = TP_CHANNEL_CONTACT_SEARCH_STATE_BEFORE;

 }

void
gabble_search_mixin_finalize (GObject *obj)
{
  GabbleSearchMixin *mixin = GABBLE_SEARCH_MIXIN (obj);
  /* free any data held directly by the object here */
}

static void
setfield_foreach (gpointer key, gpointer value, gpointer user_data)
{
  const gchar *search_data_string = NULL;  
  SearchKeyVarUserData *key_var_struct = (SearchKeyVarUserData*)user_data;
  LmMessageNode *field_node;  
  const gchar *search_key_var = NULL;
  GType g_type = G_VALUE_TYPE (value);
  
  switch (g_type) 
  {
    case G_TYPE_STRING:
    	search_data_string =  g_value_get_string(value);
    	break;
    default:
          g_assert_not_reached ();
  }
  
  search_key_var = (gchar *) g_hash_table_lookup (key_var_struct->conn->search_key_ht,
              										 key /*Label*/);
  field_node = lm_message_node_add_child ( key_var_struct->x_node, "field", NULL );
  lm_message_node_set_attribute ( field_node, "var", search_key_var );
  lm_message_node_add_child ( field_node, "value", search_data_string ); 
}
static void 
gabble_search_keynames_are_valid ( gpointer key, gpointer value,
                         			gpointer userdata )
{
  guint i;
  const gchar *search_data_string =  g_value_get_string(value);
  IsKeyValidUserData *key_valid_struct = (IsKeyValidUserData*)userdata;
  gchar **search_key_names = key_valid_struct->search_key_names;

  if( !key_valid_struct->is_key_found )
  	return;
  
  if( key == NULL )
	  {
	  	key_valid_struct->is_key_found = FALSE;
	  	return;
	  }
	   
	  
  for (i = 0; search_key_names[i]; i++)
    {
      if (0 == strcmp (search_key_names[i], key))
	      {
	      g_message("searchkey %s is valid\n",key);
	      if( search_data_string )
	      	g_message("value is %s\n",search_data_string);
	      return;	
	      }
    }
 key_valid_struct->is_key_found = FALSE;
 g_message("searchkey %s is invalid\n",key);
 g_set_error ( key_valid_struct->error, TELEPATHY_ERRORS, InvalidArgument,
		              "invalid search key found : %s\n", key);
}


/**
 * gabble_search_mixin_search
 *
 * Implements D-Bus method Search
 * on interface org.freedesktop.Telepathy.Channel.Type.ContactSearch
 *
 * @error: Used to return a pointer to a GError detailing any error
 *         that occurred, D-Bus will throw the error only if this
 *         function returns false.
 *
 * Returns: TRUE if successful, FALSE if an error was thrown.
 */
gboolean gabble_search_mixin_search (GObject *obj,GHashTable *params,
									 GabbleConnection *conn,
                                 	 GError **error)
{
  LmMessage *msg;
  LmMessageNode *query_node;
  LmMessageNode *x_node;
  gboolean result;
  const gchar *service = NULL;
  GabbleSearchMixin *mixin = GABBLE_SEARCH_MIXIN (obj);
  IsKeyValidUserData *user_data = NULL;
  SearchKeyVarUserData *get_keyvar_userdata = NULL;
     

  if (params == NULL)
      {
       g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,
	              "invalid argument \n");
  	   return FALSE;	
      }
  
  if ( !g_hash_table_size(params) )
      {
       g_set_error (error, TELEPATHY_ERRORS, InvalidArgument,
	              "invalid argument, no key-value pair to do search\n");
  	   return FALSE;	
      }
  
  service = conn->search_service_jid;
  
  if (service == NULL)
      {
       g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
	              "Search Service is not available\n");
  	   return FALSE;	
      }
      
  g_message("service is %s\n",service);
  
  if (conn->search_key_names == NULL)
      {
       g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
	              "search key names not available");
  	   return FALSE;	
      }
  
  user_data = g_new0 (IsKeyValidUserData, 1);
  user_data->is_key_found = TRUE;
  user_data->error = error;
  user_data->search_key_names = conn->search_key_names;
  
  g_hash_table_foreach (params, gabble_search_keynames_are_valid, user_data );
  
  if(!user_data->is_key_found)
	  {
	  g_free(user_data);
	  g_message("invalid searchkey found\n");
	  return FALSE;		              
	  }
  
  g_free(user_data);
  
  msg= lm_message_new_with_sub_type ( service,
                                      LM_MESSAGE_TYPE_IQ,
                                      LM_MESSAGE_SUB_TYPE_SET);
  query_node = lm_message_node_add_child (msg->node, "query", NULL);
  
  lm_message_node_set_attribute (query_node, "xmlns", NS_SEARCH);
 
  x_node = lm_message_node_add_child ( query_node, "x", NULL );

  lm_message_node_set_attributes (x_node,
                      "xmlns", NS_X_DATA,
                      "type", "submit",
                      NULL);
                      
  get_keyvar_userdata = g_new0 (SearchKeyVarUserData, 1);
  get_keyvar_userdata->x_node = x_node;
  get_keyvar_userdata->conn = conn;

  g_hash_table_foreach (params, setfield_foreach, get_keyvar_userdata );
  
  g_free(get_keyvar_userdata);	                                  	
	 
  result = _gabble_connection_send (conn, msg, error);
  lm_message_unref (msg);

  if (!result)
    return FALSE;
  
  //this means for each search attempt, a new channel should be created
  mixin->search_state = TP_CHANNEL_CONTACT_SEARCH_STATE_DURING;
  
  //send search state changed signal if required
  _gabble_search_mixin_emit_search_state_changed(obj,mixin->search_state);

   return TRUE;
}

gboolean gabble_search_mixin_get_search_state (	GObject *obj, 
												guint *ret,
                        						GError **error )
{
  GabbleSearchMixin *mixin = GABBLE_SEARCH_MIXIN (obj);
  *ret = mixin->search_state; 
  return TRUE;
}


/**
 * gabble_search_mixin_get_search_keys
 *
 * Implements D-Bus method GetSearchKeys
 * on interface org.freedesktop.Telepathy.Channel.Type.ContactSearch
 *
 * @error: Used to return a pointer to a GError detailing any error
 *         that occurred, D-Bus will throw the error only if this
 *         function returns false.
 *
 * Returns: TRUE if successful, FALSE if an error was thrown.
 */
gboolean
gabble_search_mixin_get_search_keys (	GObject *obj,
										gchar **ret_instruction, 
										gchar ***ret_searchkeys,
										GabbleConnection *conn,
		                        		GError **error
                        	  		   )
{
  //later this method should be modified to give 
  //types of search keys fields also
  
  if (conn->search_key_names == NULL)
      {
       g_set_error (error, TELEPATHY_ERRORS, NotAvailable,
	              "search keys not available");
  	   return FALSE;	
      }
  
  *ret_searchkeys = g_strdupv ((gchar **) conn->search_key_names);
  *ret_instruction = g_strdup ( (gchar*)conn->search_instr);

  g_message("conn->search_instr :%s\n",(gchar*)conn->search_instr);
  g_message("ret_instruction  :%s\n",(gchar*)*ret_instruction );

  return TRUE;
}


void
_gabble_search_mixin_emit_search_result_received (GObject *obj,
                                                 guint contact_handle,
                             				     GHashTable *values )
{
  GabbleSearchMixinClass *mixin_cls = GABBLE_SEARCH_MIXIN_CLASS (G_OBJECT_GET_CLASS
      (obj));

  g_signal_emit (obj, mixin_cls->search_result_received_signal_id, 0,
                 contact_handle,
                 values );
}

void
_gabble_search_mixin_emit_search_state_changed (GObject *obj,
                                                 guint search_state )
{
  GabbleSearchMixinClass *mixin_cls = GABBLE_SEARCH_MIXIN_CLASS (G_OBJECT_GET_CLASS
      (obj));
  g_signal_emit (obj, mixin_cls->search_state_changed_signal_id, 0,
                 search_state );
}

void
_gabble_search_mixin_set_search_state (GObject *obj, guint state )
{
  GabbleSearchMixin *mixin = GABBLE_SEARCH_MIXIN (obj);  
  mixin->search_state = state;
}