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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbInput module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbinputsettingwidget.h"

#include <hbdataform.h>

#include <hbdataformmodel.h>

#include <hbinpututils.h>

#include <hbinputsettingproxy.h>

#include <hbinputpredictionfactory.h>

#include <QInputContextPlugin>

#include <QLibrary>

#include <QPluginLoader>

#include <QDir>

#include <QtAlgorithms>

#include <hbinputcontextplugin.h>

#include <hbinputmodeproperties.h>

#include "hbinputcheckboxlist_p.h"

#include "hbinputsettingproxy_p.h"

#include <hbinputmethoddescriptor.h>

#include <hbinputmethod.h>

#include <hbmainwindow.h>

const QString statusOff = QObject::tr("Off");

const QString statusOn = QObject::tr("On");

const QString bestPrediction = QObject::tr("Best prediction");

const QString exactTyping = QObject::tr("Exact typing");

/// @cond

// input modes name for chinese

const QString KPinyinName("Pinyin");

const QString KStrokeName("Stroke");

const QString KZhuyinName("Zhuyin");

const QString KCangjieNormalName("CangjieNormal");

const QString KCangjieEasyName("CangjieEasy");

const QString KCangjieAdvancedName("CangjieAdvanced");

const QString KHwrName("Handwriting");

const QString KHwrVerySlowName("Very Slow");

const QString KHwrSlowName("Slow");

const QString KHwrNormalName("Normal");

const QString KHwrFastName("Fast");

const QString KHwrVeryFastName("Very Fast");

// strings used for default language

const QString KDefaultChineseName("Chinese");

const QString KDefaultEnglishName("English");

// hwr speed index are exactly saming as enum HbHwrWritingSpeed

const int KHwrSpeedCount = 5;

// strings used for represent cangjie

const QString KCangjieGeneralName("Cangjie");

const QString KEasy("Easy");

const QString KNormal("Normal");

const QString KAdvanced("Advanced");

// input modes value for chinese

const int KChineseInputModeNone = -1;

const int KPinyinMode = 0;

const int KStrokeMode = 1;

const int KZhuyinMode = 2;

const int KCangjieNormalMode = 3;

const int KCangjieEasyMode = 4;

const int KCangjieAdvancedMode = 5;

const int KHwrMode = 6;

class HbCnInputModeMap

{

public:

    int mMode;

    QString mModeName;

};

const HbCnInputModeMap modesMap[] = {

    {KPinyinMode, KPinyinName},

    {KStrokeMode, KStrokeName},

    {KZhuyinMode, KZhuyinName},

    {KCangjieNormalMode, KCangjieNormalName},

    {KCangjieEasyMode, KCangjieEasyName},

    {KCangjieAdvancedMode, KCangjieAdvancedName},

    {KHwrMode, KHwrName}

};

class HbInputSettingWidgetPrivate

{

    Q_DECLARE_PUBLIC(HbInputSettingWidget)

public:

    HbInputSettingWidgetPrivate(HbDataForm *dataForm);

    void initialize();

    void createSettingItems();

    void fillLanguageList(QStringList &list, QList<HbInputLanguage> &languageList, const QString &replace = QString(" "));

    int languageToIndex(const HbInputLanguage &language, const QList<HbInputLanguage> &languageList);

    HbInputLanguage indexToLanguage(int index, const QList<HbInputLanguage> &languageList);

    void createSecondaryLanguageList();

    void updateContentWidgetData();

    // following API used by chinese

    int inputModeToIndex(const int &inputMode, const QList<int> &inputModeList);

    int indexToInputmode(int index, const QList<int> &inputModeList);

    void createChineseSettingGroup(HbDataFormModel *model);

    void createValidModesList(QStringList &imModeNames, QList<int> &imModeList);

    QString inputModeName(int mode) const;

    int inputModeByGivenName(const QString& imName) const;

    int defaultModeByGivenLang(const HbInputLanguage &lang) const;

public:  

    HbDataForm *mForm;

    HbDataFormModelItem *mPrimaryLanguageItem;

    HbDataFormModelItem *mSecondaryLanguageItem;

    HbDataFormModelItem *mKeypressTimeoutItem;

    HbDataFormModelItem *mCharacterPreviewItem;

    HbDataFormModelItem *mPredictionItem;

    HbDataFormModelItem *mAutoCompletionItem;

