/**********************************************************************
** Copyright (C) 2000 Trolltech AS.  All rights reserved.
**
** This file is part of Qtopia Environment.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.trolltech.com/gpl/ for GPL licensing information.
**
** Contact info@trolltech.com if any conditions of this licensing are
** not clear to you.
**
**********************************************************************/

#include "canvascardgame.h"


#include <qgfx_qws.h>

#include <stdlib.h>
#include <limits.h>
#include <time.h>
#include <math.h>


extern int highestZ;


class CanvasCardPile : public QCanvasRectangle
{
public:
    CanvasCardPile( CanvasCardGame *ccg, QCanvas *canvas ) : QCanvasRectangle( canvas ), parent( ccg ) { 
	pile = new QPixmap( 0, 0 );
	pileHeight = 0;
	firstCard = NULL;
    }

    void addCard( CanvasCard *card );
    void advance(int stage);
    void animatedMove() { animatedMove(savedX, savedY); }
    void savePos(void) { savedX = (int)x(); savedY = (int)y(); }
    void animatedMove(int x2, int y2, int steps = 7 );

protected:
    virtual void draw( QPainter& p );

private:
    CanvasCardGame *parent;
    QPixmap *pile;
    QImage tempImage32;
    CanvasCard *firstCard;
    int pileHeight;
    int destX, destY;
    int savedX, savedY;
    int animSteps;
};


void CanvasCardPile::addCard( CanvasCard *card )
{
    int offsetDown = ( qt_screen->deviceWidth() < 200 ) ? 9 : 13;
    int cardHeight = ( qt_screen->deviceWidth() < 200 ) ? 27 : 36;
    int cardWidth  = ( qt_screen->deviceWidth() < 200 ) ? 20 : 23;

    if ( !firstCard )
	firstCard = card;

    int height = cardHeight + pileHeight * offsetDown;
    setSize( cardWidth, height );
    pile->resize( cardWidth, height );
    QPainter p( pile );
    p.translate( -card->x(), -card->y() + pileHeight * offsetDown );
    card->draw( p );
    pileHeight++;

    QImage tempImage;
    tempImage = *pile;
    tempImage32 = tempImage.convertDepth( 32 );
    tempImage32.setAlphaBuffer( TRUE );
    for ( int i = 0; i < tempImage32.width(); i++ )
	for ( int j = 0; j < tempImage32.height(); j++ ) {
	    QRgb col = tempImage32.pixel( i, j );
	    int a = 255-j*220/tempImage32.height();
	    QRgb alpha = qRgba( qRed( col ), qGreen( col ), qBlue( col ), a );
	    tempImage32.setPixel( i, j, alpha );
	}

    QRgb alpha = qRgba( 0, 0, 0, 0 );
    tempImage32.setPixel( 1, 0, alpha );
    tempImage32.setPixel( 0, 0, alpha );
    tempImage32.setPixel( 0, 1, alpha );

    tempImage32.setPixel( cardWidth - 2, 0, alpha );
    tempImage32.setPixel( cardWidth - 1, 0, alpha );
    tempImage32.setPixel( cardWidth - 1, 1, alpha );
    height--;
    tempImage32.setPixel( 1, height, alpha );
    tempImage32.setPixel( 0, height - 1, alpha );
    tempImage32.setPixel( 0, height, alpha );

    tempImage32.setPixel( cardWidth - 2, height, alpha );
    tempImage32.setPixel( cardWidth - 1, height, alpha );
    tempImage32.setPixel( cardWidth - 1, height - 1, alpha );
}


void CanvasCardPile::advance(int stage)
{
    if ( stage==1 ) {
	if ( animSteps-- <= 0 ) {
	    CanvasCard *item = firstCard;
	    while (item) {
		item->show();
		item = (CanvasCard *)item->getCardPile()->cardInfront(item);
	    }
	    setVelocity(0,0);
	    setAnimated(FALSE);
	    parent->cancelMoving();
	    hide();
	    move(destX,destY); // exact
	}
    }
    QCanvasRectangle::advance(stage);
}


void CanvasCardPile::animatedMove(int x2, int y2, int steps )
{
    destX = x2;
    destY = y2;

    double x1 = x(), y1 = y(), dx = x2 - x1, dy = y2 - y1;

    // Ensure a good speed
    while ( fabs(dx/steps)+fabs(dy/steps) < 5.0 && steps > 4 )
	steps--;

    setAnimated(TRUE);
    setVelocity(dx/steps, dy/steps);

    animSteps = steps;
}


void CanvasCardPile::draw( QPainter& p )
{
    int ix = (int)x(), iy = (int)y();
    p.drawImage( ix, iy, tempImage32 );
}


CanvasCardGame::~CanvasCardGame() {
    // the deletion stuff should be fixed now and only deletes
    // items created by this CardGame. I haven't verified there are zero
    // memory leaks yet
    if ( alphaCardPile )
	delete alphaCardPile;
}


void CanvasCardGame::gameWon() {
	
    srand(time(NULL));
    
    QCanvasItemList list = canvas()->allItems();
    QCanvasItemList::Iterator it = list.begin();
 
    for (; it != list.end(); ++it) {
	if ( (*it)->rtti() == canvasCardId ) {
	    // disperse the cards everywhere
	    int x = 300 - rand() % 1000;
	    int y = 300 + rand() % 200;
	    ((CanvasCard *)*it)->animatedMove( x, y, 50 );
	}
    }
}


void CanvasCardGame::contentsMousePressEvent(QMouseEvent *e) {

    if ( moving )
	return;

    QCanvasItemList l = canvas()->collisions( e->pos() );
    
    for (QCanvasItemList::Iterator it = l.begin(); it != l.end(); ++it) {
	
	if ( (*it)->rtti() == canvasCardId ) {
	
	    moving = (CanvasCard *)*it;

	    if ( moving->animated() )
		return;
		
	    cardXOff = (int)(e->pos().x() - moving->x());
	    cardYOff = (int)(e->pos().y() - moving->y());
	    
	    if ( !mousePressCard( moving, e->pos() ) ) {
		CanvasCard *card = moving;

		if ( alphaCardPile )
		    delete alphaCardPile;

		alphaCardPile = new CanvasCardPile( this, canvas() );
		alphaCardPile->move( card->x(), card->y() );
		alphaCardPile->savePos();
		alphaCardPile->show();

		while (card) {
		    alphaCardPile->addCard( card );
		    card->hide();
		    card = (CanvasCard *)card->getCardPile()->cardInfront(card);
		}

		alphaCardPile->setZ( INT_MAX );

		moved = TRUE;		
	    } else {
		if ( alphaCardPile )
		    alphaCardPile->hide();
	    }
	    return;	
	}
    }
    
    mousePress( e->pos() );
}

/*
//
// Should have some intelligent way to make double clicking on a
// card send it to the most appropriate pile
//
void CanvasCardGame::contentsMouseDoubleClickEvent(QMouseEvent *e) {
    QCanvasItemList l = canvas()->collisions( e->pos() );
    for (QCanvasItemList::Iterator it = l.begin(); it != l.end(); ++it) {
	if ( (*it)->rtti() == canvasCardId ) {
	    CanvasCard *card = (CanvasCard *)*it;

	    if ( card->animated() )
		return;
	    
	    if ( card->getCardPile()->isAllowedToBeMoved(card) ) {
		if (card->getCardPile()->cardInfront(card) == NULL) {
		    CardPile *pile = first();
		    if (pile && pile->isAllowedOnTop(card)) {
		       // move card to this pile
		       return;
		    }
		}
	    }
	}
    }
}
*/

void CanvasCardGame::contentsMouseMoveEvent(QMouseEvent *e) {
    
    QPoint p = e->pos();
    
    if ( moving ) {

	moved = TRUE;

	if (moving->isFacing() != TRUE)
	    return;

	int tx = (int)p.x() - cardXOff; 
	int ty = (int)p.y() - cardYOff;

	if (snapOn == TRUE) {
	    CardPile *pile = closestPile( tx, ty, 50 );
	    if ( pile && pile->isAllowedOnTop( moving ) ) {
		    QPoint p = pile->getHypertheticalNextCardPos();
		    if ( alphaCardPile )
			alphaCardPile->move( p.x(), p.y() );
		    return;
	    }
	}

	if ( alphaCardPile )
	    alphaCardPile->move( tx, ty );
    }
    
}


void CanvasCardGame::contentsMouseReleaseEvent(QMouseEvent *e)
{ 
    QPoint p = e->pos();

    Q_UNUSED(p);

    if ( moving ) {
	
	CanvasCard *item = moving;

	if ( item->animated() )
	    return;
	
	if ( alphaCardPile )
	if ( moved ) {
	    
	    CardPile *pile = closestPile((int)alphaCardPile->x(), (int)alphaCardPile->y(), 30);

	    if (pile && pile->isAllowedOnTop(item)) {
		    CardPile *oldPile = item->getCardPile();
		    Card *c = NULL;
		    if ( oldPile != pile) {
			while ( item ) {
			    item->show();
			    if ( oldPile ) {
				c = oldPile->cardInfront(item);
				oldPile->removeCard(item);
			    }    
			    item->setCardPile(pile);
			    //item->move( pile->getCardPos(item) );
			    pile->addCardToTop(item);
			    QPoint p = pile->getCardPos(item);
			    item->setPos( p.x(), p.y(), highestZ );
			    highestZ++;
				checkUnusable();   // added for freecell to move card to discard pile

			    if (item->getValue() == king && haveWeWon()) {
				alphaCardPile->hide();
				gameWon();
				moving = NULL;
				return;
			    }
			    
			    if (oldPile) {
				item = (CanvasCard *)c;
			    } else {
				item = NULL;
			    }
			}	
			alphaCardPile->hide();
			moving = NULL;
			return;
		    }
	    }

	    alphaCardPile->animatedMove();
	}
    }

    moved = FALSE;
}


void CanvasCardGame::readPile( Config& cfg, CardPile *pile, QString name, int& highestZ )
{
    cfg.setGroup( name );
    int numberOfCards = cfg.readNumEntry("NumberOfCards", 0);
    Card *card = NULL;

    for ( int i = 0; i < numberOfCards; i++ ) {
	QString cardStr;
	cardStr.sprintf( "%i", i );
	int val = cfg.readNumEntry( "Card" + cardStr );
	bool facing = cfg.readBoolEntry( "CardFacing" + cardStr );

        card = cards[ val ];
	card->setFace(facing);
	card->setCardPile(pile);		// cam: setCardPile has to happen bevor addCardToTop
	pile->addCardToTop(card);		//      due to a empty pointer if you use cardAddedToTop
	QPoint p = pile->getCardPos( card );
	card->setPos( p.x(), p.y(), highestZ );
	card->showCard();
	highestZ++;
    }
}