/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qcontactmaemo5backend_p.h"

#include "qcontactabook_p.h"

#include <QEventLoop>

#include <libebook/e-book-util.h>

/* Error handling Macros */

#define FATAL_IF_ERROR(x) if(x) { \

                            QString message(x->message); \

                            g_error_free(x); \

                            qFatal(qPrintable(message)); \

                          }

#define WARNING_IF_ERROR(x) if(x) { \

                            QString message(x->message); \

                            g_error_free(x); \

                            qWarning(qPrintable(message)); \

                          }

/* Casting Macros */

#define A_CONTACT(x) reinterpret_cast<OssoABookContact*>(x)

#define A_ROSTER(x) reinterpret_cast<OssoABookRoster*>(x)

#define CONST_CHAR(x) static_cast<const char*>(x)

#define FREE(x) free((void*)x)

struct cbSharedData{

  QContactIDsHash* hash;

  QContactABook *that;

};

struct jobSharedData{

   QContactABook* that;

   bool *result;

   char *uid;

   QContactManager::Error *error;

};

/* QContactABook */

QContactABook::QContactABook(QObject* parent) :QObject(parent), m_cbSD(0), m_deleteJobSD(0), m_saveJobSD(0)

{

  //Initialize QContactDetail context list

  initAddressBook();

}

QContactABook::~QContactABook()

{

  OssoABookAggregator *roster = reinterpret_cast<OssoABookAggregator*>(m_abookAgregator);

  if (g_signal_handler_is_connected(roster, m_contactAddedHandlerId))

      g_signal_handler_disconnect(roster, m_contactAddedHandlerId);

  if (g_signal_handler_is_connected(roster, m_contactChangedHandlerId))

      g_signal_handler_disconnect(roster, m_contactChangedHandlerId);

  if (g_signal_handler_is_connected(roster, m_contactRemovedHandlerId))

      g_signal_handler_disconnect(roster, m_contactRemovedHandlerId);

  // XXX FIXME: memory leak?

  //g_object_unref(m_abookAgregator);

  delete m_cbSD;

  m_cbSD = 0;

  delete m_deleteJobSD;

  m_deleteJobSD = 0;

  delete m_saveJobSD;

  m_saveJobSD = 0;

}

static void contactsAddedCB(OssoABookRoster *roster, OssoABookContact **contacts, gpointer data)

{

  QCM5_DEBUG << "CONTACT ADDED";

  Q_UNUSED(roster)

  cbSharedData* d = static_cast<cbSharedData*>(data);

  if (!d){

    //qWarning() << "d has been deleted";

    return;

  }

  OssoABookContact **p;

  QList<QContactLocalId> contactIds;

  for (p = contacts; *p; ++p) {

    if (osso_abook_contact_is_roster_contact(*p))

      continue;

    // Add a new localID to the local ID hash

    const char* uid = CONST_CHAR(e_contact_get_const(E_CONTACT(*p), E_CONTACT_UID));

    QContactLocalId id = d->hash->append(uid);

    if (id)

      contactIds << id;

  }

  if (!contactIds.isEmpty())

    d->that->_contactsAdded(contactIds);

}

static void contactsChangedCB(OssoABookRoster *roster, OssoABookContact **contacts, gpointer data)

{

  QCM5_DEBUG << "CONTACT CHANGED";

  Q_UNUSED(roster)

  cbSharedData* d = static_cast<cbSharedData*>(data);

  if (!d){

    //qWarning() << "d has been deleted";

    return;

  }

  OssoABookContact **p;

  QList<QContactLocalId> contactIds;

  for (p = contacts; *p; ++p) {

    if (osso_abook_contact_is_roster_contact(*p))

      continue;

    const char* uid = CONST_CHAR(e_contact_get_const(E_CONTACT(*p), E_CONTACT_UID));

    QContactLocalId id = d->hash->find(uid);

    //FREE(uid);

    if (id)

      contactIds << id;

  }

  if (!contactIds.isEmpty())

    d->that->_contactsChanged(contactIds);

}

static void contactsRemovedCB(OssoABookRoster *roster, const char **ids, gpointer data)