    HbDataFormModelItem *mCorrectionLevelItem;

    HbDataFormModelItem *mPrimaryCandidateItem;

    HbInputLanguage mPrimaryInputLanguage;

    HbInputLanguage mSecondaryInputLanguage;

    QList<HbInputLanguage> mPrimaryLanguages;

    QList<HbInputLanguage> mSecondaryLanguages;

    bool mPredictionStatusForITUT;

    bool mPredictionStatusForQwerty;

    bool mCharacterPreviewEnabled;

    int mKeypressTimeout;

    bool mAutocompletionForITUT;

    bool mAutocompletionForQwerty;

    HbTypingCorrectionLevel mTypingCorrectionLevel;

    HbPrimaryCandidateMode mPrimaryCandidateMode;

    HbInputSettingWidget *q_ptr;

    HbDataFormModel *mModel;

    // member variables for chinese

    HbDataFormModelItem *mLanguageGroup;

    HbDataFormModelItem *mChineseInputGroup;

    HbDataFormModelItem *mPortraitInputMethodItem;

    HbDataFormModelItem *mLandscapeInputMethodItem;

    HbDataFormModelItem *mHwrSpeedItem;

    HbDataFormModelItem *mCangjieItem;

    int mCnPortraitInputMode;

    int mCnLandscapeInputMode;

    int mCnCangjieInputMode;

    HbHwrWritingSpeed  mHwrSpeed;

    QList<int> mCnPortraitInputModeList;

    QList<int> mCnLandscapeInputModeList;

    QList<int> mCangjieInputModeList;

    QStringList mCnPortraitInputModeNames;

    QStringList mCnLandscapeInputModeNames;

    QStringList mCnCangjieInputModeNames;

    QStringList mHwrSpeedNames;

    QStringList mCnDefaultLanguageNames;

    HbDataFormModelItem *mCnDefaultLanguageItem;

};

/*!

Constructs setting widget

*/

HbInputSettingWidgetPrivate::HbInputSettingWidgetPrivate(HbDataForm *dataForm)

    : mForm(dataForm),

      mPrimaryLanguageItem(0),

      mSecondaryLanguageItem(0),

      mKeypressTimeoutItem(0),

      mCharacterPreviewItem(0),

      mPredictionItem(0),

      mAutoCompletionItem(0),

      mCorrectionLevelItem(0),

      mPrimaryCandidateItem(0),

      q_ptr(0),

      mModel(0),

      mLanguageGroup(0),

      mChineseInputGroup(0),      

      mPortraitInputMethodItem(0),

      mLandscapeInputMethodItem(0),

      mHwrSpeedItem(0),

      mCangjieItem(0),      

      mCnCangjieInputMode(KCangjieNormalMode),

      mCnDefaultLanguageItem(0)

{

}

/*!

Initializes setting widget

*/

void HbInputSettingWidgetPrivate::initialize()

{

    HbInputSettingProxy *settings = HbInputSettingProxy::instance();

    mPrimaryInputLanguage = settings->globalInputLanguage();

    mSecondaryInputLanguage = settings->globalSecondaryInputLanguage();

    mPredictionStatusForITUT = settings->predictiveInputStatus(HbKeyboardSetting12key);

    mPredictionStatusForQwerty = settings->predictiveInputStatus(HbKeyboardSettingQwerty);

    mCharacterPreviewEnabled = settings->isCharacterPreviewForQwertyEnabled();

    mKeypressTimeout = settings->keypressTimeout();

    mAutocompletionForITUT = settings->isAutocompletionEnabled(HbKeyboardSetting12key);

    mAutocompletionForQwerty = settings->isAutocompletionEnabled(HbKeyboardSettingQwerty);

    mPrimaryCandidateMode = settings->primaryCandidateMode();

    mTypingCorrectionLevel = settings->typingCorrectionLevel();

    HbInputUtils::listSupportedInputLanguages(mPrimaryLanguages);

    createSecondaryLanguageList();

    // if the model is already constructed we do not need to recreate the setting items

    if (!mModel) {

        createSettingItems();

    } else {

        // simply update the settings dependant content widget data of all the items

        updateContentWidgetData();

        //make sure that the items are not expanded

        QModelIndex index = mModel->indexFromItem(mSecondaryLanguageItem ? mSecondaryLanguageItem->parent(): mPrimaryLanguageItem->parent());

        mForm->setExpanded(index, false);

        index = mModel->indexFromItem(mKeypressTimeoutItem->parent());

        mForm->setExpanded(index, false);

        index = mModel->indexFromItem(mPredictionItem->parent());

        mForm->setExpanded(index, false);        

    }

}

