/*
 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description: canotifier.cpp
 *
 */

#include <caservice.h>

#include "canotifier.h"
#include "canotifier_p.h"
#include "canotifierfilter.h"
#include "caclientnotifierproxy.h"
#include "caobserver.h"

/*!
 \class CaNotifier.
 \brief This class describes notifier.

 \example
 It's example how client can be notified about changes on data specified by client's filter

 \code
 // example Client class which wants to be notified about changes

 class Client: public QObject
 {
 Q_OBJECT
 ...
 public slots:

 updateModelForEntryChanged(int,ChangeType);
 updateModelForEntryChanged(const CaEntry &,ChangeType);
 updateModelForEntryTouched(int);
 updateModelForgroupContentChanged(int);
 ...
 };
 \endcode

 \code
 // example code showed how to register for notifications
 Client * client;
 ...
 QSharedPointer<CaService> service = CaService::instance();
 CaNotifierFilter notifierFilter();
 CaNotifier * notifier = service->createNotifier(notifierfilter);

CaService instance is a singleton and is deleted when nothing references
it but CaNotifier contains a member referencing it,
so, CaService instance is not deleted before notifier is deleted.

 // Connections cause that notifier is registered to server distributed
 // notifications while data changes.
 if( notifier )
 {
 connect( notifier, SIGNAL(entryChanged(int,ChangeType)),
 client, SLOT(updateModelForEntryChanged(int,ChangeType)) );
 connect( notifier, SIGNAL(entryChanged(CaEntry,ChangeType)),
 client, SLOT(updateModelForEntryChanged(CaEntry,ChangeType)) );
 connect( notifier, SIGNAL(entryTouched(int)),
 client, SLOT(updateModelForEntryTouched(int)) );
 connect( notifier, SIGNAL(groupContentChanged(int)),
 client, SLOT(updateModelForgroupContentChanged(int)) );
 }
 ...
 // creation new entry causes sent notification to the client
 CaEntry entry;
 entry.setText( "Text" );
 entry.setTypeName( "TypeName" );
 CaEntry * newEntry = service->createEntry( entry );
 ...
 \endcode

 \code
 // here client is being get notifications new entry was created
 ...
 Client::updateModelForEntryChanged(int entryId ,ChangeType changeType)
 {
 ...
 changeType == AddChangeType;
 ...
 }

 \endcode

 */

/*!
 \var CaNotifierPrivate::m_q
 Points to the CaNotifier instance that uses
 this private implementation.
 */

/*!
 \var CaNotifierPrivate::mNotifierFilter
 Own.
 */

/*!
 \var CaNotifierPrivate::mNotifierProxy
 Not own.
 */

/*!
 Constructor.
 \param entryPrivate pointer to private implementation.
 */
CaNotifier::CaNotifier(CaNotifierPrivate *const notifierPrivate) :
    QObject(0), m_d(notifierPrivate)
{
    m_d->m_q = this;
    m_d->makeConnect();
}

/*!
 Destructor.
 */
CaNotifier::~CaNotifier()
{
    m_d->unregisterNotifier(
                        CaNotifierPrivate::EntryChangedWithIdNotifierType);
    m_d->unregisterNotifier(
                        CaNotifierPrivate::EntryChangedWithEntryNotifierType);
    m_d->unregisterNotifier(
                        CaNotifierPrivate::EntryTouchedNotifierType);
    m_d->unregisterNotifier(
                        CaNotifierPrivate::GroupContentChangedNotifierType);
    delete m_d;
}

/*!
    This method is called when something has been
    connected to signal in this object.
    \param signal which is used to register an appropriate notifier.
*/
void CaNotifier::connectNotify(const char *signal)
{
    qDebug("CaNotifier::connectNotify");
    qDebug("\tsignal: %s", signal);
    if (QLatin1String(signal)
            == SIGNAL(entryChanged(int,ChangeType))) {
        // signal is entryChanged(int, ChangeType)
        if (receivers(SIGNAL(entryChanged(int,ChangeType))) == 1) {
            m_d->registerNotifier(
                CaNotifierPrivate::EntryChangedWithIdNotifierType);
        }
    } else if (QLatin1String(signal)
               == SIGNAL(entryChanged(CaEntry,ChangeType))) {
        // signal is entryChanged(const CaEntry &, ChangeType)
        if (receivers(SIGNAL(entryChanged(const CaEntry &,ChangeType))) == 1) {
            m_d->registerNotifier(
                CaNotifierPrivate::EntryChangedWithEntryNotifierType);
        }
    } else if (QLatin1String(signal)
               == SIGNAL(entryTouched(int))) {
        // signal is entryTouched(int)
        if (receivers(SIGNAL(entryTouched(int)))) {
            m_d->registerNotifier(
                CaNotifierPrivate::EntryTouchedNotifierType);
        }
    } else if (QLatin1String(signal)
               == SIGNAL(groupContentChanged(int))) {
        // signal is groupContentChanged(int)
        if (receivers(SIGNAL(groupContentChanged(int)))) {
            m_d->registerNotifier(
                CaNotifierPrivate::GroupContentChangedNotifierType);
        }
    }
}

