/*

  Meanwhile - Unofficial Lotus Sametime Community Client Library

  Copyright (C) 2004  Christopher (siege) O'Brien

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Library General Public

  License as published by the Free Software Foundation; either

  version 2 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

  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public

  License along with this library; if not, write to the Free

  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <glib/ghash.h>

#include "mw_channel.h"

#include "mw_common.h"

#include "mw_debug.h"

#include "mw_error.h"

#include "mw_message.h"

#include "mw_service.h"

#include "mw_session.h"

#include "mw_srvc_dir.h"

#include "mw_util.h"

#define PROTOCOL_TYPE  0x0000001c

#define PROTOCOL_VER   0x00000005

enum dir_action {

  action_list    = 0x0000,  /**< list address books */

  action_open    = 0x0001,  /**< open an addressbook as a directory */

  action_close   = 0x0002,  /**< close a directory */

  action_search  = 0x0003,  /**< search an open directory */

};

struct mwServiceDirectory {

  struct mwService service;

  struct mwDirectoryHandler *handler;

  struct mwChannel *channel;

  guint32 counter;       /**< counter of request IDs */

  GHashTable *requests;  /**< map of request ID:directory */

  GHashTable *books;     /**< book->name:mwAddressBook */

};

struct mwAddressBook {

  struct mwServiceDirectory *service;

  guint32 id;        /**< id or type or something */

  char *name;        /**< name of address book */

  GHashTable *dirs;  /**< dir->id:mwDirectory */

};

struct mwDirectory {

  struct mwServiceDirectory *service;

  struct mwAddressBook *book;

  enum mwDirectoryState state;

  guint32 id;         /**< id of directory, assigned by server */

  guint32 search_id;  /**< id of current search, from srvc->counter++ */

  mwSearchHandler handler;

  struct mw_datum client_data;

};

#define next_request_id(srvc) ( ++((srvc)->counter) )

static guint32 map_request(struct mwDirectory *dir) {

  struct mwServiceDirectory *srvc = dir->service;

  guint32 id = next_request_id(srvc);

  dir->search_id = id;

  map_guint_insert(srvc->requests, id, dir);

  return id;

}

/** called when directory is removed from the service directory map */

static void dir_free(struct mwDirectory *dir) {

  map_guint_remove(dir->service->requests, dir->search_id);

  g_free(dir);

}

/** remove the directory from the service list and its owning address

    book, then frees the directory */

static void dir_remove(struct mwDirectory *dir) {

  struct mwAddressBook *book = dir->book;

  map_guint_remove(book->dirs, dir->id);

}

__attribute__((used))

static struct mwDirectory *dir_new(struct mwAddressBook *book, guint32 id) {

  struct mwDirectory *dir = g_new0(struct mwDirectory, 1);

  dir->service = book->service;

  dir->book = book;

  dir->id = id;

  map_guint_insert(book->dirs, id, dir);

  return dir;

}

/** called when book is removed from the service book map. Removed all

    directories as well */

static void book_free(struct mwAddressBook *book) {

  g_hash_table_destroy(book->dirs);

  g_free(book->name);

}

__attribute__((used))

static void book_remove(struct mwAddressBook *book) {

  struct mwServiceDirectory *srvc = book->service;

  g_hash_table_remove(srvc->books, book->name);

}

static struct mwAddressBook *book_new(struct mwServiceDirectory *srvc,

				      const char *name, guint32 id) {

  struct mwAddressBook *book = g_new0(struct mwAddressBook, 1);

  book->service = srvc;

  book->id = id;

  book->name = g_strdup(name);

  book->dirs = map_guint_new_full((GDestroyNotify) dir_free);

  g_hash_table_insert(srvc->books, book->name, book);

  return book;

}

static const char *getName(struct mwService *srvc) {

  return "Address Book and Directory";

}

static const char *getDesc(struct mwService *srvc) {

  return "Address book directory service for user and group lookups";

}

static struct mwChannel *make_channel(struct mwServiceDirectory *srvc) {

  struct mwSession *session;

  struct mwChannelSet *cs;

  struct mwChannel *chan;

  session = mwService_getSession(MW_SERVICE(srvc));

  cs = mwSession_getChannels(session);

  chan = mwChannel_newOutgoing(cs);

  mwChannel_setService(chan, MW_SERVICE(srvc));

  mwChannel_setProtoType(chan, PROTOCOL_TYPE);

  mwChannel_setProtoVer(chan, PROTOCOL_VER);

  return mwChannel_create(chan)? NULL: chan;

}

static void start(struct mwServiceDirectory *srvc) {

  struct mwChannel *chan;

  chan = make_channel(srvc);

  if(chan) {

    srvc->channel = chan;

  } else {

    mwService_stopped(MW_SERVICE(srvc));

    return;

  }

}

