/**

* 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

*

*/

#define private public

#include "videoservices.h"

#include "videosortfilterproxymodel.h"

#include "videolistwidget.h"

#include "videolistview.h"

#undef private

#include <qdebug.h>

#include <xqserviceutil.h>

#include <QtTest/QtTest>

#include "hbapplication.h"

#include "hbeffect.h"

#include "hbinstance.h"

#include "hbmenu.h"

#include "hbmenudata.h"

#include "hbtoolbar.h"

#include "hbaction.h"

#include "hbstackedwidget.h"

#include "hbgroupbox.h"

#include "hbdocumentloader.h"

#include "hbview.h"

#include "hblistview.h"

#include "hbinputdialog.h"

#include <qactiongroup.h>

#include <videocollectioncommon.h>

#include <qhash.h>

#include <qmap.h>

#include <mpxitemid.h>

#include <vcxmyvideosdefs.h>

#include "videocollectionuiloader.h"

#include "videocollectionwrapper.h"

#include "testlistview.h"

#include "videocollectionviewutils.h"

#include "videolistselectiondialog.h"

#include "videocollectionwrapper.h"

#include "videohintwidget.h"

#include "videohintwidgetdata.h"

#include "videolistwidgetdata.h"

#include "videocollectionwrapperdata.h"

#include "videocollectionviewutilsdata.h"

#include "videolistselectiondialogdata.h"

#include "videosortfilterproxymodeldata.h"

#include "videocollectionuiloaderdata.h"

#include "videolistdatamodeldata.h"

#include "xqserviceutilxtra.h"

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

// main

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

//

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

{

	HbApplication app(argc,	argv);

	HbMainWindow window;

	hbInstance->mWindowses.append(&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

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

//

{

    XQServiceUtilXtra::service = false;

	mUiLoader = new VideoCollectionUiLoader();

	mUiLoader->reset();

	bool ok(false);

	mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);

    if (!ok)

    {

    	return;

    }

    mTestView = mUiLoader->findWidget<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 mUiLoader;

	mUiLoader = 0;

	mWrapper = 0;

	mTestView = 0;

	disconnect();

    VideoListWidgetData::reset();

    VideoCollectionWrapperData::reset();

    VideoCollectionViewUtilsData::reset();

    VideoListSelectionDialogData::reset();

    VideoSortFilterProxyModelData::reset();

    HbDocumentLoader::cleanup();

}

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

// visibleMenuActions

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

//

int	TestListView::visibleMenuActions()

{

	int	visibleActions(0);

	VideoCollectionUiLoader::ActionIds key;

	HbAction *action(0);

	foreach (key,VideoCollectionUiLoaderData::mMenuActions.keys())

	{

		action = dynamic_cast<HbAction*>(VideoCollectionUiLoaderData::mMenuActions[key]);

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

		{

            visibleActions++;

		}

	}

	return visibleActions;

}

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

// setRowCount

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

//

void TestListView::setRowCount(int count, VideoSortFilterProxyModel *model)

{

    if(!model)

    {

        if (mTestView)

        {

            if (!mTestView->mCurrentList)

            {

                TMPXItemId tmpId = TMPXItemId::InvalidId();

                mTestView->activateView(tmpId);

            }

            model = mTestView->mCurrentList->mModel;

        }

    }

    if (model)

    {

        VideoListDataModel *sourceModel =

            qobject_cast<VideoListDataModel*>(

                model->sourceModel());

        if(sourceModel)

        {

            VideoListDataModelData::setRowCount(*sourceModel, count);

        }

    }

}

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

// isActionVisible

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

//

bool TestListView::isActionVisible(const char *name) const

{

    bool isVisible = false;

    HbAction *action = mUiLoader->findObject<HbAction>(name);

    if (!action)

    {

        // must be menu widget

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

        if (menu)

        {

            action = menu->menuAction();

        }

    }

    // check if action is visible

    if (action)

    {

        isVisible = action->isVisible();

    }

    return isVisible;

}

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

// testCreateDelete

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

//

void TestListView::testCreateDelete()

{

    mWrapper = 0;

    mUiLoader = new VideoCollectionUiLoader();

	mUiLoader->reset();

	bool ok(false);

	mUiLoader->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);

    if (!ok)

    {

    	return;

    }

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

    delete mTestView;

	mTestView =	0;

}

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

