#include "oyatzee.h"

/* OPIE */
#include <opie2/odebug.h>
using namespace Opie::Core;

/* QT */
#include <qmessagebox.h>
#include <qpushbutton.h>
#include <qpainter.h>
#include <qlayout.h>

/* STD */
#include <stdlib.h>

OYatzee::OYatzee( QWidget *parent , const char *name, WFlags fl ) : QMainWindow( parent , name , fl )
{
	QWidget *thing = new QWidget( this );
	setCentralWidget( thing );

	setCaption( tr( "OYatzee" ) );

	setPlayerNumber( 4 );
	setRoundsNumber( 1 );

	lastPlayerFinished = false;
	currentPlayer = 1;
	
	ps.append( new Player( "Carsten" ) );
	ps.append( new Player( "Julia" ) );
	ps.append( new Player( "Christine" ) );
	ps.append( new Player( "Stephan" ) );

	
	QVBoxLayout *vbox = new QVBoxLayout( thing );

	sb = new Scoreboard( ps, thing , "sb" );
	connect( sb->pb , SIGNAL( item(int) ), this , SLOT( slotEndRound(int) ) );
	
	dw = new DiceWidget( thing , "dw" );
	dw->setMaximumHeight( this->height()/4 );
	connect( dw->rollButton, SIGNAL( clicked() ), this , SLOT( slotRollDices() ) );
	
	vbox->addWidget( sb );
	vbox->addWidget( dw );
}

void OYatzee::slotEndRound( int item )
{
	odebug << "Der User hat Nummer " << item << " ausgewählt" << oendl; 

	/*
	 * if the user clicked on Total, Bonus or Score and thus not on a 
	 * selectable item return and do nothing
	 */
	if ( item == 7 || item == 8 || item == 16 ) return;

	/*
	 * check if the user can really click on that item
	 */
	if ( posibilities.find( item ) == posibilities.end() ) return;
	
	QValueListInt numbers;
	
	Dice *d = dw->diceList.first();
	for ( ; d != 0 ; d = dw->diceList.next() )
	{
		numbers.append( d->hasValue() );
	}

	int points = 0;

	switch ( item )
	{
		case Ones:
			points = getPoints( 1 , numbers );
			break;
		case Twos:
			points = getPoints( 2 , numbers );
			break;
		case Threes:
			points = getPoints( 3 , numbers );
			break;
		case Fours:
			points = getPoints( 4 , numbers );
			break;
		case Fives:
			points = getPoints( 5 , numbers );
			break;
		case Sixes:
			points = getPoints( 6 , numbers );
			break;
		case ThreeOfAKind:
			points = oakPoints;
			break;
		case FourOfAKind:
			points = oakPoints;
			break;
		case FullHouse:
			points = 25;
			break;
		case SStraight:
			points = 30;
			break;
		case LStraight:
			points = 40;
			break;
		case Yatzee:
			points = 50;
			break;
		case Chance:
			points = getPoints ( Chance , numbers );
	}

	sb->nextRB(currentPlayer-1)->updateMap( item , points );
	nextPlayer();

	odebug << "Punkte: " << points << "" << oendl; 
}

void OYatzee::nextPlayer()
{
	currentPlayer++;

	if ( currentPlayer > numOfPlayers )
	{
		currentPlayer = 1;
	}
	
	ps.at(currentPlayer-1)->turn = 0;
}

int OYatzee::getPoints( const int num , QValueListInt l)
{
	QValueListInt::Iterator it = l.begin();
	int c = 0;
	
	if ( num != Chance )
	{	
		for ( ; it != l.end() ; ++it )
		{
			if ( *it == num )
				c++;
		}

		return c * num;
	}
	else
	{
		for ( ; it != l.end() ; ++it )
		{
			c += *it;
		}
		return c;
	}
}	

OYatzee::~OYatzee()
{
}

