/****************************************************************************
**
** 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 HbWidgets 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 <QGraphicsLinearLayout>
#include <qglobal.h>
#include "hbabstractviewitem.h"
#include "hbselectiondialog_p.h"
#include <hblabel.h>
#include <hblistwidget.h>
#include <hblistwidgetitem.h>
#include <QtDebug>
#include <hbcheckbox.h>
#include <hbaction.h>


HbSelectionDialogContentWidget::HbSelectionDialogContentWidget(HbSelectionDialogPrivate *priv):HbWidget(),
						mListWidget(0),d(priv),chkMark(0),lbCounter(0)
{
    mListWidget = new HbListWidget(this);
	HbStyle::setItemName(mListWidget, "list");
    QObject::connect(mListWidget,SIGNAL(activated(const QModelIndex&)),this,SLOT(_q_listItemSelected(QModelIndex)));
    QObject::connect(mListWidget,SIGNAL(activated(HbListWidgetItem *)),this,SLOT(_q_listWidgetItemSelected(HbListWidgetItem *)));
}


void HbSelectionDialogContentWidget::_q_listWidgetItemSelected(HbListWidgetItem *item)
{
	if(item){
		updateCounter();
	}
}


void HbSelectionDialogContentWidget::_q_listItemSelected(QModelIndex index)
{
	Q_UNUSED(index)
	if(mListWidget->selectionMode()== HbAbstractItemView::SingleSelection ||
	   mListWidget->selectionMode()== HbAbstractItemView::NoSelection){
	   d->close();   
	}
	updateCounter();
}

int HbSelectionDialogContentWidget::selectedItemCount() const
{
	int selectedItems = 0;
	QItemSelectionModel* selectionModel = mListWidget->selectionModel();
	if(selectionModel){
		selectedItems = selectionModel->selectedRows().count();
	}
	return selectedItems;
}

int HbSelectionDialogContentWidget::totalItemCount() const
{
	return mListWidget->count();
}

void HbSelectionDialogContentWidget::updateCounter()
{
	if(mListWidget->selectionMode()!= HbAbstractItemView::MultiSelection) return;
	if(chkMark && lbCounter){
		int totalItems = totalItemCount();
		int selectedItems = selectedItemCount();

		lbCounter->setText(QString(QString::number(selectedItems) + "/" + QString::number(totalItems)));
		//update checked state of "MarkAll" checkbox 
		if (selectedItems == totalItems){
			chkMark->blockSignals(true); //should not call _q_checkboxclicked()
			chkMark->setChecked(true);
			chkMark->blockSignals(false);
		}
		else{
			chkMark->blockSignals(true); //should not call _q_checkboxclicked()
			chkMark->setChecked(false);
			chkMark->blockSignals(false);
		}
	}
}

void HbSelectionDialogContentWidget::_q_checkboxclicked(int value)
{
	int totalItems = 0;
	int selectedItems = 0;
	QAbstractItemModel* itemModel = mListWidget->model();
	QModelIndex indexStart,indexEnd;
	if(itemModel){
		indexStart = itemModel->index(0,0);
		indexEnd = itemModel->index(itemModel->rowCount()-1,0);
		totalItems = itemModel->rowCount();
	}

	QItemSelectionModel* selectionModel = mListWidget->selectionModel();
	if(selectionModel){
		selectedItems = selectionModel->selectedRows().count();
		if(value){ //Select All
			selectionModel->select(QItemSelection(indexStart,indexEnd),QItemSelectionModel::Select);
		}
		else{ //Select None
			selectionModel->clear();
		}
	}
	updateCounter();
}


void HbSelectionDialogContentWidget::showMarkWidget(bool bShow)
{
	if(bShow){
			chkMark = new HbCheckBox(this);
			chkMark->setText("Mark All");
			lbCounter = new HbTextItem(this);
			HbStyle::setItemName(chkMark,"checkbox");
			HbStyle::setItemName(lbCounter,"counter");
			setProperty("multiSelection",true);
			connect(chkMark,SIGNAL(stateChanged ( int )),this,SLOT(_q_checkboxclicked(int)));
			updateCounter();
	}
	else{
		delete chkMark;chkMark=0;
		delete lbCounter;lbCounter=0;
		HbStyle::setItemName(chkMark,"");
		HbStyle::setItemName(lbCounter,"");
		setProperty("multiSelection",false);
	}
}

HbSelectionDialogPrivate::HbSelectionDialogPrivate()
    :HbDialogPrivate()
{
	bOwnItems = false;
}


HbSelectionDialogPrivate::~HbSelectionDialogPrivate()
{
	if(!bOwnItems){
			Q_Q(HbSelectionDialog);
			HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
			if(cWidget){
				if(cWidget->mListWidget){
                    int nRows = 0;
                    QAbstractItemModel* itemModel = cWidget->mListWidget->model();
                    if(itemModel){
                        nRows = itemModel->rowCount();
                        while(nRows){
                            cWidget->mListWidget->takeItem(0);
                            nRows = itemModel->rowCount();
                        }
                    }
				}
			}
	}
}
void HbSelectionDialogPrivate::init()
{
    qDebug()<<" Entering init()";
    Q_Q(HbSelectionDialog);

    bOwnItems = false;

    HbSelectionDialogContentWidget* contentWidget = new HbSelectionDialogContentWidget(this);
    q->setContentWidget(contentWidget);

    q->setPrimaryAction(new HbAction(QString(q->tr("Ok"))));

    q->setSecondaryAction(new HbAction(QString(q->tr("Cancel"))));
    q->setTimeout(0);
    q->setModal(true);


}



void HbSelectionDialogPrivate::setSelectionMode(HbAbstractItemView::SelectionMode mode)
{
	Q_Q(HbSelectionDialog);

	mSelectionMode = mode;
	switch(mode)
	{
	case HbAbstractItemView::SingleSelection:
	case HbAbstractItemView::MultiSelection:
	case HbAbstractItemView::NoSelection:
	{
		HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
		if(cWidget){
			cWidget->mListWidget->setSelectionMode(mode);
		}
		if(mode == HbAbstractItemView::MultiSelection)
			cWidget->showMarkWidget(true);	
		else
			cWidget->showMarkWidget(false);	
	}
	break;
	case HbAbstractItemView::ContiguousSelection:
		break;
	}
}

QList<HbListWidgetItem*> HbSelectionDialogPrivate::widgetItems() const
{
	Q_Q(const HbSelectionDialog);

	QList<HbListWidgetItem*> rows;
	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(cWidget){
		HbListWidget* widget = qobject_cast<HbListWidget*>(cWidget->mListWidget);
		if(widget){
            int count = 0;
            QAbstractItemModel* itemModel = widget->model();
            if(itemModel)
                count = itemModel->rowCount();
			for(int i = 0; i < count; i++){
				rows.append(widget->item(i));
			}
		}
	}
	return rows;
}

void HbSelectionDialogPrivate::setStringItems(const QStringList &items, int currentIndex)
{
	Q_Q(HbSelectionDialog);

	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(!cWidget) return;
	
    int nRows = 0;

	if(cWidget->mListWidget){
		int count = items.size();
		for (int i = 0; i < count; ++i) {
			HbListWidgetItem* modelItem = new HbListWidgetItem();
			QString str = items.at(i);
			modelItem->setText(str);
			cWidget->mListWidget->addItem(modelItem);
			
            QAbstractItemModel* itemModel = cWidget->mListWidget->model();
            if(itemModel)
                nRows = itemModel->rowCount();
		}
		if(nRows > 0){ //if addition of rows was correct.
            QList<QVariant> currentRow;
            currentRow.append(QVariant(currentIndex));
            setSelectedItems(currentRow);
		}
		
	}
}

QStringList HbSelectionDialogPrivate::stringItems() const
{
	QStringList list;
	QList<HbListWidgetItem*> items = widgetItems();
	int count = items.count();
	for(int i = 0; i < count; i++){
                QString text = items[i]->text();
                if(!text.isEmpty()){
			list += text;
		}
	}
	return list;
}

void HbSelectionDialogPrivate::setModel(QAbstractItemModel* model)
{
	Q_Q(HbSelectionDialog);

	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(cWidget){
		cWidget->mListWidget->HbListView::setModel(model); //HbListView's implementation of setModel()
	}
}

void HbSelectionDialogPrivate::setWidgetItems(const QList<HbListWidgetItem*> &items,bool transferOwnership,int currentIndex)
{
	Q_Q(HbSelectionDialog);

	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(cWidget){
		if(cWidget->mListWidget){
			int count = items.count();
			for(int i = 0; i < count; i++){
				cWidget->mListWidget->addItem(items[i]);
			}
			cWidget->mListWidget->setCurrentRow(currentIndex);
			
		}
		bOwnItems = transferOwnership;
	}
}

QAbstractItemModel* HbSelectionDialogPrivate::model() const
{
	Q_Q(const HbSelectionDialog);
	
	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(cWidget){
		return cWidget->mListWidget->HbListView::model(); //HbListView's implementation of model()
	}
	return 0;
}

QItemSelectionModel* HbSelectionDialogPrivate::selectionModel() const
{
	Q_Q(const HbSelectionDialog);
	
	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(cWidget){
		return cWidget->mListWidget->selectionModel();
	}
	return 0;
}

void HbSelectionDialogPrivate::setSelectedItems(const QList<QVariant> items)
{
	Q_Q(const HbSelectionDialog);
    QItemSelectionModel *model = 0;
    model = selectionModel();
    if(model){
        Q_FOREACH(QVariant i,items) {
                model->select(model->model()->index(i.toInt(),0),
                    QItemSelectionModel::Select);
        }
    }
	HbSelectionDialogContentWidget* cWidget = qobject_cast<HbSelectionDialogContentWidget*>(q->contentWidget());
	if(cWidget){
		cWidget->updateCounter();
	}
}

QList<QVariant> HbSelectionDialogPrivate::selectedItems() const
{
    QItemSelectionModel *model = 0;
    QList<QVariant> selIndexes;
    model = selectionModel();
    if(model){
        QModelIndexList indexes = model->selectedIndexes();
        int count = indexes.count();
        QModelIndex index;
        for(int i = 0 ; i < count ; i++){
            index = indexes[i];
            selIndexes.append(QVariant(index.row()));
        }
    }
    return selIndexes;

}

QModelIndexList HbSelectionDialogPrivate::selectedModelIndexes() const
{
    QItemSelectionModel *model = 0;
    QModelIndexList selIndexes;
    model = selectionModel();
    if(model){
        selIndexes =  model->selectedIndexes();
    }
    return selIndexes;
}

void HbSelectionDialogPrivate::close()
{
	Q_Q(HbSelectionDialog);
	q->close();
}