/*!
    This method is called when something has been
    disconnected from signal in this object.
    \param signal which is used to unregister an appropriate notifier.
*/
void CaNotifier::disconnectNotify(const char *signal)
{
    qDebug("CaNotifier::disconnectNotify");
    qDebug("\tsignal: %s", signal);
    if (QLatin1String(signal)
            == SIGNAL(entryChanged(int,ChangeType))) {
        // signal is entryChanged(int, ChangeType)
        if (receivers(SIGNAL(entryChanged(int,ChangeType)))==0) {
            m_d->unregisterNotifier(
                CaNotifierPrivate::EntryChangedWithIdNotifierType);
        }
    } else if (QLatin1String(signal)
               == SIGNAL(entryChanged(CaEntry,ChangeType))) {
        // signal is entryChanged(const CaEntry &, ChangeType)
        if (receivers(SIGNAL(entryChanged(const CaEntry &,ChangeType)))==0) {
            m_d->unregisterNotifier(
                CaNotifierPrivate::EntryChangedWithEntryNotifierType);
        }
    } else if (QLatin1String(signal)
               == SIGNAL(entryTouched(int))) {
        // signal is entryTouched(int)
        if (receivers(SIGNAL(entryTouched(int))) == 0) {
            m_d->unregisterNotifier(
                CaNotifierPrivate::EntryTouchedNotifierType);
        }
    } else if (QLatin1String(signal)
               == SIGNAL(groupContentChanged(int))) {
        // signal is groupContentChanged(int)
        if (receivers(SIGNAL(groupContentChanged(int))) == 0) {
            m_d->unregisterNotifier(
                CaNotifierPrivate::GroupContentChangedNotifierType);
        }
    }
}

/*!
 Constructor.
 \param notifierFilter descrbies entries to observe.
 */
CaNotifierPrivate::CaNotifierPrivate(
    const CaNotifierFilter &notifierFilter, 
    CaClientNotifierProxy *notifierProxy) :
    m_q(NULL),
    mNotifierFilter(NULL), 
    mObserver(NULL),
    mCaService(CaService::instance())
{
    mNotifierProxy = notifierProxy;
    mNotifierFilter = new CaNotifierFilter(notifierFilter);
}

/*!
 Destructor.
 */
CaNotifierPrivate::~CaNotifierPrivate()
{
    if (mNotifierProxy) {
        mNotifierProxy->unregisterNotifier(*mNotifierFilter,
                                           EntryChangedWithIdNotifierType);
        mNotifierProxy->unregisterNotifier(*mNotifierFilter,
                                           EntryChangedWithEntryNotifierType);
        mNotifierProxy->unregisterNotifier(*mNotifierFilter,
                                           EntryTouchedNotifierType);
        mNotifierProxy->unregisterNotifier(*mNotifierFilter,
                                           GroupContentChangedNotifierType);
    }
    delete mNotifierFilter;
}
/*!
 Registers notifier
 \param notifierType type of notifier to register (class of events to listen)
 */
int CaNotifierPrivate::registerNotifier(NotifierType notifierType)
{
    if (mNotifierProxy) {
        return mNotifierProxy->registerNotifier(
                   mNotifierFilter,
                   notifierType,
                   mObserver);
    }
    return 0;
}
/*!
 Unregisters notifier
 \param notifierType type of notifier event type to unregister
     (class of events to listen)
 */
void CaNotifierPrivate::unregisterNotifier(NotifierType notifierType)
{
    if (mNotifierProxy) {
        mNotifierProxy->unregisterNotifier(*mNotifierFilter, notifierType);
    }
}

/*!
 Connects this Notifier
 */
void CaNotifierPrivate::makeConnect()
{
    if (m_q) {
        mObserver = new CaObserver();
        m_q->connect(mObserver,
                     SIGNAL(signalEntryChanged(int,ChangeType)),
                     m_q,
                     SIGNAL(entryChanged(int,ChangeType)));
        m_q->connect(mObserver,
                     SIGNAL(signalEntryChanged(const CaEntry &,ChangeType)),
                     m_q,
                     SIGNAL(entryChanged(const CaEntry &,ChangeType)));
        m_q->connect(mObserver,
                     SIGNAL(signalEntryTouched(int)),
                     m_q,
                     SIGNAL(entryTouched(int)));
        m_q->connect(mObserver,
                     SIGNAL(signalGroupContentChanged(int)),
                     m_q,
                     SIGNAL(groupContentChanged(int)));
    }
}