void OYatzee::detectPosibilities()
{
	posibilities.clear();
	odebug << "running detectPosibilities()" << oendl; 
	
	Dice *d = dw->diceList.first();

	QValueListInt numbers;
	
	for ( ; d != 0 ; d = dw->diceList.next() )
	{
		numbers.append( d->hasValue() );
	}
	
	//the 6 numbers
	QValueListInt::Iterator it;

	for ( int i = 1 ; i < 7 ; ++i ) // check for 1-->6
	{
		bool cont = false;
		it = numbers.begin();
		for ( ; it != numbers.end() ; ++it )
		{
			if ( cont )
				continue;
		
			if ( numbers.find( i ) != numbers.end() )
			{
				posibilities.append( i );
				cont = true;
			}
		}
	}
		
	//3er, 4er, Yatzee
	it = numbers.begin();
	int count;
	int temp;
	int countFH = 0; //for the full-house-check

	for ( int i = 1 ; i < 7 ; ++i ) // check for 1-->6 at least 3 times
	{
		count = 0;
		temp = 0;
		it = numbers.begin();
		for ( ; it != numbers.end() ; ++it )
		{
			if ( *it == i )
			{
				count++;
				temp++;
			}
			if ( temp == 2 )
				countFH = temp;
		}
		
		if ( count >= 3 )
		{
			posibilities.append( 9 );

			//now we check if it is a full house
			if ( count == 3 && countFH == 2 ) //aka Full House
				posibilities.append( 11 );
			if ( count >= 4 )
				posibilities.append( 10 );
			if ( count == 5 )                     //Yatzee
				posibilities.append( 14 );
		
			oakPoints = count * i;
		}
	}
	
	//S-Straight
	if ( numbers.find( 3 ) != numbers.end() && numbers.find( 4 ) != numbers.end() )
	{
		bool isLong = false;
		bool isShort = true;
		//L-Straight
		if ( numbers.find( 2 ) != numbers.end() && numbers.find( 5 ) != numbers.end() )
		{
			isShort = true;
		
			//12345 or 23456
			if ( numbers.find( 1 ) != numbers.end() || numbers.find( 6) != numbers.end() )
				isLong = true;
		}
		//1234
		if ( numbers.find( 1 ) != numbers.end() && numbers.find( 2 ) != numbers.end() )
			isShort = true;
		//3456
		if ( numbers.find( 5 ) != numbers.end() && numbers.find( 6 ) != numbers.end() )
			isShort = true;
		
		if ( isShort )
			posibilities.append( 12 );
		if ( isLong )
			posibilities.append( 13 );
	}	
	
	posibilities.append( 13 );        //Chance, well, this is allways possible

	displayPossibilites();
}

void OYatzee::displayPossibilites()
{
//X 	for ( QValueListInt::Iterator it = posibilities.begin() ; it != posibilities.end(); ++it )
//X 	{
//X 		odebug << QString::number( *it ) << oendl; 
//X 		switch ( *it )
//X 		{
//X 			case Ones:
//X 				odebug << "1er" << oendl; 
//X 				break;
//X 			case Twos:
//X 				odebug << "2er" << oendl; 
//X 				break;
//X 			case Threes:
//X 				odebug << "3er" << oendl; 
//X 				break;
//X 			case Fours:
//X 				odebug << "4er" << oendl; 
//X 				break;
//X 			case Fives:
//X 				odebug << "5er" << oendl; 
//X 				break;
//X 			case Sixes:
//X 				odebug << "6er" << oendl; 
//X 				break;
//X 			case ThreeOfAKind:
//X 				odebug << "3oaK" << oendl; 
//X 				break;
//X 			case FourOfAKind:
//X 				odebug << "4oaK" << oendl; 
//X 				break;
//X 			case FullHouse:
//X 				odebug << "Full House" << oendl; 
//X 				break;
//X 			case SStraight:
//X 				odebug << "Short S" << oendl; 
//X 				break;
//X 			case LStraight:
//X 				odebug << "Long S" << oendl; 
//X 				break;
//X 			case Yatzee:
//X 				odebug << "Yatzee!" << oendl; 
//X 				break;
//X 			case Chance:
//X 				odebug << "Chance" << oendl; 
//X 				break;
//X 		}
//X 	}

	sb->pb->setIntlist(  posibilities );
	sb->pb->update();
}

void OYatzee::startGame()
{
	/*
	 * TODO
	 */
}

void OYatzee::stopGame(){}

void OYatzee::setPlayerNumber( const int num )
{
	numOfPlayers = num;
}

void OYatzee::setRoundsNumber( const int num )
{
	numOfRounds = num;
}

void OYatzee::slotStartGame()
{
}