{

  QCM5_DEBUG << "CONTACT REMOVED";

  Q_UNUSED(roster)

  cbSharedData* d = static_cast<cbSharedData*>(data);

  if (!d){

    //qWarning() << "d has been deleted";

    return;

  }

  const char **p;

  QList<QContactLocalId> contactIds;

  for (p = ids; *p; ++p) {

      QContactLocalId id = d->hash->take(*p);

      if (id) {

        QCM5_DEBUG << "Contact" << id << "has been removed";

        contactIds << id;

      }

  }

  if (!contactIds.isEmpty())

    d->that->_contactsRemoved(contactIds);

}

void QContactABook::initAddressBook(){

  /* Open AddressBook */

  GError *gError = NULL;

  OssoABookRoster* roster = NULL;

  roster = osso_abook_aggregator_get_default(&gError);

  FATAL_IF_ERROR(gError)

  osso_abook_waitable_run((OssoABookWaitable *) roster, g_main_context_default(), &gError);

  FATAL_IF_ERROR(gError)

  if (!osso_abook_waitable_is_ready ((OssoABookWaitable *) roster, &gError))

    FATAL_IF_ERROR(gError)

  m_abookAgregator = reinterpret_cast<OssoABookAggregator*>(roster);

  /* Initialize local Id Hash */

  initLocalIdHash();

  /* Initialize callbacks shared data */

  m_cbSD = new cbSharedData;

  m_cbSD->hash = &m_localIds;

  m_cbSD->that = this;

  /* Setup signals */

  m_contactAddedHandlerId = g_signal_connect(roster, "contacts-added",

                   G_CALLBACK (contactsAddedCB), m_cbSD);

  m_contactChangedHandlerId = g_signal_connect(roster, "contacts-changed",

                   G_CALLBACK (contactsChangedCB), m_cbSD);

  m_contactRemovedHandlerId = g_signal_connect(roster, "contacts-removed",

                   G_CALLBACK (contactsRemovedCB), m_cbSD);

#if 0

  //TEST List supported fields

  EBook *book = NULL;

  GList *l;

  book = osso_abook_roster_get_book(roster);

  e_book_get_supported_fields (book, &l, NULL);

  while (l) {

    qDebug() << "SUPPORTED FIELD" << (const char*)l->data;

    l = l->next;  

  }

  g_list_free(l);

#endif

}

/*! Fill LocalId Hash associating an internal QContactLocalId to any

 *  master contact ID.

 *  NOTE: master contact IDs are string like "1" or "osso-abook-tmc1".

 */

void QContactABook::initLocalIdHash()

{  

   GList *contactList = NULL;

   GList *node;

   contactList = osso_abook_aggregator_list_master_contacts(m_abookAgregator);

   if (!contactList) {

     //qWarning() << "There are no Master contacts. LocalId hash is empty.";

     return;

   }

   for (node = contactList; node != NULL; node = g_list_next (node)) {

     EContact *contact = E_CONTACT(node->data);

     const char* data = CONST_CHAR(e_contact_get_const(contact, E_CONTACT_UID));

     QByteArray eContactUID(data);

     //FREE(data);

     m_localIds << eContactUID; //FIXME MemLeak

     QCM5_DEBUG << "eContactID " << eContactUID << "has been stored in m_localIDs with key" << m_localIds[eContactUID];

     // Useful for debugging.

     if (QCM5_DEBUG_ENABLED) e_vcard_dump_structure((EVCard*)contact);

   }

   g_list_free(contactList);

}

QList<QContactLocalId> QContactABook::contactIds(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders, QContactManager::Error* error) const