void HbInputSettingWidgetPrivate::createValidModesList(QStringList &imModeNames, QList<int> &imModeList)

{    

    Qt::Orientation orientation = Qt::Horizontal;

    if (mForm) {

       orientation = mForm->mainWindow()->orientation();

    }

    QList<HbInputMethodDescriptor> methodList = HbInputMethod::listCustomInputMethods(orientation,

        HbInputSettingProxy::instance()->globalInputLanguage());

    methodList.insert(0, HbInputMethod::defaultInputMethod(orientation));

    foreach(const HbInputMethodDescriptor &des, methodList) {

        QStringList displayNames = des.displayNames();

        if (!displayNames.isEmpty()) {

            imModeNames += displayNames;

        } else {

            QString displayName = des.displayName();

            imModeNames.append(displayName);

        }

    }

    imModeNames.removeDuplicates();

    // filter out the input mode that not valid to current screen orientation

    if (imModeNames.contains(KCangjieGeneralName)) {

        imModeNames.removeOne(KCangjieGeneralName);

    }

    for (int i = 0; i < imModeNames.count(); ++i) {

        imModeList.append(inputModeByGivenName(imModeNames.at(i)));

    }

}

QString HbInputSettingWidgetPrivate::inputModeName(int mode) const

{

    int cnImCnts = sizeof(modesMap) / sizeof(modesMap[0]);

    if (mode >= 0 && mode < cnImCnts) {

        return modesMap[mode].mModeName;

    }

    return QString();

}

int HbInputSettingWidgetPrivate::inputModeByGivenName(const QString& imName) const

{

    int cnMode = KChineseInputModeNone;

    if (imName == KCangjieGeneralName) {

        HbCangjieDetailMode cjDetail = HbInputSettingProxy::instance()->detailedCangjieMode();

        switch (cjDetail) {

        case HbCangjieEasy: {

            cnMode = KCangjieEasyMode;

        }

            break;

        case HbCangjieAdvanced: {

            cnMode = KCangjieAdvancedMode;

        }

            break;

        case HbCangjieNormal: 

        default: {

            cnMode = KCangjieNormalMode;

        }

            break;

        }

    } else {

        int cnImCnts = sizeof(modesMap) / sizeof(modesMap[0]);

        for (int i = 0; i < cnImCnts; ++i) {

            if (modesMap[i].mModeName == imName) {

                cnMode = modesMap[i].mMode;

            }

        }

    }

    if (KChineseInputModeNone == cnMode) {

        HbInputLanguage lang = HbInputSettingProxy::instance()->globalInputLanguage();

        cnMode = defaultModeByGivenLang(lang);

    }

    return cnMode;

}

int HbInputSettingWidgetPrivate::defaultModeByGivenLang(const HbInputLanguage &lang) const

{

    int imMode = KChineseInputModeNone;

    if (lang.variant() == QLocale::China) {

        imMode = KPinyinMode;

    } else if (lang.variant() == QLocale::HongKong) {

        imMode = KStrokeMode;

    } else if (lang.variant() == QLocale::Taiwan) {

        imMode = KZhuyinMode;

    }

    return imMode;

}

void HbInputSettingWidgetPrivate::createChineseSettingGroup(HbDataFormModel *model)

{

    Q_Q(HbInputSettingWidget);

    QByteArray ba = HbInputSettingProxy::instance()->preferredInputMethodCustomData(Qt::Vertical);

    QString imName(ba);

    HbInputLanguage lang = HbInputSettingProxy::instance()->globalInputLanguage();

    mCnPortraitInputMode = inputModeByGivenName(imName);

    ba = HbInputSettingProxy::instance()->preferredInputMethodCustomData(Qt::Horizontal);

    imName = QString(ba);

    mCnLandscapeInputMode = inputModeByGivenName(imName);

    mHwrSpeedNames.clear();

    mCnPortraitInputModeList.clear();

    mCnLandscapeInputModeList.clear();

    mCnPortraitInputModeNames.clear();

    mCnLandscapeInputModeNames.clear();

    mCnCangjieInputModeNames.clear();

    mCnDefaultLanguageNames.clear();

    createValidModesList(mCnPortraitInputModeNames, mCnPortraitInputModeList);

    mCnLandscapeInputModeNames = mCnPortraitInputModeNames;

    mCnLandscapeInputModeList = mCnPortraitInputModeList;

    // append cangjie to landscape related list if need

    if (mPrimaryInputLanguage == HbInputLanguage(QLocale::Chinese, QLocale::HongKong) && 

        !mCnLandscapeInputModeNames.contains(KCangjieGeneralName)) {

        int index = HbInputSettingProxy::instance()->detailedCangjieMode();

        switch(index) {

        case 0:

            mCnCangjieInputMode = KCangjieEasyMode;

            break;

        case 1: 

            mCnCangjieInputMode = KCangjieNormalMode;

            break;

        case 2:

            mCnCangjieInputMode = KCangjieAdvancedMode;

            break;

        default:

            break;

        }

        QStringList tmpInputmodeNames;

        QList<int> tmpInputmode;

        tmpInputmodeNames << mCnLandscapeInputModeNames.at(0) << KCangjieGeneralName << mCnLandscapeInputModeNames.at(1);

        tmpInputmode << mCnLandscapeInputModeList.at(0) << mCnCangjieInputMode << mCnLandscapeInputModeList.at(1);

        mCnLandscapeInputModeList.clear();

        mCnLandscapeInputModeNames.clear();

        mCnLandscapeInputModeList = tmpInputmode;

        mCnLandscapeInputModeNames = tmpInputmodeNames;

        mCangjieInputModeList << KCangjieEasyMode << KCangjieNormalMode << KCangjieAdvancedMode;

        mCnCangjieInputModeNames << KEasy << KNormal << KAdvanced;

    }

    mHwrSpeed = HbInputSettingProxy::instance()->hwrWritingSpeed();

    mHwrSpeedNames << KHwrVerySlowName << KHwrSlowName << KHwrNormalName << KHwrFastName << KHwrVeryFastName;

    mCnDefaultLanguageNames << KDefaultChineseName << KDefaultEnglishName;

    if (!mChineseInputGroup) {

        mChineseInputGroup = model->appendDataFormGroup(QObject::tr("Chinese Input"));

        mPortraitInputMethodItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Portrait mode input method"));

        mChineseInputGroup->appendChild(mPortraitInputMethodItem);

        mPortraitInputMethodItem->setContentWidgetData(QString("items"), mCnPortraitInputModeNames);

        int imIdx = inputModeToIndex(mCnPortraitInputMode, mCnPortraitInputModeList);

        QVariant varPor;

        varPor.setValue(imIdx);

        mPortraitInputMethodItem->setContentWidgetData(QString("currentIndex"), varPor);

        mPortraitInputMethodItem->setContentWidgetData(QString("objectName"), QString("portrait_input_method"));

        mForm->addConnection(mPortraitInputMethodItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setPortraitInputMethod(int)));

        mLandscapeInputMethodItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Landscape mode input method"));

        mChineseInputGroup->appendChild(mLandscapeInputMethodItem);

        mLandscapeInputMethodItem->setContentWidgetData(QString("items"), mCnLandscapeInputModeNames);

        int imIdx_lan = inputModeToIndex(mCnLandscapeInputMode, mCnLandscapeInputModeList);

        QVariant varLan;

        varLan.setValue(imIdx_lan);

        mLandscapeInputMethodItem->setContentWidgetData(QString("currentIndex"), varLan);

        mLandscapeInputMethodItem->setContentWidgetData(QString("objectName"), QString("landscape_input_method"));

        mForm->addConnection(mLandscapeInputMethodItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setLandscapeInputMethod(int)));

        mHwrSpeedItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Handwriting speed"));

        mChineseInputGroup->appendChild(mHwrSpeedItem);

        mHwrSpeedItem->setContentWidgetData(QString("items"), mHwrSpeedNames);

        mHwrSpeedItem->setContentWidgetData(QString("currentIndex"), mHwrSpeed);

        mHwrSpeedItem->setContentWidgetData(QString("objectName"), QString("handwriting_speed"));

        mForm->addConnection(mHwrSpeedItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setHwrSpeed(int)));

        mCnDefaultLanguageItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Default language for keyboard input"));

        mChineseInputGroup->appendChild(mCnDefaultLanguageItem);

        int defaultLanguageIndex = HbInputSettingProxy::instance()->useWesternDefaultKeypadForChinese()?1:0;

        mCnDefaultLanguageItem->setContentWidgetData(QString("items"), mCnDefaultLanguageNames);

        mCnDefaultLanguageItem->setContentWidgetData(QString("currentIndex"), defaultLanguageIndex);

        mCnDefaultLanguageItem->setContentWidgetData(QString("objectName"), QString("default_language_for_keyboard_input"));

        mForm->addConnection(mCnDefaultLanguageItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setDefaultLanguageForKeyboardInput(int)));

    }

    int cangjieIdx = HbInputSettingProxy::instance()->detailedCangjieMode();

    if (mPrimaryInputLanguage == HbInputLanguage(QLocale::Chinese, QLocale::HongKong)) {

        mCangjieItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Cangjie mode"));

        mChineseInputGroup->appendChild(mCangjieItem);

        mCangjieItem->setContentWidgetData(QString("items"), mCnCangjieInputModeNames);

        QVariant varCang;

        varCang.setValue(cangjieIdx);

        mCangjieItem->setContentWidgetData(QString("currentIndex"), varCang);

        mCangjieItem->setContentWidgetData(QString("objectName"), QString("cangjie_mode"));

        mForm->addConnection(mCangjieItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setCangjieMode(int)));

    }

}