static void stop(struct mwServiceDirectory *srvc) {

  /* XXX */

  if(srvc->channel) {

    mwChannel_destroy(srvc->channel, ERR_SUCCESS, NULL);

    srvc->channel = NULL;

  }

}

static void clear(struct mwServiceDirectory *srvc) {

  struct mwDirectoryHandler *handler;

  if(srvc->books) {

    g_hash_table_destroy(srvc->books);

    srvc->books = NULL;

  }

  /* clear the handler */

  handler = srvc->handler;

  if(handler && handler->clear)

    handler->clear(srvc);

  srvc->handler = NULL;

}

static void recv_create(struct mwServiceDirectory *srvc,

			struct mwChannel *chan,

			struct mwMsgChannelCreate *msg) {

  /* no way man, we call the shots around here */

  mwChannel_destroy(chan, ERR_FAILURE, NULL);

}

static void recv_accept(struct mwServiceDirectory *srvc,

			struct mwChannel *chan,

			struct mwMsgChannelAccept *msg) {

  g_return_if_fail(srvc->channel != NULL);

  g_return_if_fail(srvc->channel == chan);

  if(MW_SERVICE_IS_STARTING(srvc)) {

    mwService_started(MW_SERVICE(srvc));

  } else {

    mwChannel_destroy(chan, ERR_FAILURE, NULL);

  }

}

static void recv_destroy(struct mwServiceDirectory *srvc,

			 struct mwChannel *chan,

			 struct mwMsgChannelDestroy *msg) {

  srvc->channel = NULL;

  mwService_stop(MW_SERVICE(srvc));

  /** @todo session sense service */

}

