// Developer	: Bruce Hunter
// File			: Card.h
// Purpose		: 

#ifndef CARD_H_
#define CARD_H_

class Card {

public:
	
	Card();									// constructor
	~Card();								// deconstructor
	
	int remaining;							// number of cards remaining/available
	
	// set functions
	int setRemaining( int );				// calculate and set remaing cards

	// get functions
	int getCardNum( int );					// get card number
	int getSuitNum( int );					// get suit number

	int getTotalCards( void ) const;		// get the number of cards in a deck
	int getTotalSuits( void ) const;		// get the number of suits in a deck

	const char *getFaceName( int ) const;	// get card face name
	const char *getSuitName( int ) const;	// get card suit name
	
	int getRemaining( void );				// get the number of remaining cards available
	
private:
	
	const int TOTAL_CARDS;					// constant total number of cards
	const int TOTAL_SUITS;					// constant total number of suits

	const static char *FACE[ 13 ];			// constant array of each different card face name
	const static char *SUIT[ 4 ];			// constant array of each different card suit name

}; // end Card class

#endif

// Developer	: Bruce Hunter
// File			: Card.cpp
// Purpose		: 

#include "Card.h"

using namespace std;

//const int Card::TOTAL_CARDS = 52;	// total number of cards
//const int Card::TOTAL_SUITS = 4;	// total number of different suits

// constant card names
const char * Card::FACE[ 13 ] = 
				{ 
					"Ace", "King", "Queen", "Jack", "Ten", "Nine", "Eight",
					"Seven", "Six", "Five", "Four", "Three", "Deuce"
				};

// constant suit names
const char * Card::SUIT[ 4 ] = 
				{ 	
					"Spades", "Hearts" , "Diamonds", "Clubs"
				};

// Constructor
Card::Card(): TOTAL_CARDS(52),TOTAL_SUITS(4),remaining(52){}

// Deconstructor
Card::~Card()
{
	// TODO: de-initialize objects here
}

int Card::setRemaining( int value )
{
	// TODO: exception handling needed
	this->remaining = value;
}

int Card::getCardNum( int value )
{
	//TODO: exception handling needed
	return( value % 13 );
}

int Card::getSuitNum( int value )
{
	// TODO: exception handling needed
	return( value / 13 );
}

const char * Card::getFaceName( int value ) const
{
	//TODO: exception handling needed
	return( this->FACE[ value ] );
}

const char * Card::getSuitName( int value ) const
{
	//TODO: exception handling needed
	return( this->SUIT[ value ] );
}

int Card::getTotalCards( void ) const
{
	//TODO: exception handling needed
	return( this->TOTAL_CARDS );
}

int Card::getTotalSuits( void ) const
{
	//TODO: exception handling needed
	return( this->TOTAL_SUITS );
}

int Card::getRemaining( void )
{
	return( this->remaining );
}

// Developer	: Bruce Hunter
// File			: Deck.h
// Purpose		: 

#ifndef DECK_H_
#define DECK_H_

#include "Card.h"

class Deck {

public:

	Deck();											// constructor
	~Deck();										// deconstructor
	
	void shuffle( void );							// shuffle deck
	void deal( int );								// deal a specific number of cards

	bool hasNext( void );							// check for another card to deal
	void dealNext( void );							// deal the next card in the deck

	void printConsole( int );						// print to console

private:
	
	int deck[ 52 ];									// deck of cards
		
	Card * card;									// create a pointer to our cards

	void initialize( void );						// initialize deck

	// utility set functions
	void setDeckValue( int );						// set a deck value of 0 -> 51, position and value are the same
	void setDeckValue( int, int );					// set a deck value of 0 -> 51, position and value are different

	// utility get functions
	int getDeckValue( int ) const;					// get a deck value

}; // end Deck class

#endif

// Developer	: Bruce Hunter
// File			: Deck.cpp
// Purpose		: 

#include <iostream>		// basic input output stream
#include <iomanip>		// input output manipulation
#include <algorithm>	// random_shuffle()

