/***************************************************************************
 *   Copyright (C) 2007 by Joris Guisson and Ivan Vasic                    *
 *   joris.guisson@gmail.com                                               *
 *   ivasic@gmail.com                                                      *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 ***************************************************************************/
#include "torrentfilelistmodel.h"

#include <klocale.h>
#include <kicon.h>
#include <kmimetype.h>
#include <QTreeView>
#include <interfaces/torrentinterface.h>
#include <interfaces/torrentfileinterface.h>
#include <util/functions.h>

using namespace bt;

namespace kt
{
	

	TorrentFileListModel::TorrentFileListModel(bt::TorrentInterface* tc,DeselectMode mode,QObject* parent) 
	: TorrentFileModel(tc,mode,parent)
	{
	}


	TorrentFileListModel::~TorrentFileListModel()
	{}
	
	int TorrentFileListModel::rowCount(const QModelIndex & parent) const
	{	
		if (!parent.isValid())
			return tc->getStats().multi_file_torrent ? tc->getNumFiles() : 1;
		else
			return 0;
	}
	
	int TorrentFileListModel::columnCount(const QModelIndex & parent) const
	{
		if (!parent.isValid())
			return 2;
		else
			return 0;
	}
	
	QVariant TorrentFileListModel::headerData(int section, Qt::Orientation orientation,int role) const
	{
		if (role != Qt::DisplayRole || orientation != Qt::Horizontal)
			return QVariant();
		 
		switch (section)
		{
			case 0: return i18n("File");
			case 1: return i18n("Size");
			default:
				return QVariant();
		}
	}
	
	QVariant TorrentFileListModel::data(const QModelIndex & index, int role) const
	{
		if (!index.isValid())
			return QVariant();
			
			
		int r = index.row();
		int nfiles = rowCount(QModelIndex());
		bool multi = tc->getStats().multi_file_torrent;
		if (r < 0 || r >= nfiles)
			return QVariant();

		const TorrentStats & s = tc->getStats();
		if (role == Qt::DisplayRole || role == Qt::EditRole)
		{
			switch (index.column())
			{
				case 0: 
					if (multi)
						return tc->getTorrentFile(r).getUserModifiedPath();
					else
						return tc->getUserModifiedFileName();
				case 1: 
					if (multi)
						return BytesToString(tc->getTorrentFile(r).getSize());
					else
						return BytesToString(s.total_bytes);
				default: return QVariant();
			}
		}
		else if (role == Qt::UserRole) // sorting
		{
			switch (index.column())
			{
				case 0: 
					if (multi)
						return tc->getTorrentFile(r).getUserModifiedPath();
					else
						return tc->getUserModifiedFileName();
				case 1: 
					if (multi)
						return tc->getTorrentFile(r).getSize();
					else
						return s.total_bytes;
				default: return QVariant();
			}
		}
		else if (role == Qt::DecorationRole && index.column() == 0)
		{
			// if this is an empty folder then we are in the single file case
			if (multi)
				return KIcon(KMimeType::findByPath(tc->getTorrentFile(r).getPath())->iconName());
			else
				return KIcon(KMimeType::findByPath(s.torrent_name)->iconName());
		}
		else if (role == Qt::CheckStateRole && index.column() == 0)
		{
			if (multi)
				return tc->getTorrentFile(r).doNotDownload() ? Qt::Unchecked : Qt::Checked;;
		}
		
		return QVariant();
	}
	
	QModelIndex TorrentFileListModel::parent(const QModelIndex & index) const
	{
        Q_UNUSED(index)
		return QModelIndex();
	}
	
	QModelIndex TorrentFileListModel::index(int row,int column,const QModelIndex & parent) const
	{
		if (!hasIndex(row, column, parent))
			return QModelIndex();
		else
		{
			bt::TorrentFileInterface* f = &tc->getTorrentFile(row);
			return createIndex(row,column,f);
		}
	}
	
