/*

 * 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 "mpxvideo_debug.h"

#include "videosettingsgroup.h"

#include "videosettingsaccesspointentry.h"

#include <cpsettingformitemdata.h>

#include <cpitemdatahelper.h>

#include <hbdataformmodel.h>

#include <hblineedit.h>

#include <hbinputeditorinterface.h>

#include <hbdataformviewitem.h>

#include <hbinputstandardfilters.h>

#include <hbvalidator.h>

#include <hbpushbutton.h>

#include <mpsettingsmodel.h>

#include <MPSettEngPluginImplementationUIDs.hrh>

#include <xqconversions.h>

#include <qapplication.h>

#include <hbapplication.h>

const int PROXY_LOWEST_ACCEPTED_VALUE = 1;

const int UDP_LOWEST_ACCEPTED_VALUE = 1024;

const int PORT_HIGHEST_ACCEPTED_VALUE = 65535;

void gValidatePortValues(int& value, int bottom, int top)

{

    if(value < bottom)

    {

        value = bottom;

    }

    if(value > top)

    {

        value = top;

    }

}

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

VideoSettingsGroup::VideoSettingsGroup(CpItemDataHelper &itemDataHelper) :

    CpSettingFormItemData(HbDataFormModelItem::GroupItem, QString()),

    mItemDataHelper(itemDataHelper),

    mSettingsModel(0),

    mAccessPointItem(0),

    mLowestUDPPortItem(0),

    mHighestUDPPortItem(0),

    mUseProxyItem(0),

    mProxyServerItem(0),

    mProxyPortItem(0)

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::VideoSettingsGroup()"));

    // Load the translation file.

    QString lang = QLocale::system().name();

    bool loaded(false);

    loaded = mTranslator.load( "videos_" + lang, QString("c:/resource/qt/translations") );

    if (!loaded)

    {

        mTranslator.load("videos_" + lang, QString("z:/resource/qt/translations") );

    }

    // Install the translator

    HbApplication* app = qobject_cast<HbApplication*>(qApp);

    if(app)

    {

        app->installTranslator(&mTranslator);

    }

    this->setLabel(hbTrId("txt_videos_subhead_video_streaming_settings"));

    TRAPD(err, InitSettingsModelL());

    if(err != KErrNone)

    {

        delete mSettingsModel;

        mSettingsModel = 0;

        return;

    }

    itemDataHelper.connectToForm(SIGNAL(itemShown(const QModelIndex)), this, SLOT(itemShown(const QModelIndex)));

    // Access point in use

    mAccessPointItem = new VideoSettingsAccessPointEntry(itemDataHelper,

        hbTrId("txt_videos_dblist_access_point"), this);

    // Lowest UDP port

    mLowestUDPPortItem = new CpSettingFormItemData(HbDataFormModelItem::TextItem,

        hbTrId("txt_videos_dblist_min_udp_port"), this);

    mLowestUDPPortItem->setContentWidgetData(QString("maxRows"), 1);

    mItemDataHelper.addConnection(mLowestUDPPortItem, SIGNAL(editingFinished()),

        this, SLOT(lowestUdpPortEditingFinished()));

    // Highest UDP port

    mHighestUDPPortItem = new CpSettingFormItemData(HbDataFormModelItem::TextItem,

        hbTrId("txt_videos_dblist_max_udp_port"), this);

    mHighestUDPPortItem->setContentWidgetData(QString("maxRows"), 1);

    mItemDataHelper.addConnection(mHighestUDPPortItem, SIGNAL(editingFinished()),

        this, SLOT(highestUdpPortEditingFinished()));

    // Use proxy

    mUseProxyItem = new CpSettingFormItemData(HbDataFormModelItem::CheckBoxItem, QString(), this);

    mUseProxyItem->setContentWidgetData(QString("text"), hbTrId("txt_videos_formlabel_proxy_in_use"));

    // Proxy server address

    mProxyServerItem = new CpSettingFormItemData(HbDataFormModelItem::TextItem,

        hbTrId("txt_videos_dblist_proxy_host_name"), this);

    mProxyServerItem->setContentWidgetData(QString("maxRows"), 1);

    mProxyServerItem->setContentWidgetData(QString("placeholderText"), hbTrId("txt_videos_dblist_none"));

    mItemDataHelper.addConnection(mProxyServerItem, SIGNAL(editingFinished()),

        this, SLOT(proxyServerEditingFinished()));

    // Proxy port number

    mProxyPortItem = new CpSettingFormItemData(HbDataFormModelItem::TextItem,

        hbTrId("txt_videos_dblist_proxy_port"), this);

    mProxyPortItem->setContentWidgetData(QString("maxRows"), 1);

    mItemDataHelper.addConnection(mProxyPortItem, SIGNAL(editingFinished()),

        this, SLOT(proxyPortEditingFinished()));

    loadSettings();

}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

VideoSettingsGroup::~VideoSettingsGroup()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::~VideoSettingsGroup()"));

    TRAP_IGNORE( mSettingsModel->StoreSettingsL() );

    delete mSettingsModel;

}

// ---------------------------------------------------------------------------

// getAccessPointId

// ---------------------------------------------------------------------------

//

uint VideoSettingsGroup::getAccessPointId()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::getAccessPointId()"));

    TUint32 defaultAp(0);

    mSettingsModel->GetDefaultAp(defaultAp);

    MPX_DEBUG(_L("Returned access point id = %i"), defaultAp);

    return defaultAp;

}

// ---------------------------------------------------------------------------

// setAccessPointId

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::setAccessPointId(const uint& defaultAp)

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::setAccessPointId()"),

        _L("defaultAp = %i"), defaultAp);

    uint oldAp = getAccessPointId();

    if(oldAp != defaultAp)

    {

        mSettingsModel->SetDefaultAp(defaultAp);

        mUseProxyItem->setContentWidgetData(QString("checked"), false);

    }

}

// ---------------------------------------------------------------------------

// lowestUdpPortValueChanged

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::lowestUdpPortEditingFinished()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::lowestUdpPortValueChanged()"));

    int minPort = mLowestUDPPortItem->contentWidgetData(QString("text")).toString().toInt();

    int maxPort = mHighestUDPPortItem->contentWidgetData(QString("text")).toString().toInt();

    MPX_DEBUG(_L("minudp = %i, maxudp = %i"), minPort, maxPort);

    if(minPort > maxPort)

    {

        minPort = maxPort;

    }

    gValidatePortValues(minPort, UDP_LOWEST_ACCEPTED_VALUE, PORT_HIGHEST_ACCEPTED_VALUE);

    mLowestUDPPortItem->setContentWidgetData(QString("text"), QString::number(minPort));

    mSettingsModel->SetMinUDPPort(minPort);

}

// ---------------------------------------------------------------------------

// highestUdpPortValueChanged

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::highestUdpPortEditingFinished()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::highestUdpPortValueChanged()"));

    int maxPort = mHighestUDPPortItem->contentWidgetData(QString("text")).toString().toInt();

    int minPort = mLowestUDPPortItem->contentWidgetData(QString("text")).toString().toInt();

    MPX_DEBUG(_L("minudp = %i, maxudp = %i"), minPort, maxPort);

    if(maxPort < minPort)

    {

        maxPort = minPort;

    }

    gValidatePortValues(maxPort, UDP_LOWEST_ACCEPTED_VALUE, PORT_HIGHEST_ACCEPTED_VALUE);

    mHighestUDPPortItem->setContentWidgetData(QString("text"), QString::number(maxPort));

    mSettingsModel->SetMaxUDPPort(maxPort);

}

// ---------------------------------------------------------------------------

// useProxyToggled

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::useProxyToggled(int state)

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::useProxyToggled()"),

        _L("state = %i"), state);

    mProxyServerItem->setEnabled(state == Qt::Checked);

    mProxyPortItem->setEnabled(state == Qt::Checked);

    mSettingsModel->SetProxyMode(state == Qt::Checked ? 1 : 0);

}

// ---------------------------------------------------------------------------

// proxyServerValueChanged

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::proxyServerEditingFinished()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::proxyServerValueChanged()"));

    QString text = mProxyServerItem->contentWidgetData(QString("text")).toString();

    MPX_DEBUG(_L("new proxy server = '%s'"), text.data());

    HBufC* proxyServer = XQConversions::qStringToS60Desc(text);

    TRAP_IGNORE( mSettingsModel->SetProxyHostNameL(*proxyServer) );

    delete proxyServer;

}

// ---------------------------------------------------------------------------

// proxyPortValueChanged

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::proxyPortEditingFinished()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::proxyPortValueChanged()"));

    int proxyPort = mProxyPortItem->contentWidgetData(QString("text")).toString().toInt();

    MPX_DEBUG(_L("new proxy port = %i"), proxyPort);

    gValidatePortValues(proxyPort, PROXY_LOWEST_ACCEPTED_VALUE, PORT_HIGHEST_ACCEPTED_VALUE);

    mProxyPortItem->setContentWidgetData(QString("text"), QString::number(proxyPort));

    mSettingsModel->SetProxyPort(proxyPort);

}

// ---------------------------------------------------------------------------

// itemShown

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::itemShown(const QModelIndex& index)

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::itemShown()"),

        _L("index row = %i"), index.row());

    HbDataFormModelItem* modelItem = mItemDataHelper.modelItemFromModelIndex(index);

    if(modelItem == mLowestUDPPortItem ||

       modelItem == mHighestUDPPortItem ||

       modelItem == mProxyPortItem )

    {

        HbLineEdit *editor = static_cast<HbLineEdit *>(mItemDataHelper.widgetFromModelIndex(index));

        editor->setMaxLength(5);

        HbEditorInterface editorIf(editor);

        editorIf.setFilter(HbDigitsOnlyFilter::instance());

    }

    if(modelItem == mProxyServerItem)

    {

        mItemDataHelper.addConnection(mUseProxyItem, SIGNAL(stateChanged(int)), this, SLOT(useProxyToggled(int)));

        HbEditorInterface editor(mItemDataHelper.widgetFromModelIndex(index));

        editor.setFilter(HbUrlFilter::instance());

    }

}

// ---------------------------------------------------------------------------

// InitSettingsModelL

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::InitSettingsModelL()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::InitSettingsModelL()"));

    TUid settingsUid = {KMPSettEngImplUidROP};

    mSettingsModel = CMPSettingsModel::NewL(settingsUid);

    mSettingsModel->LoadSettingsL(EConfigUser);

}

// ---------------------------------------------------------------------------

// loadSettings

// ---------------------------------------------------------------------------

//

void VideoSettingsGroup::loadSettings()

{

    MPX_ENTER_EXIT(_L("VideoSettingsGroup::loadSettings()"));

    int lowestUdpPort(0);

    mSettingsModel->GetMinUDPPort(lowestUdpPort);

    mLowestUDPPortItem->setContentWidgetData(QString("text"), QString::number(lowestUdpPort));

    int highestUdpPort(0);

    mSettingsModel->GetMaxUDPPort(highestUdpPort);

    mHighestUDPPortItem->setContentWidgetData(QString("text"), QString::number(highestUdpPort));

    int proxyMode(0);

    mSettingsModel->GetProxyMode(proxyMode);

    mUseProxyItem->setContentWidgetData(QString("checked"), proxyMode == 1);

    useProxyToggled(proxyMode == 1 ? Qt::Checked : Qt::Unchecked);

    TBuf<496> proxyServerBuf;

    mSettingsModel->GetProxyHostName(proxyServerBuf);

    QString proxyServer = XQConversions::s60DescToQString(proxyServerBuf);

    mProxyServerItem->setContentWidgetData(QString("text"), proxyServer);

    int proxyPort;

    mSettingsModel->GetProxyPort(proxyPort);

    mProxyPortItem->setContentWidgetData(QString("text"), QString::number(proxyPort));

    mAccessPointItem->setIapId(getAccessPointId());

}