/**

* 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:	 tester	for	methods	in VideoListView

*

*/

#include <QtTest/QtTest>

#include <hbapplication.h>

#include <hbinstance.h>

#include <qactiongroup.h>

#include <hbmenu.h>

#include <hbtoolbar.h>

#include <hbaction.h>

#include <videocollectioncommon.h>

#include <hbstackedwidget.h>

#include <hbgroupbox.h>

#include <hbdocumentloader.h>

#include <qhash.h>

#include <qmap.h>

#include <hbview.h>

#include <hblistview.h>

#include <mpxitemid.h>

#include <vcxmyvideosdefs.h>

#include "videocollectionwrapper.h"

#include "testlistview.h"

#include "videocollectionviewutils.h"

#include "videolistselectiondialog.h"

#include "videosortfilterproxymodel.h"

#include "videocollectionwrapper.h"

#include "videohintwidget.h"

#include "videolistwidgetdata.h"

#include "videocollectionwrapperdata.h"

#include "videocollectionviewutilsdata.h"

#include "videolistselectiondialogdata.h"

#include "videosortfilterproxymodeldata.h"

#include "videocollectionuiloaderdata.h"

#include "videolistdatamodeldata.h"

#define	private	public

#include "videolistwidget.h"

#include "videocollectionuiloader.h"

#include "videolistview.h"

#undef private

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

// main

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

//

int	main(int argc, char	*argv[])

{

	HbApplication app(argc,	argv);

	HbMainWindow window;

	TestListView tv;

    int res;

    if(argc > 1)

    {   

        res = QTest::qExec(&tv, argc, argv);

    }

    else

    {

    	char *pass[3];

    	pass[0]	= argv[0];

    	pass[1]	= "-o";

    	pass[2]	= "c:\\data\\testlistview.txt";

        res = QTest::qExec(&tv, 3, pass);

    }

	return res;

}

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

// init

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

//

void TestListView::init(bool initTestView)

{

	mUiLoader = new VideoCollectionUiLoader();

	mUiLoader->reset();

	bool ok(false);

	QList<QObject *> objects = mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);

    if (!ok)

    {

    	return;

    }

    mTestView = mUiLoader->findObject<VideoListView>( DOCML_NAME_VIEW );

    QVERIFY(mTestView);

    if(initTestView)

    {

        QVERIFY(mTestView->initializeView() == 0);

    }

    mListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

    QVERIFY(mListWidget);

	mWrapper = &VideoCollectionWrapper::instance();

	QVERIFY(mWrapper);

}

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

// cleanup

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

//

void TestListView::cleanup()

{

	delete mTestView;

	mTestView =	0;

	mWrapper = 0;

	disconnect();

    VideoListWidgetData::reset();

    VideoCollectionWrapperData::reset();

    VideoCollectionViewUtilsData::reset();

    VideoListSelectionDialogData::reset();

    VideoSortFilterProxyModelData::reset();

}

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

// visibleMenuActions

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

//

int	TestListView::visibleMenuActions()

{

	int	visibleActions(0);

	VideoCollectionUiLoader::ActionIds key;

	HbAction *action(0);

	foreach(key,mUiLoader->mMenuActions.keys())

	{

		action = dynamic_cast<HbAction*>(mUiLoader->mMenuActions[key]);

		if(action && action->isVisible())

			visibleActions++;

	}

	return visibleActions;

}

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

// setRowCount

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

//

void TestListView::setRowCount(int count)

{

    if (mTestView)

    {

        if (!mTestView->mCurrentList)

        {

            mTestView->activateView();

        }

        VideoSortFilterProxyModel *model = mTestView->mCurrentList->mModel;

        if (model)

        {

            VideoListDataModel *sourceModel =

                qobject_cast<VideoListDataModel*>(

                    model->sourceModel());

            if (sourceModel)

            {

                VideoListDataModelData::setRowCount(*sourceModel, count);

            }

        }

    }

}

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

// testCreateDelete

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

//

void TestListView::testCreateDelete()

{

    mWrapper = 0;

    mUiLoader = new VideoCollectionUiLoader();

	mUiLoader->reset();

	bool ok(false);

	QList<QObject *> objects = mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);

    if (!ok)

    {

    	return;

    }

    mTestView = mUiLoader->findObject<VideoListView>( DOCML_NAME_VIEW );

    delete mTestView;

	mTestView =	0;

}

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

// Slot: test initialize view

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

//

void TestListView::testInitializeView()

