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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** 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;

};

/* 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;

  }

  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;

  }

  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);

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

    if (id)

      contactIds << id;

  }

  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;

  /* 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);

  }

  /* Matching action filter */

  //NOTE The code was not really tested */

  if(filter.type() == QContactFilter::ActionFilter){

    QContactActionFilter af(filter);

    /* This looks a bit strange for me */

    QList<QContactActionDescriptor> descriptors = QContactAction::actionDescriptors(af.actionName(), af.vendorName(), af.implementationVersion());

    GList *masterContacts = osso_abook_aggregator_list_master_contacts(m_abookAgregator);

    for(; masterContacts; ){

      OssoABookContact *masterContact = A_CONTACT(masterContacts->data);

      bool match = contactActionsMatch(masterContact, descriptors);

      if(!match) {

        GList *rosterContacts = osso_abook_contact_get_roster_contacts(masterContact);

        for(; rosterContacts && !match; ){

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

          match = contactActionsMatch(rosterContact, descriptors);

          rosterContacts = g_list_delete_link(rosterContacts, rosterContacts);

        }

        g_list_free(rosterContacts);

      }

      if(match){

        EContact *contact = E_CONTACT(masterContact);

        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];

      }

      masterContacts = g_list_delete_link(masterContacts, masterContacts);

    }

    *error = QContactManager::NoError;

    return  rtn;

  }

  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);

  if (!aContact) {

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

    *error = QContactManager::DoesNotExistError;

    return new QContact;

  }

  //Convert aContact => qContact

  rtn = convert(E_CONTACT(aContact));

  return rtn;

}

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->that->_jobRemovingCompleted();

}

//### FIXME error is not managed

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);

  if (!OSSO_ABOOK_IS_CONTACT(aContact)){

    qWarning() << "aCtontact 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;

  //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));

  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);

  return ok;

}

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

{

  Q_UNUSED(book)

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

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

  sd->that->_jobSavingCompleted();

}

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

{

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

  if (uid)

    sd->uid = strdup(uid);

  //osso_abook_contact_set_roster(OssoABookContact *contact, OssoABookRoster *roster)

  commitContactCB(book, status, user_data);

}

bool QContactABook::saveContact(QContact* contact, QContactManager::Error* error)

{

  QMutexLocker locker(&m_saveContactMutex);

  if (!contact) {

    *error = QContactManager::BadArgumentError;

    return false;

  }

  bool ok = false;

  OssoABookContact *aContact = NULL;

  const char *uid;

  EBook *book;

  {

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

    book = osso_abook_roster_get_book(roster);

  }

  // Conver QContact to AContact

  aContact = convert(contact);

  if (!aContact){

    *error = QContactManager::UnspecifiedError;

    return false;

  }  

  // ASync => Sync

  QEventLoop loop;

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

  // Prepare shared data

  if (m_saveJobSD){

    delete m_saveJobSD;

    m_saveJobSD = 0;

  }

  m_saveJobSD = new jobSharedData;

  m_saveJobSD->that = this;

  m_saveJobSD->result = &ok;

  // Add/Commit the contact

  uid = CONST_CHAR(e_contact_get_const(E_CONTACT (aContact), E_CONTACT_UID)); 

  if (uid) {

    osso_abook_contact_async_commit(aContact, book, commitContactCB, m_saveJobSD);

  } else {

    osso_abook_contact_async_add(aContact, book, addContactCB, m_saveJobSD);

  }

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

  // set the id of the contact.

  QContactId cId;

  cId.setLocalId(m_localIds[m_saveJobSD->uid]);

  contact->setId(cId);

  //free(m_saveJobSD->uid);

  return ok;

}

QContactLocalId QContactABook::selfContactId(QContactManager::Error* errors) const

{

  QContactLocalId id;

  EContact *self = E_CONTACT(osso_abook_self_contact_get_default());

  if (self) {

    *errors = QContactManager::NoError;

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

    const QByteArray eContactUID(data);

    QContactLocalId localId = m_localIds[eContactUID];