void OYatzee::slotRollDices()
{
	odebug << "Roll nummer: " << ps.at( currentPlayer-1 )->turn << "" << oendl; 

	if ( ps.at( currentPlayer-1 )->turn == 3 )
	{
		QMessageBox::information(   this, 
									"OYatzee",
									tr( "Only three rolls per turn allowed." ) );
		return;
	}
		
	Dice *d = dw->diceList.first();
	
	for ( ; d != 0 ; d = dw->diceList.next() )
	{
		if ( !d->isSelected )
			d->roll();
	}
	
//	odebug << "Roll nummer (vorher): " << ps.at( currentPlayer-1 )->turn << "" << oendl; 
	ps.at(currentPlayer-1)->turn++;
//	odebug << "Roll nummer (nachher): " << ps.at( currentPlayer-1 )->turn << "" << oendl; 

	detectPosibilities();
}

/*
 * Scoreboard
 */
Scoreboard::Scoreboard( playerList ps, QWidget *parent, const char *name ) : QWidget( parent , name )
{ 
	ps_ = ps;

	pb = new Possibilityboard( this , "pb" );

	createResultboards( 4 );

	QHBoxLayout *hbox = new QHBoxLayout( this );

	hbox->addWidget( pb );

	hbox->addSpacing( 25 );

	Resultboard *r = rbList.first();
	
	for ( ; r != 0 ; r = rbList.next() )
	{
		hbox->addWidget( r );
	}
}

Resultboard* Scoreboard::nextRB( int currentPlayer )
{
	Resultboard *b;

	b = rbList.at( currentPlayer );
	
	odebug << "Anzahl: " << rbList.count() << "" << oendl; 

	return b;
}		

void Scoreboard::createResultboards(const int num)
{
	Player *p = ps_.first();
	for ( int i = 0 ; i < num ; ++i , p = ps_.next() )
	{
		QString n = p->playerName;
		rbList.append( new Resultboard( n , this ) );
	}
}

void Scoreboard::paintEvent( QPaintEvent * )
{
//X 	QPainter p;
//X 	p.begin( this );
//X 
//X 	p.drawRect( 0,0, this->width() , this->height() );
}

/*
 * Dice
 */
Dice::Dice( QWidget *parent , const char *name ) : QFrame( parent , name )
{
	QTime t = QTime::currentTime();   // set random seed
	srand(t.hour()*12+t.minute()*60+t.second()*60);

	connect( this , SIGNAL( selected() ), this , SLOT( slotSelected() ) );
}

void Dice::slotSelected()
{
	if ( isSelected )
		isSelected = false;
	else isSelected = true;

	update();
}

const int Dice::hasValue() const
{
	return Value;
}

void Dice::roll()
{
	Value = rand()%6;
	Value += 1;

	update();
}

void Dice::mousePressEvent( QMouseEvent* /*e*/ )
{
	    emit selected();
}

void Dice::paintEvent( QPaintEvent * )
{
	QPainter p;
	p.begin( this );

	p.drawRect( 0,0, this->width() , this->height() );

	if ( isSelected )
		p.drawRect( 20,20, 10,10 );

	paintNumber( &p );
}