{

  QList<QContactLocalId> rtn;

  // do this naively for now...

  *error = QContactManager::NoError;

  QContactManager::Error tempError = QContactManager::NoError;

  QList<QContactLocalId> allIds = m_localIds.keys();

  QList<QContact> sortedAndFiltered;

  QContact *curr = 0;

  foreach (const QContactLocalId& currId, allIds) {

    curr = getQContact(currId, &tempError);

    if (tempError != QContactManager::NoError)

      *error = tempError;

    if (QContactManagerEngine::testFilter(filter, *curr)) {

      QContactManagerEngine::addSorted(&sortedAndFiltered, *curr, sortOrders);

    }

    delete curr;

  }

  foreach (const QContact& contact, sortedAndFiltered) {

    rtn.append(contact.localId());

  }

  return rtn;

  /*

  // Sorting

  //NOTE Native sorting is possible thanks to g_list_sort.

  //     It's limited just to one filter.

  //     Multi filters support need non native sorting.

  //     Native filtering needs a lot of coding since we need

  //     detailDefinitionName * detailFieldName functions

  //     to compare couple of contacts

  if (sortOrders.count()){

    QCM5_DEBUG << "Sorting...";

    // We don't need 

    // Fill Ids

    QList<QContactLocalId> Ids;

    {

      QList<QContactSortOrder> so;

      QContactManager::Error e;

      Ids = contactIds(filter, so, &e);

    }

    // Fill Contact List

    QList<QContact> contacts;

    foreach(QContactLocalId id, Ids){

      QContact *c;

      QContactManager::Error e;

      c = getQContact(id, &e);

      if (e == QContactManager::NoError)

	contacts << *c;

      else

        *error = e;

    }

    // Non native sorting

    return QContactManagerEngine::sortContacts(contacts, sortOrders);

  }

  EBookQuery* query = convert(filter);

  GList* l = osso_abook_aggregator_find_contacts(m_abookAgregator, query);

  if (query)

      e_book_query_unref(query);

  while (l){

    EContact *contact = E_CONTACT(l->data);

    const char* data = CONST_CHAR(e_contact_get_const(contact, E_CONTACT_UID));

    QByteArray localId(data);

    m_localIds << localId;

    rtn.append(m_localIds[localId]);

    QCM5_DEBUG << "eContactID " << localId << "has been stored in m_localIDs with key" << m_localIds[localId];

    l = g_list_delete_link(l, l);

  }

  *error = QContactManager::NoError;

  return rtn;

  */

}

QContact* QContactABook::getQContact(const QContactLocalId& contactId, QContactManager::Error* error) const

{

  QContact *rtn;

  OssoABookContact* aContact = getAContact(contactId, error);

  if (!aContact) {

    //qWarning() << "Unable to get a valid AContact";

    return new QContact;

  }

  //Convert aContact => qContact

  rtn = convert(E_CONTACT(aContact));

  QContactId cId;

  cId.setLocalId(contactId);

  rtn->setId(cId);

  return rtn;

}

static QContactManager::Error getErrorFromStatus(const EBookStatus status){

  switch (status) {

    case E_BOOK_ERROR_OK:

      return QContactManager::NoError;

    case E_BOOK_ERROR_INVALID_ARG:

      return QContactManager::BadArgumentError;

    case E_BOOK_ERROR_BUSY:

      return QContactManager::LockedError;        

    case E_BOOK_ERROR_PERMISSION_DENIED:

    case E_BOOK_ERROR_AUTHENTICATION_FAILED:

    case E_BOOK_ERROR_AUTHENTICATION_REQUIRED:

    //case E_BOOK_ERROR_UNSUPPORTED_AUTHENTICATION_METHOD: //Missing in current Maemo5 Ebook lib version

      return QContactManager::PermissionsError;

    case E_BOOK_ERROR_CONTACT_NOT_FOUND:

      return QContactManager::DoesNotExistError;

    case E_BOOK_ERROR_CONTACT_ID_ALREADY_EXISTS:

      return QContactManager::AlreadyExistsError;

    case E_BOOK_ERROR_NO_SPACE:

      return QContactManager::OutOfMemoryError;

#if 0

    case E_BOOK_ERROR_REPOSITORY_OFFLINE:

    case E_BOOK_ERROR_NO_SUCH_BOOK:

    case E_BOOK_ERROR_NO_SELF_CONTACT:

    case E_BOOK_ERROR_SOURCE_NOT_LOADED:

    case E_BOOK_ERROR_SOURCE_ALREADY_LOADED:

    case E_BOOK_ERROR_PROTOCOL_NOT_SUPPORTED:

    case E_BOOK_ERROR_CANCELLED:

    case E_BOOK_ERROR_COULD_NOT_CANCEL:

    case E_BOOK_ERROR_TLS_NOT_AVAILABLE:

    case E_BOOK_ERROR_CORBA_EXCEPTION:

    case E_BOOK_ERROR_NO_SUCH_SOURCE:

    case E_BOOK_ERROR_OFFLINE_UNAVAILABLE:

    case E_BOOK_ERROR_OTHER_ERROR:

    case E_BOOK_ERROR_INVALID_SERVER_VERSION:

#endif

    default:

      return QContactManager::UnspecifiedError;

  }

}

