/*

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

 *

 */

#include <QModelIndex>

#include <QDateTime>

#include <QDir>

#include <hbdataform.h>

#include <hbdataformmodel.h>

#include <hbmainwindow.h>

//#include <hbstyleoptioncommonnote.h> //<hbcommonnote.h> this new header compensate oldone ??

#include <HbDataFormModelItem.h>

#include <hbdataformviewitem.h>

#include <hblineedit.h>

#include <HbComboBox.h>

#include <HbPushButton.h>

#include <HbAbstractButton.h>

#include <HbLineEdit.h>

#include <xqsettingsmanager.h>

#include <xqsettingskey.h>

#include <XQServiceUtil.h>

#include <nsmloperatorerrorcrkeys.h>

#include <DataSyncInternalPSKeys.h>

#include "qtsyncstatusmodel.h"

#include "qtsyncstatuslog.h"

QtSyncStatusModel::QtSyncStatusModel(QtSyncStatusLog& log, HbDataForm *form, QObject *parent)

:QObject(parent),

 mSettingsForm(form),

 mSettingsModel(0),

 mSyncLog(log)

{

    connect(mSettingsForm, SIGNAL(activated(const QModelIndex)),

            this, SLOT(itemDisplayed(const QModelIndex)));

    mSettingsManager = new XQSettingsManager(this);

    mNsmlOpDsSyncErrorCode = new XQSettingsKey(XQSettingsKey::TargetCentralRepository,

            KCRUidOperatorDatasyncErrorKeys.iUid, KNsmlOpDsSyncErrorCode);

    mSettingsManager->startMonitoring(*mNsmlOpDsSyncErrorCode);

    mNsmlOpDsSyncProfUid = new XQSettingsKey(XQSettingsKey::TargetCentralRepository,

            KCRUidOperatorDatasyncErrorKeys.iUid, KNsmlOpDsSyncProfId);

    mSettingsManager->startMonitoring(*mNsmlOpDsSyncProfUid);

    mNsmlOpDsSyncType = new XQSettingsKey(XQSettingsKey::TargetCentralRepository,

            KCRUidOperatorDatasyncErrorKeys.iUid, KNsmlOpDsSyncType);

    mSettingsManager->startMonitoring(*mNsmlOpDsSyncType);

    mNsmlOpDsSyncInitiation = new XQSettingsKey(XQSettingsKey::TargetCentralRepository,

            KCRUidOperatorDatasyncErrorKeys.iUid, KNsmlOpDsSyncInitiation);

    mSettingsManager->startMonitoring(*mNsmlOpDsSyncInitiation);

    mDataSyncStatusKey = new XQSettingsKey(XQSettingsKey::TargetPublishAndSubscribe,

            KPSUidDataSynchronizationInternalKeys.iUid, KDataSyncStatus);

    connect(mSettingsManager, SIGNAL(valueChanged(const XQSettingsKey&, const QVariant&)),

            this, SLOT(valueChanged(const XQSettingsKey&, const QVariant&)));

    // Read the initial values from the cenrep

    QVariant value = mSettingsManager->readItemValue(*mNsmlOpDsSyncErrorCode);

    mSyncErrorCode = value.toUInt();

    value = mSettingsManager->readItemValue(*mNsmlOpDsSyncProfUid);

    mSyncProfileUid = value.toUInt();

    value = mSettingsManager->readItemValue(*mNsmlOpDsSyncType);

    mSyncType = value.toUInt();

    value = mSettingsManager->readItemValue(*mNsmlOpDsSyncInitiation);

    mSyncInitiation = value.toUInt();

}

QtSyncStatusModel::~QtSyncStatusModel()

{

    delete mSettingsModel;

    delete mSettingsManager;

    delete mNsmlOpDsSyncErrorCode;

    delete mNsmlOpDsSyncProfUid;

    delete mNsmlOpDsSyncType;

    delete mNsmlOpDsSyncInitiation;

    delete mDataSyncStatusKey;

}

void QtSyncStatusModel::initModel()