void HbInputSettingWidgetPrivate::updateContentWidgetData() 

{

    // current primary language

    mPrimaryLanguageItem->setContentWidgetData(QString("currentIndex"), languageToIndex(mPrimaryInputLanguage, mPrimaryLanguages));

    if (mSecondaryLanguageItem) {

        mSecondaryLanguageItem->setContentWidgetData(QString("currentIndex"), languageToIndex(mSecondaryInputLanguage, mSecondaryLanguages));

    }

    // key press timeout

    mKeypressTimeoutItem->setContentWidgetData(QString("sliderPosition"), mKeypressTimeout);

    if (mCharacterPreviewEnabled) {

        mCharacterPreviewItem->setContentWidgetData(QString("text"), statusOn);

        mCharacterPreviewItem->setContentWidgetData(QString("additionalText"), statusOff);

    } else {

        mCharacterPreviewItem->setContentWidgetData(QString("text"), statusOff);

        mCharacterPreviewItem->setContentWidgetData(QString("additionalText"), statusOn);

    }

    QList<QVariant> predictionEnabled;

    predictionEnabled << mPredictionStatusForQwerty << mPredictionStatusForITUT;

    mPredictionItem->setContentWidgetData(QString("selectedItems"), predictionEnabled);

    QList<QVariant> autocompletionEnabled;

    autocompletionEnabled << mAutocompletionForQwerty << mAutocompletionForITUT;

    mAutoCompletionItem->setContentWidgetData(QString("selectedItems"), autocompletionEnabled);

    mCorrectionLevelItem->setContentWidgetData(QString("selected"), mTypingCorrectionLevel);

    if (mPrimaryCandidateMode == HbPrimaryCandidateModeBestPrediction) {

        mPrimaryCandidateItem->setContentWidgetData(QString("text"), bestPrediction);

        mPrimaryCandidateItem->setContentWidgetData(QString("additionalText"), exactTyping);

    } else {

        mPrimaryCandidateItem->setContentWidgetData(QString("text"), exactTyping);

        mPrimaryCandidateItem->setContentWidgetData(QString("additionalText"), bestPrediction);

    }

    if(mChineseInputGroup && mCnDefaultLanguageItem) {

        int defaultLanguageIndex = HbInputSettingProxy::instance()->useWesternDefaultKeypadForChinese()?1:0;

        mCnDefaultLanguageItem->setContentWidgetData(QString("currentIndex"), defaultLanguageIndex);

    }

}

/*!

Creates setting items to this widget

*/

void HbInputSettingWidgetPrivate::createSettingItems()

{   

    Q_Q(HbInputSettingWidget);

    mModel = new HbDataFormModel();

    HbInputCheckBoxList *customPrototype = new HbInputCheckBoxList(mForm);

    QList<HbAbstractViewItem *> prototypes = mForm->itemPrototypes();

    prototypes.append(customPrototype);

    mForm->setItemPrototypes(prototypes);