/*
* Copyright (c) 2010 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:
*
*/

// System includes
#include <QVariant>

// User Includes
#include "t_radiohswidget.h"
#include "xqsettingsmanager.h"
#include "xqapplicationmanager.h"
#include "xqaiwrequest.h"
#include "xqaiwinterfacedescriptor.h"
#include "radioservicedef.h"
#include "radiologger.h"

// Constants
/**
* From ProfileEngineSDKCRKeys.h
* The id of the currently active profile, integer value.
* Possible values:
*
* 0 = General profile (default value)<br>
* 1 = Silent profile<br>
* 2 = Meeting profile<br>
* 3 = Outdoor profile<br>
* 4 = Pager profile<br>
* 5 = Off-line profile<br>
* 6 = Drive profile<br>
* 30-49 = User-created profiles<br>
**/
const int PROFILE_GENERAL(0); 
const int PROFILE_SILENT(1); 
const int PROFILE_MEETING(2); 
const int PROFILE_OUTDOOR(3); 
const int PROFILE_PAGER(4); 
const int PROFILE_OFFLINE(5); 
const int PROFILE_DRIVE(6); 
const int PROFILE_USER_CREATED(35);

/** Requests are not embedded. */
const bool EMBEDDED_REQUEST(false);

/** Last request should be answered with empty reply. */
int EMPTY_REPLY(-5);

/** Test values for favorite station count. */
const int FAVORITE_STATION_COUNT_INVALID_TOO_LOW1(-56);
const int FAVORITE_STATION_COUNT_INVALID_TOO_LOW2(-1);
const int FAVORITE_STATION_COUNT_VALID_LOWER_BOUNDARY(0);
const int FAVORITE_STATION_COUNT_VALID1(1);
const int FAVORITE_STATION_COUNT_VALID2(2);
const int FAVORITE_STATION_COUNT_VALID3(3);
const int FAVORITE_STATION_COUNT_VALID4(9);
const int FAVORITE_STATION_COUNT_VALID5(78);
const int FAVORITE_STATION_COUNT_VALID_UPPER_BOUNDARY(100);
const int FAVORITE_STATION_COUNT_INVALID_TOO_HIGH1(101);
const int FAVORITE_STATION_COUNT_INVALID_TOO_HIGH2(1256);

/** Test values for textual information. */
const QString TEST_FREQUENCY("99.9");
const QString TEST_NAME("Radio Test");
const QString TEST_GENRE("Test GenRe");
const QString TEST_RADIO_TEXT("Test RDS");
const QString TEST_DYNAMIC_PSNAME("Dynamic PS Name test");
const QString TEST_EMPTY_STRING("");
const QString TEST_INVALID_STRING;
/** This test string contains 1000 characters. */
const QString TEST_TOO_LONG_STRING("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");

/** Test values for service notification types. */
const int RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_LOW1(-357);
const int RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_LOW2(-1);
const int RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_LOW3(0);
const int RADIO_SERVICE_NOTIFICATION_ID_VALID_LOWER_BOUNDARY(1);
const int RADIO_SERVICE_NOTIFICATION_ID_VALID_UPPER_BOUNDARY(8);
const int RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_HIGH1(9);
const int RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_HIGH2(57982);
const int RADIO_STATUS_INVALID_TOO_LOW1(-581);
const int RADIO_STATUS_INVALID_TOO_LOW2(-1);
const int RADIO_STATUS_VALID_LOWER_BOUNDARY(0);
const int RADIO_STATUS_VALID_UPPER_BOUNDARY(5);
const int RADIO_STATUS_INVALID_TOO_HIGH1(6);
const int RADIO_STATUS_INVALID_TOO_HIGH2(456);

/** Mock returns for settings manager stub. */
QVariant settings_manager_mock_return_profile;
QVariant settings_manager_mock_return_2nd_profile;
bool settings_manager_mock_bool_return;

/** These request are defined in stub xqapplicationmanager.cpp. */
extern XQAiwRequest *application_manager_mock_refresh_request;
extern XQAiwRequest *application_manager_mock_monitor_request;

/** List for request mocks. */
QVariantList request_mocks;
/** Amount of requests send. */
int send_count;


/*!
    \class TestRadioHsWidget
    \brief Unit testing for FM Radio hs widget.

    TestRadioHsWidget implements needed functions for the FM Radio home screen
    widget unit tests.
*/

// ======== MEMBER FUNCTIONS ========

/*!
    Main function.
    
    There's been problems with QTEST_MAIN macro, so main function is defined
    here.
*/
int main(int /* argc*/, char *argv[])
{
    LOG_METHOD_ENTER;
    TestRadioHsWidget tv;

    char *pass[3];
    pass[0] = argv[0];
    pass[1] = "-o";
    pass[2] = "c:\\data\\testradiohswidget.txt";
    
    int res = QTest::qExec(&tv, 3, pass);

    return res;
}

/*!
    Constructor.
 */