{

    // Remove the model.

    if (mSettingsForm->model()) {

        delete mSettingsForm->model();

        mSettingsForm->setModel(0);

        mSettingsModel = 0;

    }

    mSettingsModel = new HbDataFormModel();

    mNsmlOpDsSyncErrorCodeItem = new HbDataFormModelItem(

            HbDataFormModelItem::TextItem, QString( tr("Sync error code") ), 0);

    QString errorCode;

    errorCode.setNum(mSyncErrorCode);

    mNsmlOpDsSyncErrorCodeItem->setContentWidgetData( "text", errorCode );

    mNsmlOpDsSyncErrorCodeItem->setContentWidgetData( QString("readOnly"), QString("false") );

    mSettingsModel->appendDataFormItem(mNsmlOpDsSyncErrorCodeItem);

    mNsmlOpDsSyncProfUidItem = new HbDataFormModelItem(

            HbDataFormModelItem::TextItem, QString(tr("Sync profile ID")), 0);

            //HbDataFormModelItem::TextItem, QString(tr("Sync profile ID")), mSettingsModel->invisibleRootItem());

    QString profileUId;

    profileUId.setNum(mSyncProfileUid);

    mNsmlOpDsSyncProfUidItem->setContentWidgetData( "text", profileUId );

    mNsmlOpDsSyncProfUidItem->setContentWidgetData( QString("readOnly"), QString("false") );

    mSettingsModel->appendDataFormItem(mNsmlOpDsSyncProfUidItem);

    QStringList syncTypes;

    syncTypes << tr("ESmlTwoWay")

               << tr("ESmlOneWayFromServer")

               << tr("ESmlOneWayFromClient")

               << tr("ESmlSlowSync")

               << tr("ESmlRefreshFromServer")

               << tr("ESmlRefreshFromClient");

    mNsmlOpDsSyncTypeItem = new HbDataFormModelItem();

    mNsmlOpDsSyncTypeItem->setType(HbDataFormModelItem::ComboBoxItem);

    mNsmlOpDsSyncTypeItem->setData(HbDataFormModelItem::LabelRole, QString(tr("Sync type")));

    mNsmlOpDsSyncTypeItem->setContentWidgetData(QString("items"), syncTypes);

    mNsmlOpDsSyncTypeItem->setContentWidgetData(QString("currentIndex"), mSyncType);

    mSettingsModel->appendDataFormItem(mNsmlOpDsSyncTypeItem);

    QStringList syncInitiation;

    syncInitiation << tr("No sync ongoing")

               << tr("Client initiated")

               << tr("Server alerted");

    mNsmlOpDsSyncInitiationItem = new HbDataFormModelItem();

    mNsmlOpDsSyncInitiationItem->setType(HbDataFormModelItem::ComboBoxItem);

    mNsmlOpDsSyncInitiationItem->setData(HbDataFormModelItem::LabelRole, QString(tr("Sync initiation")));

    mNsmlOpDsSyncInitiationItem->setContentWidgetData(QString("items"), syncInitiation);

    mNsmlOpDsSyncInitiationItem->setContentWidgetData(QString("currentIndex"), mSyncInitiation);

    mSettingsModel->appendDataFormItem(mNsmlOpDsSyncInitiationItem);

    mSettingsForm->setModel(mSettingsModel);

}

void QtSyncStatusModel::itemDisplayed(const QModelIndex &index)

{   

    //HbDataFormModelItem *data = static_cast<HbDataFormModelItem*>(index.internalPointer());

    HbDataFormViewItem *viewItem = static_cast<HbDataFormViewItem*>( mSettingsForm->itemByIndex(index) );

    switch (index.row())

        {

        case 0:

            {

            HbWidget* contentWidget = viewItem->dataItemContentWidget();

            mSyncErrorCodeEdit = static_cast<HbLineEdit *>(contentWidget);

            mSyncErrorCodeEdit->setInputMethodHints(Qt::ImhPreferNumbers);

            connect(mSyncErrorCodeEdit, SIGNAL(editingFinished()),

                    this, SLOT(handleSyncMLErrorCodeChangeFinished()));

            break;

            }

        case 1:

            {

            HbWidget* contentWidget = viewItem->dataItemContentWidget();

            mSyncProfileUidEdit = static_cast<HbLineEdit *>(contentWidget);

            mSyncProfileUidEdit->setInputMethodHints(Qt::ImhPreferNumbers);

            connect(mSyncProfileUidEdit, SIGNAL(editingFinished()),

                    this, SLOT(handleProfileUidChangeFinished()));            

            break;

            }

        case 2:

            {

            HbWidget* contentWidget = viewItem->dataItemContentWidget();

            mmSyncTypeComboBox = static_cast<HbComboBox *>(contentWidget);

            connect(mmSyncTypeComboBox, SIGNAL(currentIndexChanged(int)),

                    this, SLOT(handleSyncTypeChange(int)));                

            break;

            }

        case 3:

            {

            HbWidget* contentWidget = viewItem->dataItemContentWidget();

            mSyncInitiationComboBox = static_cast<HbComboBox *>(contentWidget);

            connect(mSyncInitiationComboBox, SIGNAL(currentIndexChanged(int)),

                    this, SLOT(handleSyncInitiationChange(int)));                

            break;

            }

        default:

        break;

        }

}