#include "Deck.h"

using namespace std;

// Constructor
Deck::Deck()
{
	card = new Card();

	this->initialize();
}

// Deconstructor
Deck::~Deck()
{
	delete card;
}

// Function: initialize
// Purpose: 
void Deck::initialize( void )
{
	for( int position = 0; position < card->getTotalCards(); position++ )
		this->setDeckValue( position );
}

// Function: shuffle
// Purpose: shuffle the deck in a randomly
void Deck::shuffle( void )
{
	// TODO: this way of shuffling is not random enough
	random_shuffle( this->deck, this->deck+52 );
	card->setRemaining( card->getTotalCards() ); 	// reset the remaining cards on each shuffle
}

void Deck::deal( int dealNum )
{
	// TODO: exception handling needed
	
	if( this->hasNext() )
	{
		for( int position = 0; position < dealNum; position++ )
			this->dealNext();
	}
	else
	{
		// TODO: exception handling here
		// for now i will just do cout some shit
		cout << "Error: no more cards to deal" << endl;
	}
}

void Deck::dealNext( void )
{
	if( this->hasNext() )
	{
		int position = ( card->getTotalCards() - card->getRemaining() );
		this->printConsole( position );
		card->setRemaining( card->getRemaining() - 1 );
	}
	else
	{
		// TODO: exception handling here
		// for now i will just do cout some shit
		cout << "Error: no more cards to deal" << endl;
	}
}

bool Deck::hasNext( void )
{
	bool available = false;
	
	if( card->getRemaining() != 0 )
		available = true;
	
	return( available );
}

void Deck::printConsole( int deckPosition )
{
	cout << setw( 5 ) << setiosflags( ios::right )
		 << card->getFaceName( card->getCardNum( this->getDeckValue( deckPosition ) ) ) << " of "

		 << setw( 8 ) << setiosflags( ios::left )
		 << card->getSuitName( card->getSuitNum( this->getDeckValue( deckPosition ) ) )

		 << ( (deckPosition + 1) % 4 == 0 ? '\n' : '\t' );
}

void Deck::setDeckValue( int value )
{
	// TODO: exception handling needed
	this->deck[ value ] = value;
}

void Deck::setDeckValue( int position, int value )
{
	// TODO: exception handling needed
	this->deck[ position ] = value;
}

int Deck::getDeckValue( int position ) const
{
	// TODO: exception handling needed
	return( this->deck[ position ] );
}

// Developer: Bruce Hunter
// File		: main.cpp
// Purpose	: test the Deck class

#include <iostream>
#include "Deck.h"

/*
	TO COMPILE: # g++ -o main main.cpp Deck.cpp Card.cpp
*/

using namespace std;

int main( int argc, char *argv[] ) 
{
	Deck * deck = new Deck();
	
	deck->shuffle();	// shuffle the deck

	deck->deal(3);		// deal 3 cards from the deck
	deck->deal(2);		// deal 2 more cards from the deck
	
	deck->dealNext();	// should be the 6 card down in the deck

	// 3 + 2 + 1 + 47 = 53 , which is more then we have to deal
	deck->deal(47);		// this should cause an error to be printed
	
	deck->dealNext();	// lets try to deal one more card just to see, it should give an error

	cout << endl;

	// if we shuffle again then we should be able to deal again without an error
	deck->shuffle();
	deck->deal(52);		// deal all cards in deck that we just shuffled
	
	return(0);
}

// Function: shuffle
// Purpose: shuffle the deck in a randomly
void Deck::shuffle( void )
{
	// TODO: this way of shuffling is not random enough
	
	srand(time(0));	// seed the random number generator
	
	// shuffle the deck random times
	for( int process = 0; process <= rand()%17; process++ )
		random_shuffle( this->deck, this->deck+52 );

	card->setRemaining( card->getTotalCards() ); 	// reset the remaining cards on each shuffle
}

int Card::setRemaining( int value )
{
  // TODO: exception handling needed
  this->remaining = value;
}