{

    VideoListWidget *videoListWidget = 0;

    VideoHintWidget *hintWidget = 0;

    init(false);

	// Test	videolist widget creation failure.

	VideoListWidgetData::mInitializeReturnValue	= -1;

	QVERIFY( mTestView->initializeView() < 0 );

	QVERIFY( mTestView->mToolbarViewsActionGroup == 0 );

	QVERIFY( mTestView->mToolbarCollectionActionGroup == 0 );

	QVERIFY( mTestView->mVideoServices == 0 );

	QVERIFY( mTestView->mIsService == false );

	cleanup();

	// Test	widget creation	succeed.

	init(false);

    VideoCollectionViewUtilsData::mSortRole = Qt::DisplayRole;

    VideoCollectionViewUtilsData::mSortOrder = Qt::DescendingOrder;

	QVERIFY( mTestView->initializeView() ==	0 );

	// Verify

	QCOMPARE( VideoListWidgetData::mInitializeCount, 1 );

	QVERIFY( mTestView->mToolbarViewsActionGroup != 0 );

	QVERIFY( mTestView->mToolbarCollectionActionGroup != 0 );

	QCOMPARE( mTestView->mToolbarViewsActionGroup->actions().count(), 3 );

	QCOMPARE( mTestView->mToolbarCollectionActionGroup->actions().count(), 3 );

	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );

	// to my understanding the all videos action should	always be first.

	QVERIFY( mTestView->mToolbarViewsActionGroup->actions().first()->isChecked()	);

	QCOMPARE( VideoSortFilterProxyModelData::mSortRole, (int)Qt::DisplayRole );

	QCOMPARE( VideoSortFilterProxyModelData::mSortOrder, Qt::DescendingOrder );

	QVERIFY( VideoSortFilterProxyModelData::mSortAsync == false );

	QVERIFY( mTestView->mVideoServices == 0 );

	QVERIFY( mTestView->mIsService == false );

	cleanup();

	cleanup();

	// Test	command	signal.

	init(true);

	videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

    QVERIFY(videoListWidget);

	connect( this, SIGNAL(testSignal(int)),	videoListWidget, SIGNAL(command(int)) );

	QSignalSpy spy(mTestView, SIGNAL(command(int)));

	emit testSignal(5);

	QCOMPARE( spy.count(), 1 );

	QList<QVariant>	arguments =	spy.takeFirst();

	QCOMPARE( arguments.at(0).toInt(), 5 );

	disconnect();

	cleanup();

	init(true);

	QPointer<QActionGroup> toolbar = mTestView->mToolbarViewsActionGroup;

	QPointer<QActionGroup> toolbar2 = mTestView->mToolbarCollectionActionGroup;

	// Test	calling	initializeView again.

	QVERIFY( mTestView->initializeView() ==	0 );

	QVERIFY( toolbar !=	0 );

	QVERIFY( toolbar2 != 0 );

	QVERIFY( mTestView->mToolbarViewsActionGroup == toolbar );

	QVERIFY( mTestView->mToolbarCollectionActionGroup == toolbar2 );

	// Test	view deletion.

	cleanup();

	QVERIFY( toolbar ==	0 );

	QVERIFY( toolbar2 == 0 );

	// Test	get	model failure.

	init(false);

	QVERIFY(mTestView);

	VideoCollectionWrapperData::mGetModelFails	= true;

	QVERIFY( mTestView->initializeView() < 0 );

	QVERIFY( mTestView->mToolbarViewsActionGroup	== 0 );

	QVERIFY( mTestView->mToolbarCollectionActionGroup	== 0 );

	cleanup();

	// Test	model open failure.

	init(false);

	QVERIFY(mTestView);

	VideoSortFilterProxyModelData::mOpenFails =	true;

	QVERIFY( mTestView->initializeView() < 0 );

	QVERIFY( mTestView->mToolbarViewsActionGroup == 0 );

	QVERIFY( mTestView->mToolbarCollectionActionGroup == 0 );

	cleanup();

	// Test sorting value load 'failure'.

	init(false);

    VideoCollectionViewUtilsData::mSortRole = Qt::DisplayRole;

    VideoCollectionViewUtilsData::mSortOrder = Qt::DescendingOrder;

    VideoCollectionViewUtilsData::mLoadSortingValuesFails = true;

    QVERIFY( mTestView->initializeView() == 0 );

    QCOMPARE( VideoSortFilterProxyModelData::mSortRole, (int)VideoCollectionCommon::KeyDateTime );

    QCOMPARE( VideoSortFilterProxyModelData::mSortOrder, Qt::AscendingOrder );

    QVERIFY( VideoSortFilterProxyModelData::mSortAsync == false );

    cleanup();

}

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