TestRadioHsWidget::TestRadioHsWidget()
{
    LOG_METHOD_ENTER;
}


/*!
    Destructor.
 */
TestRadioHsWidget::~TestRadioHsWidget()
{
    LOG_METHOD_ENTER;
}

/*!
    Called before each testfunction is executed.
 */
void TestRadioHsWidget::init()
{
    LOG_METHOD_ENTER;
    settings_manager_mock_return_profile = PROFILE_GENERAL;
    request_mocks.clear();
    mSendInfos.clear();
    send_count = -1;
    mRadioHsWidgetStub.data()->reset();
}

/*!
    Called after every testfunction.
 */
void TestRadioHsWidget::cleanup()
{
    LOG_METHOD_ENTER;
}

/*!
    Called before the first testfunction is executed
 */
void TestRadioHsWidget::initTestCase()
{
    LOG_METHOD_ENTER;
    mRadioHsWidgetStub.reset(new RadioHsWidget());
    QVERIFY(mRadioHsWidgetStub);
    mProfileReader.reset(new RadioHsWidgetProfileReader(mRadioHsWidgetStub.data()));
    QVERIFY(mProfileReader);
    mServiceClient.reset(new RadioHsWidgetRadioServiceClient(mRadioHsWidgetStub.data()));
    QVERIFY(mServiceClient);
}

/*!
    Called after the last testfunction was executed.
 */
void TestRadioHsWidget::cleanupTestCase()
{
    LOG_METHOD_ENTER;
}

/*!
    Tests RadioHsWidgetProfileReader and it's isCurrentProfileOffline()
    function.
 */
void TestRadioHsWidget::offlineModeTest()
{
    LOG_METHOD;
    settings_manager_mock_return_profile = PROFILE_GENERAL;
    bool isOffline = mProfileReader.data()->isCurrentProfileOffline();
    QVERIFY2(( isOffline == false ), "FmRadioHsWidget:RadioHsWidget profile is offline");
    settings_manager_mock_return_profile = PROFILE_OFFLINE;
    isOffline = mProfileReader.data()->isCurrentProfileOffline();
    QVERIFY2(( isOffline == true ), "FmRadioHsWidget:RadioHsWidget profile is not offline");
    settings_manager_mock_return_profile = PROFILE_USER_CREATED;
    isOffline = mProfileReader.data()->isCurrentProfileOffline();
    QVERIFY2(( isOffline == false ), "FmRadioHsWidget:RadioHsWidget profile is offline");
}

/*!
    Tests RadioHsWidgetRadioServiceClient class and it's ability to receive
    and forward valid information.
 */
void TestRadioHsWidget::validReplies()
{
    LOG_METHOD;
    // Replies that should be ok.
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID_LOWER_BOUNDARY));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID1));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID2));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID3));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID4));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID5));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_VALID_UPPER_BOUNDARY));
    createSendInfo(RadioServiceNotification::CurrentIsFavorite, QVariant(true));
    createSendInfo(RadioServiceNotification::CurrentIsFavorite, QVariant(false));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RadioStatus::UnSpecified));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RadioStatus::Playing));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RadioStatus::Muted));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RadioStatus::Seeking));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RadioStatus::NoAntenna));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RadioStatus::PoweringOff));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RADIO_STATUS_VALID_LOWER_BOUNDARY));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RADIO_STATUS_VALID_UPPER_BOUNDARY));
    createSendInfo(RadioServiceNotification::Frequency, QVariant(TEST_FREQUENCY));
    createSendInfo(RadioServiceNotification::Name, QVariant(TEST_NAME));
    createSendInfo(RadioServiceNotification::Name, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RadioServiceNotification::Genre, QVariant(TEST_GENRE));
    createSendInfo(RadioServiceNotification::RadioText, QVariant(TEST_RADIO_TEXT));
    createSendInfo(RadioServiceNotification::DynamicPS, QVariant(TEST_DYNAMIC_PSNAME));
    // Empty reply should be last to put RServiceClient to make an request, which is not replied. 
    createSendInfo(EMPTY_REPLY, QVariant(EMPTY_REPLY));

    send_count = mSendInfos.count();
    
    mServiceClient.data()->startMonitoring(FmRadio::VisibiltyToBackground);
    mServiceClient.data()->stopMonitoring();
    
    int receivedCount = mRadioHsWidgetStub.data()->receivedInformationCount();
    QVERIFY2((receivedCount == send_count - 1), "Send and received counts doesn't match");
    
    ReceivedInfo temp;
    for (int i = 0; i < send_count - 1; i++) {
        temp = mRadioHsWidgetStub.data()->receivedInformation();
        QVERIFY(temp.informationType == mSendInfos.at(i).informationType);
        verifyReceivedInformation(temp.informationType, temp.information, mSendInfos.at(i).information);
    }
}

/*!
    Tests RadioHsWidgetRadioServiceClient class and it's ability to receive
    and forward invalid information.
 */
