/*
    kopeteonlinestatusmanager.cpp

    Copyright (c) 2004 by Olivier Goffart  <ogoffart@kde.fr>
    Copyright (c) 2003 by Will Stephenson <wstephenson@kde.org>

    Kopete    (c) 2003-2007 by the Kopete developers  <kopete-devel@kde.org>

    *************************************************************************
    *                                                                       *
    * This library is free software; you can redistribute it and/or         *
    * modify it under the terms of the GNU Lesser General Public            *
    * License as published by the Free Software Foundation; either          *
    * version 2 of the License, or (at your option) any later version.      *
    *                                                                       *
    *************************************************************************
*/

#include "kopeteonlinestatusmanager.h"

#include "kopeteprotocol.h"
#include "kopetebehaviorsettings.h"

#include <kiconloader.h>
#include <kiconeffect.h>
#include <kglobalsettings.h>
#include <kdebug.h>
#include <kicon.h>

#include <algorithm> // for min

namespace Kopete {


class OnlineStatusManager::Private
{
public:
	struct QMapDummyValue
	{
	};

	typedef QMap< OnlineStatus , QMapDummyValue >  RegisteredStatusMap;

	QPixmap *nullPixmap;
	QMap< Protocol* , RegisteredStatusMap > registeredStatus;
	QHash< QString, QPixmap* > iconCache;
};

OnlineStatusManager *OnlineStatusManager::self()
{
	static OnlineStatusManager s;
	return &s;
}

OnlineStatusManager::OnlineStatusManager()
 : d( new Private )
{
	// no autodelete, removing everything in destructor
//	d->iconCache.setAutoDelete( true );
	d->nullPixmap = new QPixmap;
	connect( KGlobalSettings::self(), SIGNAL( iconChanged(int) ), this, SLOT( slotIconsChanged() ) );
}

OnlineStatusManager::~OnlineStatusManager()
{
	QHashIterator<QString, QPixmap*> it(d->iconCache);
	while ( it.hasNext() )
	{
		it.next();
		delete it.value();
	}

	delete d->nullPixmap;
	delete d;
}

void OnlineStatusManager::slotIconsChanged()
{
	// shall we delete all of em first ?
	d->iconCache.clear();
	emit iconsChanged();
}

void OnlineStatusManager::registerOnlineStatus( const OnlineStatus &status )
{
	d->registeredStatus[status.protocol()].insert( status, Private::QMapDummyValue() );
}

OnlineStatus OnlineStatusManager::onlineStatus(Protocol * protocol, Categories category) const
{
	/* Each category has a number which is a power of two, so it is possible to have several categories per online status
	 * the logaritm in base two if this number, which represent the bit which is equal to 1 in the number is chosen to be in a tree
	 *           1     (0 is reserved for Offline)
	 *         /   \
	 *        2      3
	 *      / \     /  \
	 *     4  5     6    7
	 *   /\  / \   / \   / \
	 *  8 9 10 11 12 13 14 15
	 *  To get the parent of a key, one just divide per two the number
	 */

	const Private::RegisteredStatusMap protocolMap=d->registeredStatus[protocol];

	int categ_nb=-1;  //the logaritm of category
	uint category_=category;
	while(category_)
	{
		category_ >>= 1;
		categ_nb++;
	} //that code will give the log +1

	do
	{
		Private::RegisteredStatusMap::ConstIterator it;
		for ( it = protocolMap.begin(); it != protocolMap.end(); ++it )
		{
			unsigned int catgs=it.key().categories();
			if(catgs & (1<<(categ_nb)))
				return it.key();
		}
		//no status found in this category, try the previous one.
		categ_nb=(int)(categ_nb/2);
	} while (categ_nb > 0);

	kWarning() << "No status in the category " << category << " for the protocol " << protocol->displayName();
	return OnlineStatus();
}

OnlineStatusManager::Category OnlineStatusManager::initialStatus() const
{
    Kopete::OnlineStatusManager::Category statusValue = Kopete::OnlineStatusManager::Offline;
		switch( Kopete::BehaviorSettings::self()->initialStatus() )
		{
		  case Kopete::BehaviorSettings::EnumInitialStatus::Offline:
			statusValue = Kopete::OnlineStatusManager::Offline;
		  break;
		  case Kopete::BehaviorSettings::EnumInitialStatus::Online:
			statusValue = Kopete::OnlineStatusManager::Online;
		  break;
		  case Kopete::BehaviorSettings::EnumInitialStatus::Away:
			statusValue = Kopete::OnlineStatusManager::Away;
		  break;
		  case Kopete::BehaviorSettings::EnumInitialStatus::Busy:
			statusValue = Kopete::OnlineStatusManager::Busy;
		  break;
		  case Kopete::BehaviorSettings::EnumInitialStatus::Invisible:
			statusValue = Kopete::OnlineStatusManager::Invisible;
		  break;
		}

    return statusValue;
}

QString OnlineStatusManager::fingerprint( const OnlineStatus &statusFor, const QString& icon, int size, QColor color, bool idle)
{
	// create a 'fingerprint' to use as a hash key
	// fingerprint consists of description/icon name/color/overlay name/size/idle state
	return QString::fromLatin1("%1/%2/%3/%4/%5/%6")
	                           .arg( statusFor.description() )
	                           .arg( icon )
	                           .arg( color.name() )
	                           .arg( statusFor.overlayIcons().join( QString::fromLatin1( "," ) ) )
	                           .arg( size )
	                           .arg( idle ? 'i' : 'a' );
}

QPixmap OnlineStatusManager::cacheLookupByObject( const OnlineStatus &statusFor, const QString& icon, int size, QColor color, bool idle)
{
	QString fp = fingerprint( statusFor, icon, size, color, idle );

	//kDebug(14010) << "finger print:" << fp << ", icon: " << icon;
	// look it up in the cache
	QPixmap *theIcon = d->iconCache.value(fp);
	if ( !theIcon )
	{
		// cache miss
		kDebug(14010) << "Missed " << fp << " in icon cache!";
		theIcon = renderIcon( statusFor, icon, size, color, idle);
		d->iconCache[fp] = theIcon;
	}
	return *theIcon;
}

QPixmap OnlineStatusManager::cacheLookupByMimeSource( const QString &mimeSource )
{
	// look it up in the cache
	const QPixmap *theIcon= d->iconCache.find( mimeSource ).value();
	if ( !theIcon )
	{
		// need to return an invalid pixmap
		theIcon = d->nullPixmap;
	}
	return *theIcon;
}

// This code was forked from the broken KImageEffect::blendOnLower, but it's
// been so heavily fixed and rearranged it's hard to recognise that now.
static void blendOnLower( const QImage &upper_, QImage &lower, const QPoint &offset )
{
	if ( upper_.width() <= 0 || upper_.height() <= 0 )
		return;
	if ( lower.width() <= 0 || lower.height() <= 0 )
		return;
	if ( offset.x() < 0 || offset.x() >= lower.width() )
		return;
	if ( offset.y() < 0 || offset.y() >= lower.height() )
		return;

	QImage upper = upper_;
	if ( upper.depth() != 32 )
		upper = upper.convertToFormat( QImage::Format_RGB32 );
	if ( lower.depth() != 32 )
		lower = lower.convertToFormat( QImage::Format_RGB32 );

	const int cx = offset.x();
	const int cy = offset.y();
	const int cw = std::min( upper.width() + cx, lower.width() );
	const int ch = std::min( upper.height() + cy, lower.height() );
	const int m = 255;

	for ( int j = cy; j < ch; ++j )
	{
		QRgb *u = (QRgb*)upper.scanLine(j - cy);
		QRgb *l = (QRgb*)lower.scanLine(j) + cx;

		for( int k = cx; k < cw; ++u, ++l, ++k )
		{
			int ua = qAlpha(*u);
			if ( !ua )
				continue;

			int la = qAlpha(*l);

			int   d =                       ua * m +              la * (m - ua);
			uchar r = uchar( (   qRed(*u) * ua * m +   qRed(*l) * la * (m - ua) ) / d );
			uchar g = uchar( ( qGreen(*u) * ua * m + qGreen(*l) * la * (m - ua) ) / d );
			uchar b = uchar( (  qBlue(*u) * ua * m +  qBlue(*l) * la * (m - ua) ) / d );
			uchar a = uchar( (         ua * ua * m +         la * la * (m - ua) ) / d );
			*l = qRgba( r, g, b, a );
		}
	}
}

// Get bounding box of image via alpha channel
static QRect getBoundingBox( const QImage& image )
{
	const int width = image.width();
	const int height = image.height();
	if ( width <= 0 || height <= 0 )
		return QRect();

	// scan image from left to right and top to bottom
	// to get upper left corner of bounding box
	int x1 = width - 1;
	int y1 = height - 1;
	for ( int j = 0; j < height; ++j )
	{
		QRgb *i = (QRgb*)image.scanLine(j);

		for( int k = 0; k < width; ++i, ++k )
		{
			if ( qAlpha(*i) )
			{
				x1 = std::min( x1, k );
				y1 = std::min( y1, j );
				break;
			}
		}
	}

	// scan image from right to left and bottom to top
	// to get lower right corner of bounding box
	int x2 = 0;
	int y2 = 0;
	for ( int j = height-1; j >= 0; --j )
	{
		QRgb *i = (QRgb*)image.scanLine(j) + width-1;

		int k;
		for( k = width-1; k >= 0; --i, --k )
		{
			if ( qAlpha(*i) )
			{
				x2 = std::max( x2, k );
				y2 = std::max( y2, j );
				break;
			}
		}
			if ( qAlpha(*i) )
			{
				x2 = std::max( x2, k );
				y2 = std::max( y2, j );
				break;
			}
	}
	return QRect( x1, y1, std::max( 0, x2-x1+1 ), std::max( 0, y2-y1+1 ) );
}

// Get offset for upperImage to blend it in the i%4-th corner of lowerImage:
// bottom right, bottom left, top left, top right
static QPoint getOffsetForCorner( const QImage& upperImage, const QImage& lowerImage, const int i )
{
	const int dX = lowerImage.width() - upperImage.width();
	const int dY = lowerImage.height() - upperImage.height();
	const int corner = i % 4;
	QPoint offset;
	switch( corner ) {
		case 0:
			// bottom right
			offset = QPoint( dX, dY );
			break;
		case 1:
			// bottom left
			offset = QPoint( 0, dY );
			break;
		case 2:
			// top left
			offset = QPoint( 0, 0 );
			break;
		case 3:
			// top right
			offset = QPoint( dX, 0 );
			break;
	}
	return offset;
}

QPixmap* OnlineStatusManager::renderIcon( const OnlineStatus &statusFor, const QString& baseIcon, int size, QColor color, bool idle) const
{
	// create an icon suiting the status from the base icon
	// use reasonable defaults if not provided or protocol not set

	//kDebug( 14010) << "overlayIcons size: " << statusFor.overlayIcons().count();

	// NOTE: overlayIcons car be empty
	if ( !statusFor.overlayIcons().empty() && baseIcon == statusFor.overlayIcons().first() )
	{
		kWarning( 14010 ) << "Base and overlay icons are the same - icon effects will not be visible.";
	}

	QPixmap* basis = new QPixmap( KIcon(baseIcon).pixmap(size) );

	// Colorize
	if ( color.isValid() )
		*basis = KIconEffect().apply( *basis, KIconEffect::Colorize, 1, color, 0);

	// Note that we do this before compositing the overlay, since we want
	// that to be colored in this case.
	if ( statusFor.internalStatus() == Kopete::OnlineStatus::AccountOffline || statusFor.status() == Kopete::OnlineStatus::Offline )
	{
		*basis = KIconEffect().apply( *basis, KIconEffect::ToGray , 0.85, QColor() , false  );
	}

	//composite the iconOverlay for this status and the supplied baseIcon
	QStringList overlays = statusFor.overlayIcons();
	if ( !( overlays.isEmpty() ) ) // otherwise leave the basis as-is
	{
		KIconLoader *loader = KIconLoader::global();

		int i = 0;
		for( QStringList::iterator it = overlays.begin(), end = overlays.end(); it != end; ++it )
		{
			QPixmap overlay = loader->loadIcon(*it, KIconLoader::NoGroup, size,
				KIconLoader::DefaultState, QStringList(), 0L, /*canReturnNull=*/ true );

			if ( !overlay.isNull() )
			{
				// we want to preserve the alpha channels of both basis and overlay.
				// there's no way to do this in Qt. In fact, there's no way to do this
				// in KDE since KImageEffect is so badly broken.
				QImage basisImage = basis->toImage();
				QImage overlayImage = overlay.toImage();
				QPoint offset;
				if ( (*it).endsWith( QString::fromLatin1( "_overlay" ) ) )
				{
					// it is possible to have more than one overlay icon
					// to avoid overlapping we place them in different corners
					overlayImage = overlayImage.copy( getBoundingBox( overlayImage ) );
					offset = getOffsetForCorner( overlayImage, basisImage, i );
					++i;
				}
				blendOnLower( overlayImage, basisImage, offset );
				*basis = QPixmap::fromImage( basisImage );
			}
		}
	}

	// no need to scale if the icon is already of the required size (assuming height == width!)
	if ( basis->width() != size )
	{
		QImage scaledImg = basis->toImage().scaled( size, size , Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
		*basis = QPixmap::fromImage( scaledImg );
	}

	// if idle, apply effects
	if ( idle )
		KIconEffect::semiTransparent( *basis );

	return basis;
}

QList<OnlineStatus> OnlineStatusManager::registeredStatusList( Protocol *protocol ) const
{
	return d->registeredStatus.value( protocol ).keys();
}

KIcon OnlineStatusManager::pixmapForCategory( Categories category )
{
	switch ( category )
	{
	case Kopete::OnlineStatusManager::Online:
		return KIcon("user-online");
	case Kopete::OnlineStatusManager::FreeForChat:
		return KIcon("user-online");
	case Kopete::OnlineStatusManager::Away:
		return KIcon("user-away");
	case Kopete::OnlineStatusManager::Idle:
		return KIcon("user-away");
	case Kopete::OnlineStatusManager::ExtendedAway:
		return KIcon("user-away-extended");
	case Kopete::OnlineStatusManager::Busy:
		return KIcon("user-busy");
	case Kopete::OnlineStatusManager::Invisible:
		return KIcon("user-invisible");
	case Kopete::OnlineStatusManager::Offline:
		return KIcon("user-offline");
	default:
		return KIcon("user-identity");
	}
}

} //END namespace Kopete

#include "kopeteonlinestatusmanager.moc"

// vim: set noet ts=4 sts=4 sw=4:

