class Game implements BelotConstants

{
	Game ()
	{
		belotCards = new Cards();

		players = new Player[NUMBER_OF_PLAYERS];

		players[PLAYER_1] = new Player("You");
		players[PLAYER_2] = new Player("Computer");

		dealer = NO_ONE;
	}

	public void selectDealer ()          // interface
	{
		dealer = otherPlayer (dealer);
		trump = UNKNOWN;
	}

	public void dealFiveCards()
	{
		players[PLAYER_1].resetHand();   // interface
		players[PLAYER_2].resetHand();   // interface

		whoseTurn = otherPlayer(dealer);

		belotCards.assignValues(trump);

		belotCards.shuffle();

		for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
		{
			players[i].dealCards(belotCards, 5);
			players[i].sortCards(trump, USE_TRUMP);
		}

		flippedCard = belotCards.showNextCard();
	}

	public void callTrump(int what, int who)    // interface parameters
	{
		trump = what;
		caller = who;

		belotCards.assignValues(trump);
	}

	public void finishDealing()
	{
		players[caller].dealCards(belotCards, 3);
		players[otherPlayer(caller)].dealCards(belotCards, 3);

		for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
		{
			players[i].sortCards(trump, USE_TRUMP);
		}

		flippedCard = belotCards.showNextCard();
	}

	public void scoreBonuses()
	{
		boolean bonusesDone = false;
		int numberBelots;
		int card = 0;

		for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
		{
			numberBelots = players[i].findNumberBelots(trump);
			if (numberBelots > 0)
			{
				players[i].addToRawPoints(numberBelots * BELOT_BONUS);
			}
		}

		while ((!bonusesDone) && (card < ALL_FOUR.length))
		{
			for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
			{
				if ( players[i].hasALL_FOUR(ALL_FOUR[card]) )
				{
					players[i].addToRawPoints(ALL_FOUR_BONUSES[card]);
					bonusesDone = true;
				}
			}
			card++;
		}

		RunInfo bestRun = new RunInfo();
		RunInfo currentRunInfo;
		int winner = -1;

		if (!bonusesDone)
		{
			for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
			{
				currentRunInfo = players[i].findRunInfo(trump);
				if ( currentRunInfo.betterThan(bestRun, trump) )
				{
					winner = i;
					bestRun = currentRunInfo;
				}
			}
			if ( winner >= 0 )
			{
				players[winner].addToRawPoints(bestRun.calculateValue());
			}
		}
	}

	public void startPlay()  // interface
	{
		cards = new Card [NUMBER_OF_PLAYERS];
		wins = new int [NUMBER_OF_PLAYERS];

		for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
			wins[i] = 0;
	}

	public Card getComputerLead()               // interface
	{
		cards[PLAYER_2] = players[PLAYER_2].getCard(0);
		return cards[PLAYER_2];
	}

	public Card getComputerFollow()             // interface
	{
		cards[PLAYER_2] = players[PLAYER_2].findPlay(cards[PLAYER_1]);
		return cards[PLAYER_2];
	}

	public boolean checkLegalPlay(Card cardPlayed, Card cardLed, int player)  // interface
	{
		Card otherCard = players[player].findPlay(cardLed);
		if ((otherCard.getSuit() != cardPlayed.getSuit()) &&
			(otherCard.getSuit() == cardLed.getSuit()))
		{
			return false;
		}
		else
		{
			return true;
		}
	}

	public void assignPlayerCard(Card playedCard)  // interface
	{
		cards[PLAYER_1] = playedCard;
	}

	public void determineWinner()                  // interface
	{
		otherPlayer = otherPlayer(whoseTurn);

		if (!cards[whoseTurn].isHigher(cards[otherPlayer], trump))
			whoseTurn = otherPlayer;

		for (int j = 0; j < NUMBER_OF_PLAYERS; j++)
		{
			players[j].discard(cards[j]);
			players[whoseTurn].addToRawPoints(cards[j]);
		}

		wins[whoseTurn]++;
	}

	public void finishPlay()                      // interface
	{
		players[whoseTurn].addToRawPoints(LAST_TRICK_BONUS);
		if (wins[whoseTurn] == CARDS_IN_HAND)
		{
			otherPlayer = otherPlayer(whoseTurn);
			players[whoseTurn].addToRawPoints(ALL_TRICKS_BONUS);
			players[whoseTurn].addToRawPoints
				(players[otherPlayer].getRawPoints());
			players[otherPlayer].setRawPoints(0);
		}
	}

	public void calculateScores()
	{
		int defender = otherPlayer(caller);

		int pointsForCaller = players[caller].getRawPoints();
		int pointsForDefender = players[defender].getRawPoints();

		if (pointsForDefender >= pointsForCaller)
		{
			if (pointsForDefender > pointsForCaller)
			{
				players[defender].setRawPoints
				   (pointsForCaller + pointsForDefender);
			}
			players[caller].setRawPoints(0);
		}

		for (int i = 0; i < NUMBER_OF_PLAYERS; i++)
		{
			players[i].setGamePoints
				(((players[i].getRawPoints() + 5) / 10) * trump);
			players[i].addToTotalPoints(players[i].getGamePoints());  // interface
		}
	}

	private int otherPlayer (int player)
	{
		if ((player == NO_ONE) || (player == PLAYER_2))
			return PLAYER_1;
		else
			return PLAYER_2;
	}

	public Cards getBelotCards()            // interface
	{
		return belotCards;
	}

	public Player getPlayer (int whichOne)  // interface
	{  
		return players[whichOne];
	}

	public String getTrump()                // interface
	{
		return TRUMP_NAMES[trump];
	}

	public String getCaller()               // interface
	{
		if (trump == UNKNOWN)
			return "-----";
		else return players[caller].getName();
	}

	public String getDealer()               // interface
	{
		if (dealer == NO_ONE)
			return "-----";
		else return players[dealer].getName();
	}

	public int getDealerNumber()            // interface
	{
		return dealer;
	}

	public Card getFlippedCard()            // interface
	{
		return flippedCard;
	}

	public int getWhoseTurn()               // interface
	{
		return whoseTurn;
	}

	public int getNumberCards()             // interface
	{
		return players[PLAYER_1].getNumberCards();
	}

	public void setNumberCards(int howMany)  // interface
	{
		players[PLAYER_1].setNumberCards(howMany);
	}

	private Cards belotCards;
	private Player[] players;
	private int dealer;

	private int trump;
	private Card flippedCard;
	private int whoseTurn;
	private int caller;

	Card [] cards;                         // interface
	int otherPlayer;                       // interface
	int [] wins;                           // interface

}