void TestRadioHsWidget::invalidReplies()
{
    LOG_METHOD;
    QList<int> skipSendInfo;
    // Replies that should not be ok.
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_INVALID_TOO_LOW1));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_INVALID_TOO_LOW2));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_INVALID_TOO_HIGH1));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant(FAVORITE_STATION_COUNT_INVALID_TOO_HIGH2));
    createSendInfo(RadioServiceNotification::FavoriteCount, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::CurrentIsFavorite, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RADIO_STATUS_INVALID_TOO_LOW1));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RADIO_STATUS_INVALID_TOO_LOW1));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RADIO_STATUS_INVALID_TOO_HIGH1));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant(RADIO_STATUS_INVALID_TOO_HIGH2));
    createSendInfo(RadioServiceNotification::RadioStatus, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::Frequency, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::Name, QVariant(TEST_INVALID_STRING));
    createSendInfo(RadioServiceNotification::Name, QVariant(TEST_TOO_LONG_STRING));
    createSendInfo(RadioServiceNotification::Name, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::Genre, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::RadioText, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    createSendInfo(RadioServiceNotification::DynamicPS, QVariant());
    skipSendInfo.append(request_mocks.count() - 1);
    // Replies that should generate a warning.
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_VALID_LOWER_BOUNDARY, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_VALID_UPPER_BOUNDARY, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_LOW1, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_LOW2, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_LOW3, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_HIGH1, QVariant(TEST_EMPTY_STRING));
    createSendInfo(RADIO_SERVICE_NOTIFICATION_ID_INVALID_TOO_HIGH2, QVariant(TEST_EMPTY_STRING));
    // Empty reply should be last to put RServiceClient to make an request, which is not replied. 
    createSendInfo(EMPTY_REPLY, QVariant(EMPTY_REPLY));
    
    send_count = mSendInfos.count();
    
    mServiceClient.data()->startMonitoring(FmRadio::VisibiltyToBackground);
    mServiceClient.data()->stopMonitoring();
    
    int receivedCount = mRadioHsWidgetStub.data()->receivedInformationCount();
    int skippedCount = skipSendInfo.count();
    QVERIFY2((receivedCount == send_count - skippedCount - 1), "Send and received counts doesn't match");
    
    ReceivedInfo temp;
    for (int i = 0; i < send_count - 1; i++) {
        if (skipSendInfo.contains(i)) {
            // Skip verification for information that was filtered in
            // RadioHsWidgetRadioServiceClient.
            continue;
        }
        temp = mRadioHsWidgetStub.data()->receivedInformation();
        QVERIFY(temp.informationType == mSendInfos.at(i).informationType);
        verifyReceivedInformation(temp.informationType, temp.information, mSendInfos.at(i).information);
    }
}

/*!
    Helper function to store send information and append it to a request
    mocks. 
 */
void TestRadioHsWidget::createSendInfo(int informationType, const QVariant information)
{
    SendInfo info;
    QVariantList notificationList;
    
    info.informationType = informationType;
    info.information = information;
    info.data = QVariant(mServiceClient.data()->
        createRadioNotificationData(
            info.informationType,
            info.information
            ));
    
    mSendInfos.append(info);

    notificationList.append(info.data);
    request_mocks.append(QVariant(notificationList));
}

/*!
    Helper function to verify receved information.
 */
void TestRadioHsWidget::verifyReceivedInformation(int informationType,
    const QVariant &receivedInformation, const QVariant &sendInformation)
{
    switch (informationType) {
    case RadioServiceNotification::CurrentIsFavorite:
        QVERIFY(receivedInformation.canConvert(QVariant::Bool));
        QCOMPARE(receivedInformation.toBool(), sendInformation.toBool());
        break;
    case RadioServiceNotification::FavoriteCount:
        // Fall through because of similar handling
    case RadioServiceNotification::RadioStatus:
        QVERIFY(receivedInformation.canConvert(QVariant::Int));
        QCOMPARE(receivedInformation.toInt(), sendInformation.toInt());
        break;
    case RadioServiceNotification::Frequency:
        // Fall through because of similar type of information and thus
        // similar handling
    case RadioServiceNotification::Name:
        // Fall through because of similar type of information and thus
        // similar handling
    case RadioServiceNotification::Genre:
        // Fall through because of similar type of information and thus
        // similar handling
    case RadioServiceNotification::RadioText:
        // Fall through because of similar type of information and thus
        // similar handling
    case RadioServiceNotification::DynamicPS:
        QVERIFY(receivedInformation.canConvert(QVariant::String));
        QCOMPARE(receivedInformation.toString(), sendInformation.toString());
        break;
    default:
        QWARN("Default case, shouldn't be here except if specifically testing RadioServiceNotification id out of bounds.");
        QVERIFY(receivedInformation.canConvert(QVariant::String));
        QCOMPARE(receivedInformation.toString(), sendInformation.toString());
        break;
    }
}

//QTEST_MAIN(t_radiohswidget)