	bool TorrentFileListModel::setData(const QModelIndex & index, const QVariant & value, int role) 
	{
		if (!index.isValid())
			return false;
		
		if (role == Qt::CheckStateRole)
		{
			Qt::CheckState newState = static_cast<Qt::CheckState>(value.toInt());
			bt::TorrentFileInterface & file = tc->getTorrentFile(index.row());
			if (newState == Qt::Checked)
			{
				if (file.getPriority() == ONLY_SEED_PRIORITY)
					file.setPriority(NORMAL_PRIORITY);
				else
					file.setDoNotDownload(false);
			}
			else
			{
				if (mode == KEEP_FILES)
					file.setPriority(ONLY_SEED_PRIORITY);
				else
					file.setDoNotDownload(true);
			}
			dataChanged(createIndex(index.row(),0),createIndex(index.row(),columnCount(index) - 1));
			checkStateChanged();
			return true;
		}
		else if (role == Qt::EditRole)
		{
			QString path = value.toString();
			if (path.isEmpty())
				return false;
			
			if (tc->getStats().multi_file_torrent)
			{
				bt::TorrentFileInterface & file = tc->getTorrentFile(index.row());
				// keep track of modified paths
				file.setUserModifiedPath(path);	
			}
			else
			{
				// change the name of the file or toplevel directory
				tc->setUserModifiedFileName(path);
			}
			dataChanged(createIndex(index.row(),0),createIndex(index.row(),columnCount(index) - 1));
			return true;
		}
		
		return false;
	}

	void TorrentFileListModel::checkAll()
	{
		if (tc->getStats().multi_file_torrent)
		{
			for (Uint32 i = 0;i < tc->getNumFiles();++i)
				setData(index(i,0,QModelIndex()),Qt::Checked,Qt::CheckStateRole);
		}
	}

	void TorrentFileListModel::uncheckAll()
	{
		if (tc->getStats().multi_file_torrent)
		{
			for (Uint32 i = 0;i < tc->getNumFiles();++i)
				setData(index(i,0,QModelIndex()),Qt::Unchecked,Qt::CheckStateRole);
		}
	}

	void TorrentFileListModel::invertCheck()
	{
		if (!tc->getStats().multi_file_torrent)
			return;

		for (Uint32 i = 0;i < tc->getNumFiles();++i)
			invertCheck(index(i,0,QModelIndex()));
	}

	void TorrentFileListModel::invertCheck(const QModelIndex & idx)
	{
		if (tc->getTorrentFile(idx.row()).doNotDownload())
			setData(idx,Qt::Checked,Qt::CheckStateRole);
		else
			setData(idx,Qt::Unchecked,Qt::CheckStateRole);
	}

	bt::Uint64 TorrentFileListModel::bytesToDownload()
	{
		if (tc->getStats().multi_file_torrent)
		{
			bt::Uint64 ret = 0;
			for (Uint32 i = 0;i < tc->getNumFiles();++i)
			{
				const bt::TorrentFileInterface & file = tc->getTorrentFile(i);
				if (!file.doNotDownload())
					ret += file.getSize();
			}
			return ret;
		}
		else
			return tc->getStats().total_bytes;
	}

	bt::TorrentFileInterface* TorrentFileListModel::indexToFile(const QModelIndex & idx)
	{
		if (!idx.isValid())
			return 0;
		
		int r = idx.row();
		if (r < 0 || r >= rowCount(QModelIndex()))
			return 0;
		else
			return &tc->getTorrentFile(r);
	}
	
	QString TorrentFileListModel::dirPath(const QModelIndex & idx)
	{
		if (!idx.isValid())
			return QString();
		
		int r = idx.row();
		if (r < 0 || r >= rowCount(QModelIndex()))
			return QString();
		else
			return tc->getTorrentFile(r).getPath();
	}
	
	void TorrentFileListModel::changePriority(const QModelIndexList & indexes,bt::Priority newpriority)
	{
		foreach (const QModelIndex &idx,indexes)
		{
			setData(idx,newpriority,Qt::UserRole);
		}
	}
}

#include "torrentfilelistmodel.moc"