// Slot: test create menu

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

//

void TestListView::testCreateListMenu()

{

	init(false);

	VideoListWidgetData::mInitializeReturnValue	= -1;

	QVERIFY( mTestView->initializeView() < 0 );

	HbMenu*	menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

	QVERIFY( menu );

	QCOMPARE( menu->actions().count(), 4 );

	cleanup();

	init(false);

	VideoListWidgetData::mInitializeReturnValue	= 0;

	QVERIFY( mTestView->initializeView() ==	0 );

	menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

	QVERIFY( menu );

	QCOMPARE( menu->actions().count(), 4 );

	HbAction* sortAction = dynamic_cast<HbAction*>(menu->actions().at(3));

	QVERIFY( sortAction	);

	menu = mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU);

	QVERIFY(menu !=	0);

	QVERIFY( menu->actions().count() ==	4 );

	QVERIFY( mUiLoader->mMenuActions.count() ==	9 );

	QVERIFY( mTestView->mSortingRoles.count() == 5 );

	cleanup();

}

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

// testMenus

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

//

void TestListView::testMenus()

{

	init();

	HbAction* action;

	QList<QAction*> tbActions = mTestView->toolBar()->actions();

	QList<QAction*>	tbGroupActions;

	QList<QAction*>	tbGroupActions2;

	// All videos is open for default, verify.

	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);

	QVERIFY(mTestView->mToolbarCollectionActionGroup != 0);

	tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();

	tbGroupActions2 = mTestView->mToolbarCollectionActionGroup->actions();

	QVERIFY(mTestView->mToolbarActions.count() == 6);

	QVERIFY(tbActions.count() == 3);

	QVERIFY(tbGroupActions.count() == 3);

	QVERIFY(tbGroupActions2.count() == 3);

	QVERIFY( tbGroupActions.at(0)->isChecked() ); // First is checked.

	// visible menu items remains constant after init until

	// aboutToShowMainMenuSlot is called

	QVERIFY(visibleMenuActions() == 9);

	// Verify checkable	and	visible	toolbar	actions.

	HbAction* allVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];

	HbAction* collectionsAction	= mTestView->mToolbarActions[VideoListView::ETBActionCollections];

	HbAction* servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];

	HbAction* addVideosAction =	mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];

	HbAction* removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];

	HbAction* sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];

	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable()	&& allVideosAction->isVisible() &&

			tbActions.at(0) == tbGroupActions.at(0));

	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable()	&& collectionsAction->isVisible() &&

			tbActions.at(1) == tbGroupActions.at(1));

	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable() && servicesAction->isVisible() &&

			tbActions.at(2) == tbGroupActions.at(2));

	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() &&

			tbActions.at(0) != tbGroupActions2.at(0));

	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() &&

			tbActions.at(1) != tbGroupActions2.at(1));

	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() &&

			tbActions.at(2) != tbGroupActions2.at(2));

	// Open	collections.

	action = dynamic_cast<HbAction*>(tbGroupActions.at(1));

	QVERIFY(action);

	action->setChecked(false);

	action->trigger();

	// Verify.

	QVERIFY(mTestView->mToolbarViewsActionGroup);

	tbGroupActions = mTestView->mToolbarViewsActionGroup->actions();

	QVERIFY(mTestView->mToolbarActions.count() == 6);

	QVERIFY(tbGroupActions.count() == 3);

	QVERIFY(tbGroupActions2.count() == 3);

	QVERIFY( tbGroupActions.at(1)->isChecked() ); // 2nd is	checked.

	// visible menu items remains constant after init until

	// aboutToShowMainMenuSlot is called

	QVERIFY(visibleMenuActions() ==	9);

	// Verify checkable	and	visible	toolbar	actions.

	allVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAllVideos];

	collectionsAction =	mTestView->mToolbarActions[VideoListView::ETBActionCollections];

	servicesAction = mTestView->mToolbarActions[VideoListView::ETBActionServices];

	addVideosAction	= mTestView->mToolbarActions[VideoListView::ETBActionAddVideos];

	removeVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionRemoveVideos];

	sortVideosAction = mTestView->mToolbarActions[VideoListView::ETBActionSortVideos];

	QVERIFY( allVideosAction !=	0 && allVideosAction->isCheckable()	&& allVideosAction->isVisible()	&&

			tbActions.at(0) == tbGroupActions.at(0));

	QVERIFY( collectionsAction != 0	&& collectionsAction->isCheckable()	&& collectionsAction->isVisible() &&

			tbActions.at(1) == tbGroupActions.at(1));

	QVERIFY( servicesAction	!= 0 &&	servicesAction->isCheckable() && servicesAction->isVisible() &&

			tbActions.at(2) == tbGroupActions.at(2));

	QVERIFY( addVideosAction !=	0 && !addVideosAction->isCheckable() &&

			tbActions.at(0) != tbGroupActions2.at(0));

	QVERIFY( removeVideosAction	!= 0 &&	!removeVideosAction->isCheckable() &&

			tbActions.at(1) != tbGroupActions2.at(1));

	QVERIFY( sortVideosAction != 0 && !sortVideosAction->isCheckable() &&

			tbActions.at(2) != tbGroupActions2.at(2));

	cleanup();

}

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