void Dice::paintNumber( QPainter *p )
{
	p->setBrush( Qt::black );
	
	int w = this->width();
	int h = this->height();
	int r = this->width();
	r /= 10;
	
	switch ( Value )
	{
		case 1:
			p->drawEllipse( (int)( 0.5*w - r ) , (int)( 0.5*h - r ) , r , r ) ;
			break;
		case 2:
			p->drawEllipse( (int)( 0.3*w - r ) , (int)( 0.3*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.7*w - r ) , (int)( 0.7*h - r ) , r , r ) ;
			break;
		case 3:
			p->drawEllipse( (int)( 0.5*w - r ) , (int)( 0.5*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			break;
		case 4:
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			break;
		case 5:
			p->drawEllipse( (int)( 0.5*w - r ) , (int)( 0.5*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			break;
		case 6:
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.2*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.8*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.2*w - r ) , (int)( 0.5*h - r ) , r , r ) ;
			p->drawEllipse( (int)( 0.8*w - r ) , (int)( 0.5*h - r ) , r , r ) ;
			break;
	}
}

/*
 * DiceWidget
 */
DiceWidget::DiceWidget( QWidget *parent , const char *name ) : QWidget(  parent , name )
{
	rollButton = new QPushButton( tr( "Roll" ) , this ) ;
	
	for ( int i = 0 ; i < 5 ; i++ )
	{
		//appending the 5 dices of the game
		diceList.append( new Dice( this, "wuerfel" ) );
	}
	
	QHBoxLayout *hbox = new QHBoxLayout( this );

	Dice *d = diceList.first();
	
	for ( ; d != 0 ; d = diceList.next() )
	{
		hbox->addWidget( d );
	}

	hbox->addWidget( rollButton );
}

/*
 * Player
 */
Player::Player( QString name )
{
	playerName = name;
	setupResultList();
	turn = 0;
}

void Player::setupResultList()
{
	for ( int i = 1 ; i < 14 ; ++i )
	{
		pResults.append( 0 );
	}
}

/*
 * TODO: muss noch genutzt werden
 */
void Player::updateTotalPoints( pointMap m )
{
	pointMap::Iterator it = m.begin();
	for ( ; it != m.end() ; ++it )
	{
		totalPoints += it.data();
	}
	
}


void Player::setResults( const int cat , const int points )
{
	QValueListInt::Iterator it = pResults.at( cat );
	*it = points;
}

/*
 * Board
 */
Board::Board( QWidget *parent , const char* name ) : QWidget ( parent , name )
{
}

void Board::mousePressEvent( QMouseEvent *e )
{
	emit clicked( e->pos() );
}

/*
 * Resultboard
 */

Resultboard::Resultboard( QString playerName , QWidget *parent , const char* name ) : Board ( parent , name )
{
	pName = playerName;
}

void Resultboard::paintEvent( QPaintEvent* )
{
	QPainter p;
	p.begin( this );
	
	const int cell_width = this->width();
	const int cell_height = this->height()/17;
	
	pointMap::Iterator it = pMap.begin();
	for ( ; it != pMap.end() ; ++it )
	{
		int i = it.key();
		odebug << "ok: " << i << " , " << it.data() << "" << oendl; 
		p.drawText( 0, i*cell_height , cell_width , cell_height , Qt::AlignCenter , QString::number( it.data() ) );
	}

	p.drawText( 0,0,cell_width,cell_height, Qt::AlignCenter , pName ); //Playername
}


void Resultboard::updateMap( int item , int points )
{
	pMap.insert( item , points );

	update();
}

/*
 * Possibilityboard
 */

Possibilityboard::Possibilityboard( QWidget *parent , const char* name ) : Board ( parent , name )
{
	begriffe.append( "1er" );
	begriffe.append( "2er" );
	begriffe.append( "3er" );
	begriffe.append( "4er" );
	begriffe.append( "5er" );
	begriffe.append( "6er" );
	begriffe.append( "Total" );
	begriffe.append( "Bonus" );
	begriffe.append( "3oaK" );
	begriffe.append( "4oaK" );
	begriffe.append( "Full House" );
	begriffe.append( "Short S" );
	begriffe.append( "Long S" );
	begriffe.append( "Yatzee!" );
	begriffe.append( "Chance" );
	begriffe.append( "Score" );
	
	connect( this , SIGNAL( clicked(QPoint) ), this , SLOT( slotClicked(QPoint) ) );
}

void Possibilityboard::slotClicked( QPoint p)
{
	emit item( p.y()/(this->height()/17) );
}

void Possibilityboard::paintEvent( QPaintEvent* )
{
	QPainter p;
	p.begin( this );

	const int cell_width = this->width();
	const int cell_height = this->height()/17;

	p.setBrush( Qt::blue );

	QValueListInt::Iterator listIt = list.begin();
	for ( ; listIt != list.end() ; ++listIt )
	{
		p.drawRect( 0 , (*listIt) * cell_height , cell_width , cell_height );
	}

	p.setBrush( Qt::black );
	p.setBrush( Qt::NoBrush );
	QStringList::Iterator begriffeIt = begriffe.begin();
	for ( int i = 1 ; i < 18 ; ++i )
	{
		p.drawText( 0 , i*cell_height , cell_width , cell_height , Qt::AlignCenter , *begriffeIt );
		++begriffeIt;
	}
}

void Possibilityboard::setIntlist( QValueListInt &l )
{
	list = l;
}