// Slot: test initialize view

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

//

void TestListView::testInitializeView()

{

    VideoListWidget *videoListWidget = 0;

    VideoHintWidget *hintWidget = 0;

    init(false);

	// Test mUiLoader is null

    VideoCollectionUiLoader *tmp = mTestView->mUiLoader;

	mTestView->mUiLoader = 0;

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

	QVERIFY( mTestView->mVideoServices == 0 );

	mTestView->mUiLoader = tmp;

	// service flag is false and mVideoServices is != 0

	XQServiceUtilXtra::service = false;

	VideoServices *tmpService = VideoServices::instance(); 

	mTestView->mVideoServices = tmpService;

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

    QVERIFY( mTestView->mVideoServices == 0 );

    tmpService->decreaseReferenceCount();

    // service flag is true, mVideoServices is 0

    mTestView->mVideoServices = 0;

    XQServiceUtilXtra::service = true;

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

    QVERIFY( mTestView->mVideoServices != 0 );

    XQServiceUtilXtra::service = false;

	cleanup();	

}

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

// testMenus

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

//

void TestListView::testMenus()

{

    init();

    TMPXItemId tmpId = TMPXItemId::InvalidId();

    mTestView->activateView(tmpId);

    HbAction* action = 0;

    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();

    QCOMPARE( mTestView->mToolbarActions.count(), 5 );

    QCOMPARE( tbActions.count(), 3 );

    QCOMPARE( tbGroupActions.count(), 3 );

    QCOMPARE( tbGroupActions2.count(), 2 );

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

    // 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];

    QVERIFY( allVideosAction !=	0 );

    QVERIFY( allVideosAction->isCheckable()	);

    QVERIFY( allVideosAction->isVisible() );

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

    QVERIFY( collectionsAction != 0	);

    QVERIFY( collectionsAction->isCheckable() );

    QVERIFY( collectionsAction->isVisible() );

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

    QVERIFY( servicesAction	!= 0 );

    QVERIFY( !servicesAction->isCheckable() );

    QVERIFY( servicesAction->isVisible() );

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

    QVERIFY( addVideosAction !=	0 );

    QVERIFY( !addVideosAction->isCheckable() );

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

    QVERIFY( removeVideosAction	!= 0 );

    QVERIFY( !removeVideosAction->isCheckable() );

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

    // Open	collections.

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

    QVERIFY( action );

    action->setChecked(false);

    action->QAction::trigger();

    // Verify.

    QVERIFY( mTestView->mToolbarViewsActionGroup );

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

    QCOMPARE( mTestView->mToolbarActions.count(), 5 );

    QCOMPARE( tbGroupActions.count(), 3 );

    QCOMPARE( tbGroupActions2.count(), 2 );

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

    // 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];

    QVERIFY( allVideosAction !=	0 );

    QVERIFY( allVideosAction->isCheckable()	);

    QVERIFY( allVideosAction->isVisible() );

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

    QVERIFY( collectionsAction != 0	);

    QVERIFY( collectionsAction->isCheckable() );

    QVERIFY( collectionsAction->isVisible() );

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

    QVERIFY( servicesAction	!= 0 );

    QVERIFY( !servicesAction->isCheckable() );

    QVERIFY( servicesAction->isVisible() );

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

    QVERIFY( addVideosAction !=	0 );

    QVERIFY( !addVideosAction->isCheckable() );

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

    QVERIFY( removeVideosAction	!= 0 );

    QVERIFY( !removeVideosAction->isCheckable() );

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

    cleanup();

}

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

// Slot: test create toolbar

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