// Slot: test create toolbar

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

//

void TestListView::testCreateAction()

{

	init();

	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);

	QList<QAction*>	actions	= mTestView->mToolbarViewsActionGroup->actions();

	actions.append(mTestView->mToolbarCollectionActionGroup->actions());

	QVERIFY(actions.count()	== 6);

	QCOMPARE( mTestView->toolBar()->actions().count(), 3 );

	HbAction* allVideos	= static_cast<HbAction*>(actions.at(0));

	QVERIFY( allVideos->isCheckable() );

	QCOMPARE( allVideos->icon().iconName(),	QString(":/images/qtg_mono_video_all.svg")	);

	HbAction* collections =	static_cast<HbAction*>(actions.at(1));

	QVERIFY( collections->isCheckable()	);

	QCOMPARE( collections->icon().iconName(), QString(":/images/qtg_mono_video_collection.svg") );

	HbAction* services = static_cast<HbAction*>(actions.at(2));

	QVERIFY( services->isCheckable() );

	QCOMPARE( services->icon().iconName(), QString(":/images/qtg_mono_video_services.svg") );

	HbAction* addVideos	= static_cast<HbAction*>(actions.at(3));

	QVERIFY( !addVideos->isCheckable() );

	QCOMPARE( addVideos->icon().iconName(),	QString(":/images/mono_video_addvideos.svg") );

	HbAction* removeVideos = static_cast<HbAction*>(actions.at(4));

	QVERIFY( !removeVideos->isCheckable() );

	QCOMPARE( removeVideos->icon().iconName(), QString(":/images/mono_video_removevideos.svg") );

	HbAction* sortVideos = static_cast<HbAction*>(actions.at(5));

	QVERIFY( !sortVideos->isCheckable()	);

	QCOMPARE( sortVideos->icon().iconName(), QString(":/images/mono_video_sortvideos.svg") );

	cleanup();

}

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

// Slot: test activate view

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

//

void TestListView::testActivateView()

{

    VideoListWidget* videoListWidget = 0;

	init();

	videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

	QVERIFY(videoListWidget);

	mTestView->mCurrentList = 0;

	QCOMPARE( mTestView->activateView(), -1	);

    QVERIFY( VideoListWidgetData::mActive == false );

    QCOMPARE( mTestView->mCurrentList, videoListWidget );

    QCOMPARE( VideoListWidgetData::mActivateCount, 0 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

	VideoListWidgetData::mActivateReturnValue =	-1;

	QCOMPARE( mTestView->activateView(), -1	);

	QVERIFY( VideoListWidgetData::mActive == false );

	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() == false );

	VideoListWidgetData::mActivateReturnValue =	0;

	QCOMPARE( mTestView->activateView(), 0 );

	QVERIFY( VideoListWidgetData::mActive );

	QCOMPARE( VideoListWidgetData::mActivateCount, 2 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() );

	QCOMPARE( mTestView->activateView(), 0 );

	QVERIFY( VideoListWidgetData::mActive );

	QCOMPARE( VideoListWidgetData::mActivateCount, 3 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

	QVERIFY( mUiLoader->findWidget<HbMenu>(DOCML_NAME_OPTIONS_MENU)->isEnabled() );

	cleanup();

}

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

// Slot: test deactivate view

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

//

void TestListView::testDeactivateView()

{

    VideoListWidget* videoListWidget = 0;

    init();

    videoListWidget = mUiLoader->findWidget<VideoListWidget>(DOCML_NAME_VC_VIDEOLISTWIDGET);

    QVERIFY(videoListWidget);

    mTestView->mCurrentList = 0;