static void delContactCB(EBook *book, EBookStatus status, gpointer closure)

{

  Q_UNUSED(book);

  QCM5_DEBUG << "Contact Removed";

  jobSharedData *sd = static_cast<jobSharedData*>(closure);

  if (!sd)

    return;

  *sd->result = (status != E_BOOK_ERROR_OK &&

                 status != E_BOOK_ERROR_CONTACT_NOT_FOUND) ? false : true;

  *sd->error = getErrorFromStatus(status);

  sd->that->_jobRemovingCompleted();

}

bool QContactABook::removeContact(const QContactLocalId& contactId, QContactManager::Error* error)

{

  Q_UNUSED(error);

  QMutexLocker locker(&m_delContactMutex);

  bool ok = false;

  OssoABookRoster *roster = A_ROSTER(m_abookAgregator);

  EBook *book = osso_abook_roster_get_book(roster);

  OssoABookContact *aContact = getAContact(contactId, error);

  if (!OSSO_ABOOK_IS_CONTACT(aContact)){

    //qWarning() << "Specified contact is not a valid ABook contact";

    return false;

  }

  // ASync => Sync

  QEventLoop loop;                           

  connect(this, SIGNAL(jobRemovingCompleted()), &loop, SLOT(quit()));

  // Prepare shared data

  if (m_deleteJobSD){

    delete m_deleteJobSD;

    m_deleteJobSD = 0;

  }

  m_deleteJobSD = new jobSharedData;

  m_deleteJobSD->that = this;

  m_deleteJobSD->result = &ok;

  m_deleteJobSD->error = error;

  //Remove photos

  EContactPhoto *photo = NULL;

  GFile *file = NULL;

  photo = (EContactPhoto*) e_contact_get(E_CONTACT (aContact), E_CONTACT_PHOTO);

  if (photo) {

    if (photo->type == E_CONTACT_PHOTO_TYPE_URI && photo->data.uri) {

      file = g_file_new_for_uri(photo->data.uri);

      g_file_delete(file, NULL, NULL);

      g_object_unref (file);

    }

    e_contact_photo_free (photo);

  }

  //Remove all roster contacts from their roster

  GList* rosterContacts = NULL;

  rosterContacts = osso_abook_contact_get_roster_contacts(aContact);

  const char *masterUid = CONST_CHAR(e_contact_get_const(E_CONTACT(aContact), E_CONTACT_UID));

  char *contactUidCopy = strdup(masterUid);

  while(rosterContacts){

    OssoABookContact *rosterContact = A_CONTACT(rosterContacts->data);

    osso_abook_contact_reject_for_uid(rosterContact, masterUid, NULL);

    rosterContacts = rosterContacts->next;

  }  

  // Remove contact

  e_book_async_remove_contact(book, E_CONTACT(aContact),

                              delContactCB, m_deleteJobSD);

  loop.exec(QEventLoop::AllEvents|QEventLoop::WaitForMoreEvents);

  // update our list of ids...

  QContactLocalId id = m_localIds[contactUidCopy];

  m_localIds.remove(contactUidCopy);

  if (contactUidCopy)

    free(contactUidCopy);

  if (id)

    _contactsRemoved(QList<QContactLocalId>() << id);

  return ok;

}

static void commitContactCB(EBook* book, EBookStatus  status, gpointer user_data)

{

  Q_UNUSED(book)

  jobSharedData *sd = static_cast<jobSharedData*>(user_data);

  if (!sd)

    return;

  *sd->result = (status == E_BOOK_ERROR_OK) ? true : false;

  *sd->error = getErrorFromStatus(status);

  sd->that->_jobSavingCompleted();

}

static void addContactCB(EBook* book, EBookStatus  status, const char  *uid, gpointer user_data)

{

  jobSharedData *sd = static_cast<jobSharedData*>(user_data);

  if (!sd)

    return;

  if (uid)

    sd->uid = strdup(uid);

  //### FIXME IS THIS LINE REALLY NEEDED: osso_abook_contact_set_roster(OssoABookContact *contact, OssoABookRoster *roster)

  *sd->result = (status == E_BOOK_ERROR_OK) ? true : false;

  commitContactCB(book, status, user_data);

}