//

void TestListView::testCreateAction()

{

	init();

	TMPXItemId tmpId = TMPXItemId::InvalidId();

	mTestView->activateView(tmpId);

	QVERIFY(mTestView->mToolbarViewsActionGroup != 0);

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

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

	QCOMPARE(actions.count(), 5);

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

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

	QVERIFY( allVideos->isCheckable() );

	QCOMPARE( allVideos->icon().iconName(),	QString("qtg_mono_video") );

	QVERIFY( allVideos->isChecked() );

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

	QVERIFY( collections->isCheckable()	);

	QCOMPARE( collections->icon().iconName(), QString("qtg_mono_video_collection") );

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

	QVERIFY( !services->isCheckable() );

	QCOMPARE( services->icon().iconName(), QString("qtg_mono_ovistore") );

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

	QVERIFY( !addVideos->isCheckable() );

	QCOMPARE( addVideos->icon().iconName(),	QString("qtg_mono_add_to_video_collection") );

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

	QVERIFY( !removeVideos->isCheckable() );

	QCOMPARE( removeVideos->icon().iconName(), QString("qtg_mono_remove_from_video_collection") );

	cleanup();

}

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

// Slot: test activate view

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

//

void TestListView::testActivateView()

{

    VideoListWidget* videoListWidget = 0;

    TMPXItemId invalidId = TMPXItemId::InvalidId();

	init();

	HbMainWindow *mainWnd = hbInstance->allMainWindows().value(0);

	mainWnd->unsetOrientation(false);

    VideoListWidget *backup = mTestView->mCurrentList;

	mTestView->mCurrentList = 0;

	HbDocumentLoader::mFindWidgetFails = true;

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

    QVERIFY( VideoListWidgetData::mActive == false );

    QVERIFY( mTestView->mCurrentList == 0 );

    QCOMPARE( VideoListWidgetData::mActivateCount, 0 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 0 );

	QVERIFY( mainWnd->mOrientationSet == false );

	mTestView->mCurrentList = backup;

    HbDocumentLoader::mFindWidgetFails = false;

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

    QVERIFY(videoListWidget);

	VideoListWidgetData::mActivateReturnValue =	-1;

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

	QVERIFY( VideoListWidgetData::mActive == false );

	QCOMPARE( VideoListWidgetData::mActivateCount, 1 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

    QVERIFY( mainWnd->mOrientationSet == false );

	VideoListWidgetData::mActivateReturnValue =	0;

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

	QVERIFY( VideoListWidgetData::mActive );

	QCOMPARE( VideoListWidgetData::mActivateCount, 2 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

    QVERIFY( mainWnd->mOrientationSet );

    QCOMPARE( mainWnd->mOrientation, Qt::Vertical );

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

	QVERIFY( VideoListWidgetData::mActive );

	QCOMPARE( VideoListWidgetData::mActivateCount, 3 );

	QCOMPARE( VideoListWidgetData::mDeactivateCount, 1 );

    QVERIFY( mainWnd->mOrientationSet );

    QCOMPARE( mainWnd->mOrientation, Qt::Vertical );

    cleanup();

    // activate collection content view:

    // -captured category

    TMPXItemId itemId = TMPXItemId::InvalidId();

    init();

    VideoListWidgetData::reset();

    VideoSortFilterProxyModelData::reset();

    itemId.iId1 = KVcxMvcCategoryIdCaptured;

    itemId.iId2 = KVcxMvcMediaTypeCategory;

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

    QVERIFY(VideoListWidgetData::mActive);

    QCOMPARE(VideoListWidgetData::mActivateCount, 1);

    QCOMPARE(mTestView->mCollectionName, hbTrId("txt_videos_dblist_captured"));

    QCOMPARE(mTestView->mCurrentList->getLevel(), VideoCollectionCommon::ELevelDefaultColl);

    QCOMPARE(VideoSortFilterProxyModelData::mLastItemId, itemId);

    cleanup();