// Function: shuffle
// Purpose: a basic random shuffle
void Deck::shuffle( void )
{
	int currentValue;	// hold current deck value
	int r_Position;		// hold random position
	int r_Value;		// hold random position value

	for ( int position = 0; position < card->getTotalCards(); position++ )
	{
		// save the current deck positions value
		currentValue = this->getDeckValue( position );
		// generate a random position in the deck
		r_Position = ( rand() % card->getTotalCards() );
		// save the random positions value
		r_Value = this->getDeckValue( r_Position );

		// do the deck value swap
		this->setDeckValue( position, r_Value );		
		this->setDeckValue( r_Position, currentValue ); 
	}
	// reset the remaining cards on each shuffle
	card->setRemaining( card->getTotalCards() );
}

#include <iostream>
#include <string>
#include <stdexcept>
#include <exception>
#include <vector>
#include <algorithm>
#include <ctime>
#include <cstdlib>
using namespace std;

typedef std::vector<int> deck;

//class PlayingCardDeck; // forward reference

class Card
{
public:
	Card() : m_type(0) {}
	
	Card( const int type )
	{
		m_type = type;
	}
	const int getType() const { return m_type; }
protected:
	int m_type;
};

class PlayingCard : public Card
{
public:
	const static char SPADES 	= 0x10;
	const static char HEARTS 	= 0x20;
	const static char CLUBS 	= 0x30;
	const static char DIAMONDS 	= 0x40;

//friend PlayingCardDeck;
	PlayingCard() :
	Card( 0 /* enum type { GAME=0, GREETING=1, ... } */ )
	{
		m_value = 0x00; // zero "initialized" PCard
	}
	PlayingCard( char value, char suit ) :
	Card( 0 /* enum type { GAME=0, GREETING=1, ... } */ ),
	m_value( 0 )
	{
		if( value < 1 || value > 13 )
		{
			throw new out_of_range( "value must be between 1 and 13" );
		}
		switch( suit )
		{
			case SPADES:
			case HEARTS:
			case CLUBS:
			case DIAMONDS:
				break;
			default:
				throw new out_of_range( "suit must be one of Spades, Hearts, Diamonds or Clubs" );
		}
		m_value = value | suit;
	}
	const char getValue() const
	{
		return m_value;
	}
	const char getFace() const
	{
		char face = m_value;
		return face &= ~( SPADES|HEARTS|CLUBS|DIAMONDS); // mask off the value from the suit
	}
	const char getSuit() const
	{
		return m_value - getFace();
	}
	const std::string getSuitName()
	{
		std::string suit;
		switch( getSuit() )
		{
			case SPADES:
				suit = "Spades";				
				break;
			case HEARTS:
				suit = "Hearts";
				break;
			case CLUBS:
				suit = "Clubs";
				break;
			case DIAMONDS:
				suit = "Diamonds";
				break;
			default:
				suit = "none";
		}
		return suit;
	}
	
protected:
	char m_value;
};

int main( int argc, char* argv[] )
{
	deck v;
	for( int i = 1; i <= 13; i++ )
	{
		for( int j = PlayingCard::SPADES; j <= PlayingCard::DIAMONDS; j+= 0x10 )
		{
			try
			{
				PlayingCard c( i, j );
			 	v.push_back( (int)c.getValue() ); // add card to vector here
				cout << (int)c.getFace() << " " << c.getSuitName() << " " << (int)c.getValue() << endl;
			}
			catch( exception ex )
			{
				cout << ex.what() << endl;
			}
		}
	}
	sort( v.begin(), v.end() );	
	deck::iterator it;
	for( it = v.begin(); it != v.end(); it++ )
	{
		cout << (int)(*it) << endl;
	}
	srand( time(0) );
	random_shuffle( v.begin(), v.end() );
	for( it = v.begin(); it != v.end(); it++ )
	{
		cout << (int)(*it) << endl;
	}
	
	return 0;
}