void QtSyncStatusModel::handleSyncErrorCodeChangeFinished()

{

    mSettingsManager->writeItemValue(*mNsmlOpDsSyncErrorCode, mSyncErrorCodeEdit->text().toInt()); 

}

void QtSyncStatusModel::handleProfileUidChangeFinished()

{

    mSettingsManager->writeItemValue(*mNsmlOpDsSyncProfUid, mSyncProfileUidEdit->text().toInt());

}

void QtSyncStatusModel::handleSyncTypeChange(int index)

{

    mSettingsManager->writeItemValue(*mNsmlOpDsSyncType, index);

}

void QtSyncStatusModel::handleSyncInitiationChange(int index)

{

    mSettingsManager->writeItemValue(*mNsmlOpDsSyncInitiation, index);

}

void QtSyncStatusModel::valueChanged(const XQSettingsKey& key, const QVariant& value)

{

    QDateTime dt = QDateTime::currentDateTime();

    QString logLine;

    unsigned long int crKey = key.key();

    if (crKey == mNsmlOpDsSyncErrorCode->key()) {

        mSyncErrorCode = value.toUInt();

        QString errorCode;

        errorCode.setNum(mSyncErrorCode);

        mNsmlOpDsSyncErrorCodeItem->setContentWidgetData( "text", errorCode );

        logLine.append("[" + dt.toString("dd.MM.yyyy hh:mm:ss") + "] [SyncErrCode: " + errorCode + "]\r\n");

    }

    else if (crKey == mNsmlOpDsSyncProfUid->key()) {

        mSyncProfileUid = value.toUInt();

        QString profileUId;

        profileUId.setNum(mSyncProfileUid);

        mNsmlOpDsSyncProfUidItem->setContentWidgetData( "text", profileUId );

        logLine.append("[" + dt.toString("dd.MM.yyyy hh:mm:ss") + "] [SyncProfileId: " + profileUId + "]\r\n");

    }

    else if (crKey == mNsmlOpDsSyncType->key()) {

        mSyncType = value.toUInt();

        QString syncType;

        syncType.setNum(mSyncType);

        mNsmlOpDsSyncTypeItem->setContentWidgetData(QString("currentIndex"), mSyncType);

        logLine.append("[" + dt.toString("dd.MM.yyyy hh:mm:ss") + "] [SyncType: " + syncType + "]\r\n");

    }

    else if (crKey == mNsmlOpDsSyncInitiation->key()) {

        mSyncInitiation = value.toUInt();

        QString syncInitiation;

        syncInitiation.setNum(mSyncInitiation);

        mNsmlOpDsSyncInitiationItem->setContentWidgetData(QString("currentIndex"), mSyncInitiation);

        logLine.append("[" + dt.toString("dd.MM.yyyy hh:mm:ss") + "] [SyncInitiation: " + syncInitiation + "]\r\n");        

    }

    mSyncLog.write(logLine);

    XQServiceUtil::toBackground( false );

}

void QtSyncStatusModel::clearSyncLog()

{

    mSyncLog.clear();

}

void QtSyncStatusModel::publishSyncStatusKey()

{

    mSettingsManager->writeItemValue(*mDataSyncStatusKey,EDataSyncRunning12);

    mSettingsManager->writeItemValue(*mDataSyncStatusKey,EDataSyncNotRunning);

}

// End of file