static void recv_list(struct mwServiceDirectory *srvc,

		      struct mwOpaque *data) {

  struct mwGetBuffer *b;

  guint32 request, code, count;

  gboolean foo_1;

  guint16 foo_2;

  b = mwGetBuffer_wrap(data);

  guint32_get(b, &request);

  guint32_get(b, &code);

  guint32_get(b, &count);

  gboolean_get(b, &foo_1);

  guint16_get(b, &foo_2);

  if(foo_1 || foo_2) {

    mw_mailme_opaque(data, "received strange address book list");

    mwGetBuffer_free(b);

    return;

  }

  while(!mwGetBuffer_error(b) && count--) {

    guint32 id;

    char *name = NULL;

    guint32_get(b, &id;;

    mwString_get(b, &name);

    book_new(srvc, name, id);

    g_free(name);

  }

}

static void recv_open(struct mwServiceDirectory *srvc,

		      struct mwOpaque *data) {

  /* look up the directory associated with this request id, 

     mark it as open, and trigger the event */

}

static void recv_search(struct mwServiceDirectory *srvc,

			struct mwOpaque *data) {

  /* look up the directory associated with this request id,

     trigger the event */

}

static void recv(struct mwServiceDirectory *srvc,

		 struct mwChannel *chan,

		 guint16 msg_type, struct mwOpaque *data) {

  g_return_if_fail(srvc != NULL);

  g_return_if_fail(chan != NULL);

  g_return_if_fail(chan == srvc->channel);

  g_return_if_fail(data != NULL);

  switch(msg_type) {

  case action_list:

    recv_list(srvc, data);

    break;

  case action_open:

    recv_open(srvc, data);

    break;

  case action_close:

    ; /* I don't think we should receive these */

    break;

  case action_search:

    recv_search(srvc, data);

    break;

  default:

    mw_mailme_opaque(data, "msg type 0x%04x in directory service", msg_type);

  }

}

struct mwServiceDirectory *

mwServiceDirectory_new(struct mwSession *session,

		       struct mwDirectoryHandler *handler) {

  struct mwServiceDirectory *srvc;

  struct mwService *service;

  g_return_val_if_fail(session != NULL, NULL);

  g_return_val_if_fail(handler != NULL, NULL);

  srvc = g_new0(struct mwServiceDirectory, 1);

  service = MW_SERVICE(srvc);

  mwService_init(service, session, SERVICE_DIRECTORY);

  service->get_name = getName;

  service->get_desc = getDesc;

  service->start = (mwService_funcStart) start;

  service->stop = (mwService_funcStop) stop;

  service->clear = (mwService_funcClear) clear;

  service->recv_create = (mwService_funcRecvCreate) recv_create;

  service->recv_accept = (mwService_funcRecvAccept) recv_accept;

  service->recv_destroy = (mwService_funcRecvDestroy) recv_destroy;

  service->recv = (mwService_funcRecv) recv;

  srvc->handler = handler;

  srvc->requests = map_guint_new();

  srvc->books = g_hash_table_new_full(g_str_hash, g_str_equal,

				      NULL, (GDestroyNotify) book_free);

  return srvc;

}

struct mwDirectoryHandler *

mwServiceDirectory_getHandler(struct mwServiceDirectory *srvc) {

  g_return_val_if_fail(srvc != NULL, NULL);

  return srvc->handler;

}

int mwServiceDirectory_refreshAddressBooks(struct mwServiceDirectory *srvc) {

  struct mwChannel *chan;

  struct mwPutBuffer *b;

  struct mwOpaque o;

  int ret;

  g_return_val_if_fail(srvc != NULL, -1);

  chan = srvc->channel;

  g_return_val_if_fail(chan != NULL, -1);

  b = mwPutBuffer_new();

  guint32_put(b, next_request_id(srvc));

  mwPutBuffer_finalize(&o, b);

  ret = mwChannel_send(chan, action_list, &o);

  mwOpaque_clear(&o);

  return ret;

}

GList *mwServiceDirectory_getAddressBooks(struct mwServiceDirectory *srvc) {

  g_return_val_if_fail(srvc != NULL, NULL);

  g_return_val_if_fail(srvc->books != NULL, NULL);

  return map_collect_values(srvc->books);

}

GList *mwServiceDirectory_getDirectories(struct mwServiceDirectory *srvc) {

  GList *bl, *ret = NULL;

  g_return_val_if_fail(srvc != NULL, NULL);

  g_return_val_if_fail(srvc->books != NULL, NULL);

  bl = map_collect_values(srvc->books);

  for( ; bl; bl = g_list_delete_link(bl, bl)) {

    struct mwAddressBook *book = bl->data;

    ret = g_list_concat(ret, map_collect_values(book->dirs));

  }

  return ret;

}

GList *mwAddressBook_getDirectories(struct mwAddressBook *book) {

  g_return_val_if_fail(book != NULL, NULL);

  g_return_val_if_fail(book->dirs != NULL, NULL);

  return map_collect_values(book->dirs);

}

const char *mwAddressBook_getName(struct mwAddressBook *book) {

  g_return_val_if_fail(book != NULL, NULL);

  return book->name;

}

struct mwDirectory *mwDirectory_new(struct mwAddressBook *book) {

  struct mwDirectory *dir;

  g_return_val_if_fail(book != NULL, NULL);

  g_return_val_if_fail(book->service != NULL, NULL);

  dir = g_new0(struct mwDirectory, 1);

  dir->service = book->service;

  dir->book = book;

  dir->state = mwDirectory_NEW;

  return dir;

}

enum mwDirectoryState mwDirectory_getState(struct mwDirectory *dir) {

  g_return_val_if_fail(dir != NULL, mwDirectory_UNKNOWN);

  return dir->state;

}

void mwDirectory_setClientData(struct mwDirectory *dir,

			       gpointer data, GDestroyNotify clear) {

  g_return_if_fail(dir != NULL);

  mw_datum_set(&dir->client_data, data, clear);

}

gpointer mwDirectory_getClientData(struct mwDirectory *dir) {

  g_return_val_if_fail(dir != NULL, NULL);

  return mw_datum_get(&dir->client_data);

}

void mwDirectory_removeClientData(struct mwDirectory *dir) {

  g_return_if_fail(dir != NULL);

  mw_datum_clear(&dir->client_data);

}

struct mwServiceDirectory *mwDirectory_getService(struct mwDirectory *dir) {

  g_return_val_if_fail(dir != NULL, NULL);

  g_return_val_if_fail(dir->book != NULL, NULL);

  return dir->book->service;

}

struct mwAddressBook *mwDirectory_getAddressBook(struct mwDirectory *dir) {

  g_return_val_if_fail(dir != NULL, NULL);

  return dir->book;

}

static int dir_open(struct mwDirectory *dir) {

  struct mwServiceDirectory *srvc;

  struct mwChannel *chan;

  struct mwPutBuffer *b;

  struct mwOpaque o;

  int ret;

  g_return_val_if_fail(dir != NULL, -1);

  srvc = dir->service;

  g_return_val_if_fail(srvc != NULL, -1);

  chan = srvc->channel;

  g_return_val_if_fail(chan != NULL, -1);

  b = mwPutBuffer_new();

  guint32_put(b, map_request(dir));

  /* unsure about these three bytes */

  gboolean_put(b, FALSE);

  guint16_put(b, 0x0000);

  guint32_put(b, dir->book->id);

  mwString_put(b, dir->book->name);

  mwPutBuffer_finalize(&o, b);

  ret = mwChannel_send(chan, action_open, &o);

  mwOpaque_clear(&o);

  return ret;

}

int mwDirectory_open(struct mwDirectory *dir, mwSearchHandler cb) {

  g_return_val_if_fail(dir != NULL, -1);

  g_return_val_if_fail(cb != NULL, -1);

  g_return_val_if_fail(MW_DIRECTORY_IS_NEW(dir), -1);

  dir->state = mwDirectory_PENDING;

  dir->handler = cb;

  return dir_open(dir);

}

int mwDirectory_next(struct mwDirectory *dir) {  

  struct mwServiceDirectory *srvc;

  struct mwChannel *chan;

  struct mwPutBuffer *b;

  struct mwOpaque o;

  int ret;

  g_return_val_if_fail(dir != NULL, -1);

  g_return_val_if_fail(MW_DIRECTORY_IS_OPEN(dir), -1);

  srvc = dir->service;

  g_return_val_if_fail(srvc != NULL, -1);

  chan = srvc->channel;

  g_return_val_if_fail(chan != NULL, -1);

  b = mwPutBuffer_new();

  guint32_put(b, map_request(dir));

  guint32_put(b, dir->id);

  guint16_put(b, 0xffff);      /* some magic? */

  guint32_put(b, 0x00000000);  /* next results */

  mwPutBuffer_finalize(&o, b);

  ret = mwChannel_send(chan, action_search, &o);

  mwOpaque_clear(&o);

  return ret;

}

int mwDirectory_previous(struct mwDirectory *dir) {

  struct mwServiceDirectory *srvc;

  struct mwChannel *chan;

  struct mwPutBuffer *b;

  struct mwOpaque o;

  int ret;

  g_return_val_if_fail(dir != NULL, -1);

  g_return_val_if_fail(MW_DIRECTORY_IS_OPEN(dir), -1);

  srvc = dir->service;

  g_return_val_if_fail(srvc != NULL, -1);

  chan = srvc->channel;

  g_return_val_if_fail(chan != NULL, -1);

  b = mwPutBuffer_new();

  guint32_put(b, map_request(dir));

  guint32_put(b, dir->id);

  guint16_put(b, 0x0061);      /* some magic? */

  guint32_put(b, 0x00000001);  /* prev results */

  mwPutBuffer_finalize(&o, b);

  ret = mwChannel_send(chan, action_search, &o);

  mwOpaque_clear(&o);

  return ret;

}

int mwDirectory_search(struct mwDirectory *dir, const char *query) {

  struct mwServiceDirectory *srvc;

  struct mwChannel *chan;

  struct mwPutBuffer *b;

  struct mwOpaque o;

  int ret;

  g_return_val_if_fail(dir != NULL, -1);

  g_return_val_if_fail(MW_DIRECTORY_IS_OPEN(dir), -1);

  g_return_val_if_fail(query != NULL, -1);

  g_return_val_if_fail(*query != '\0', -1);

  srvc = dir->service;

  g_return_val_if_fail(srvc != NULL, -1);

  chan = srvc->channel;

  g_return_val_if_fail(chan != NULL, -1);

  b = mwPutBuffer_new();

  guint32_put(b, map_request(dir));

  guint32_put(b, dir->id);

  guint16_put(b, 0x0061);      /* some magic? */

  guint32_put(b, 0x00000008);  /* seek results */

  mwString_put(b, query);

  mwPutBuffer_finalize(&o, b);

  ret = mwChannel_send(chan, action_search, &o);

  mwOpaque_clear(&o);

  return ret;

}

static int dir_close(struct mwDirectory *dir) {

  struct mwServiceDirectory *srvc;

  struct mwChannel *chan;

  struct mwPutBuffer *b;

  struct mwOpaque o;

  int ret;

  g_return_val_if_fail(dir != NULL, -1);

  srvc = dir->service;

  g_return_val_if_fail(srvc != NULL, -1);

  chan = srvc->channel;

  g_return_val_if_fail(chan != NULL, -1);

  b = mwPutBuffer_new();

  guint32_put(b, next_request_id(dir->service));

  guint32_put(b, dir->id);

  mwPutBuffer_finalize(&o, b);

  ret = mwChannel_send(chan, action_close, &o);

  mwOpaque_clear(&o);

  return ret;

}

int mwDirectory_destroy(struct mwDirectory *dir) {

  int ret = 0;

  g_return_val_if_fail(dir != NULL, -1);

  if(MW_DIRECTORY_IS_OPEN(dir) || MW_DIRECTORY_IS_PENDING(dir)) {

    ret = dir_close(dir);

  }

  dir_remove(dir);

  return ret;

}