/*
 * Created on Apr 6, 2005
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 */

/**
 * @author AlexPC
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */

/* Useful imports */

package FinalProject;
import edu.neu.ccs.*;
import edu.neu.ccs.gui.*;
import edu.neu.ccs.codec.*;
import edu.neu.ccs.console.*;
import edu.neu.ccs.filter.*;
import edu.neu.ccs.jpf.*;
import edu.neu.ccs.parser.*;
import edu.neu.ccs.pedagogy.*;
import edu.neu.ccs.quick.*;
import edu.neu.ccs.util.*;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.font.*;
import java.awt.image.*;
import javax.swing.*;
import javax.swing.border.*;


import java.io.*;
import java.util.*;
import java.math.*;
import java.beans.*;
import java.lang.reflect.*;
import java.net.*;
import java.util.regex.*;

// represent a five card hand
public class CardHand extends DisplayPanel{
	
	// hash set of cards
    private HashSet cardSet = new HashSet();
    
    int size = 250;
    
    Rectangle2D bounds = new Rectangle2D.Double(0, 0, size, size);
    
    // rank/suit arrays
    public int[] cardValues = new int[5];
    public int[] cardSuitValues = new int[5];
    
    // sorted rank/suit arrays
    public int[] cardValuesSorted = new int[5];
    public int[] cardSuitValuesSorted = new int[5];
    
    // re-arranged rank array
    public int[] newCVS = new int[5];
    
    // card array
    public Card[] cardArray;
    
    // hand-specific integer values
    public int fourKindNum;
    public int fHThreeKindNum;
    public int fHPairNum;
    public int flushSuitNum;
    public int flushHighCard;
    public int straightStartNum;
    public int straightEndNum;
    public int threeKindNum;
    public int pairNum;
    public int secondPairNum;
    
    // hand-specific constants
    int JUMP = 759375;
    int NOTHING = 0;
    int ONE_PAIR        = 1 * JUMP;
    int TWO_PAIR        = 2 * JUMP;
    int THREE_OF_A_KIND = 3 * JUMP;    
    int STRAIGHT        = 4 * JUMP;    
    int FLUSH           = 5 * JUMP;    
    int FULL_HOUSE      = 6 * JUMP;
    int FOUR_OF_A_KIND  = 7 * JUMP;    
    int STRAIGHT_FLUSH  = 8 * JUMP;
    
    // constructor
    public CardHand(Card[] cards) {
        addCards(cards);

        cardArray = getCardsAsArray();

        initialize();
    }
    
    // perform intialization tasks
    public void initialize() {
    	
        // int array of hand's card's ranks
    	cardValues[0] = cardArray[0].getRank();
    	cardValues[1] = cardArray[1].getRank();
    	cardValues[2] = cardArray[2].getRank();
    	cardValues[3] = cardArray[3].getRank();
    	cardValues[4] = cardArray[4].getRank();
        
        // int array of hand's card's suits
    	cardSuitValues[0] = cardArray[0].getSuit();
    	cardSuitValues[1] = cardArray[1].getSuit();
    	cardSuitValues[2] = cardArray[2].getSuit();
    	cardSuitValues[3] = cardArray[3].getSuit();
    	cardSuitValues[4] = cardArray[4].getSuit();
        
        // sorted(low to high) int array of hand's card's ranks
        cardValuesSorted = new int[5];{

    	    for(int i = 0; i < 5; i++){

    	    cardValuesSorted[i] = cardValues[i];

    	    }

    	Arrays.sort(cardValuesSorted);

    	}
        
        // sorted(low to high) int array of hand's card's suits
        cardSuitValuesSorted = new int[5];{

    	    for(int i = 0; i < 5; i++){

    	    cardSuitValuesSorted[i] = cardSuitValues[i];

    	    }

    	Arrays.sort(cardSuitValuesSorted);

    	}
    	
    }
       
    // determines and displays type of hand
    public TablePanel madeHand(){
    	TablePanel panel = new TablePanel();
    	
    	String hand;
    	
    	if (straightFlush())
    		hand = straightFlushString();
    	else if (fourOfAKind())
    		hand = fourOfAKindString();
    	else if (fullHouse())
    		hand = fullHouseString();
    	else if (flush())
    		hand = flushString();
    	else if (straight())
    		hand = straightString();
    	else if (threeOfAKind())
    		hand = threeOfAKindString();
    	else if (twoPair())
    		hand = twoPairString();
    	else if (pair())
    		hand = pairString();
    	else
    		hand = highCardString();
    		
 
    	
    	TextPaintable tp = new TextPaintable
		(hand, null, null, null, null, 800, 800);
    	
    	panel.addObject(tp);
    	
    	return panel;
    }
    
    // determines if a hand is a straight flush
    private boolean straightFlush(){
    	return straight() && flush();
    }
    
    // determines if a hand has four of a kind
    private boolean fourOfAKind(){
    	if ( ((cardValuesSorted[3] - cardValuesSorted[0]) == 0) ||
    			((cardValuesSorted[4] - cardValuesSorted[1]) == 0) ){
    		fourKindNum = cardValuesSorted[4];
    		return true;
    	}
    	else
    		return false;
    }
    
    // determines if a hand is a full house
    private boolean fullHouse(){
    	if ( (cardValuesSorted[2] == cardValuesSorted[0]) && 
    			(cardValuesSorted[3] == cardValuesSorted[4]) ){
    		fHThreeKindNum = cardValuesSorted[2];
    		fHPairNum = cardValuesSorted[3];
    		return true;
    	}
    	else if	( (cardValuesSorted[3] == cardValuesSorted[1]) && 
    			(cardValuesSorted[0] == cardValuesSorted[4]) ){
    		fHThreeKindNum = cardValuesSorted[3];
    		fHPairNum = cardValuesSorted[0];
    		return true;
    	}
		else if ( (cardValuesSorted[4] == cardValuesSorted[2]) && (
				cardValuesSorted[0] == cardValuesSorted[1]) ){
    		fHThreeKindNum = cardValuesSorted[4];
    		fHPairNum = cardValuesSorted[0];
    		return true;
		}
    	else 
    		return false;
    }
    
    // determines if a hand is a flush
    private boolean flush(){
    	flushSuitNum = cardSuitValues[0];
    	
    	if (cardValuesSorted[0] == 1)
    		flushHighCard = 14;
    	else
    		flushHighCard = cardValuesSorted[4];
    	
    	return ( cardSuitValuesSorted[0] == cardSuitValuesSorted[4] );
    }
    
    // determines if a hand is a straight
    private boolean straight(){
    	    	    	
    	if ( ((cardValuesSorted[4] - cardValuesSorted[0]) == 4) && !pair() ){
    		straightStartNum = cardValuesSorted[0];
    		straightEndNum = cardValuesSorted[4];
    		return true;
    	}
    	else if ( (cardValuesSorted[0] == 1) &&
    				(cardValuesSorted[1] == 10) &&
					(cardValuesSorted[2] == 11) &&
					(cardValuesSorted[3] == 12) &&
					(cardValuesSorted[4] == 13) ){
    		straightStartNum = cardValuesSorted[1];
    		straightEndNum = cardValuesSorted[0];
    		return true;
    	}
    	else    	
    		return false;
    }
    
    // determines if a hand has three of a kind
    private boolean threeOfAKind(){
    	if ( ((cardValuesSorted[2] - cardValuesSorted[0]) == 0) ||
    			((cardValuesSorted[3] - cardValuesSorted[1]) == 0) ||
				((cardValuesSorted[4] - cardValuesSorted[2]) == 0)){
    		threeKindNum = cardValuesSorted[2];
    		return true;
    	}
    	else 
    		return false;
    }
    
    // determines if a hand has two pair
    private boolean twoPair(){
    	if ( (cardValuesSorted[0] == cardValuesSorted[1]) &&
			( (cardValuesSorted[2] == cardValuesSorted[3]) ||
					(cardValuesSorted[3] == cardValuesSorted[4]) ) ){
    		pairNum = cardValuesSorted[0];
    		secondPairNum = cardValuesSorted[3];
    		return true;
    	}
		else if ( (cardValuesSorted[1] == cardValuesSorted[2]) &&
				(cardValuesSorted[3] == cardValuesSorted[4]) ){
			pairNum = cardValuesSorted[1];
			secondPairNum = cardValuesSorted[3];
	    	return true;
		}
		else if ( (cardValuesSorted[2] == cardValuesSorted[3]) &&
				(cardValuesSorted[0] == cardValuesSorted[1]) ){
			pairNum = cardValuesSorted[2];
			secondPairNum = cardValuesSorted[0];
	    	return true;
		}
		else if ( (cardValuesSorted[3] == cardValuesSorted[4]) &&
				( (cardValuesSorted[0] == cardValuesSorted[1]) ||
						(cardValuesSorted[1] == cardValuesSorted[2]) ) ){
			pairNum = cardValuesSorted[3];
			secondPairNum = cardValuesSorted[1];
	    	return true;
		}
		else
			return false;
    }
    
    // determines if a hand has one pair
    private boolean pair(){
    	if ( (cardValuesSorted[0] == cardValuesSorted[1]) ||
			(cardValuesSorted[1] == cardValuesSorted[2]) ){
    		pairNum = cardValuesSorted[1];
    		return true;
    	}
    	else if ( (cardValuesSorted[2] == cardValuesSorted[3]) ||
			(cardValuesSorted[3] == cardValuesSorted[4]) ){
    		pairNum = cardValuesSorted[3];
    		return true;
    	}
    	else
    		return false;
    }
    
    // produce straight flush string
    private String straightFlushString(){
    	return "Straight Flush: " + Card.rankList[straightStartNum] + " to " + Card.rankList[straightEndNum];
    }
    
    // produce four of a kind string
    private String fourOfAKindString(){
    	return "Four of a Kind " + Card.rankList[fourKindNum] + "s";
    }
    
    // produce full house string
    private String fullHouseString(){
    	return "Full House: " + Card.rankList[fHThreeKindNum] + "s full of " + Card.rankList[fHPairNum] + "s";
    }
    
    // produce flush string
    private String flushString(){
    	return Card.suitList[flushSuitNum] + " Flush";
    }
    
    // produce straight string
    private String straightString(){
    	return "Straight: " + Card.rankList[straightStartNum] + " to " + Card.rankList[straightEndNum];
    }
    
    // produce three of a kind string
    private String threeOfAKindString(){
    	return "Three of a Kind " + Card.rankList[threeKindNum] + "s";
    }
    
    // produce two pair string
    private String twoPairString(){
    	return "Two Pair: " + Card.rankList[pairNum] + "s and " + Card.rankList[secondPairNum] + "s";
    }

    // produce pair string
    private String pairString(){
    	return "Pair of " + Card.rankList[pairNum] + "s";
    }
    
    // produce high card string
    private String highCardString(){
    	if (cardValuesSorted[0] == 1)
    		return "High Card Ace";
    	else
    		return "High Card " + Card.rankList[cardValuesSorted[4]];
    }
    
    
    // add an array of cards
    public void addCards(Card[] cards) {
        if (cards == null)
             return;

        int length = cards.length;

        for (int i = 0; i < length; i++)
            addCard(cards[i]);
    }


    // add one card
    public void addCard(Card card) {
        if (card == null)
            return;

        cardSet.add(card);
    }


    // remove an array of cards
    public void removeCards(Card[] cards) {
        if (cards == null)
             return;

        int length = cards.length;

        for (int i = 0; i < length; i++)
            removeCard(cards[i]);
    }


    // remove one card
    public void removeCard(Card card) {
        if (card == null)
            return;

        cardSet.remove(card);
    }


    // return the current cards in the hand as an array
    public Card[] getCardsAsArray() {
        return (Card[]) cardSet.toArray(new Card[0]);
    }
    
    // return the "score" of a hand
    public int score() {
        return kindofhand() + basescore();
    }
    
    // return the hand's base score
    public int basescore() {
        
    	// rearrage array, in case of an ace
    	if (cardValuesSorted[0] == 1) {
    		newCVS[0] = cardValuesSorted[1];
    		newCVS[1] = cardValuesSorted[2];
    		newCVS[2] = cardValuesSorted[3];
    		newCVS[3] = cardValuesSorted[4];
    		// new value for the ace
    		newCVS[4] = 14;
    	}
    	else
    		// if no ace, array remains unchanged
    		newCVS = cardValuesSorted;

        int number = newCVS[4];  // highest digit

        // multiply current number by 15 and add next digit
        for (int i = 3; i >= 0; i--)
            number = number * 15 + cardValuesSorted[i];

        // return the base 15 number
        return number;
    }
        
    // return an integer value as per type of hand
    int kindofhand() {
        // returns one of the above constants that tells
        // what kind of hand we have
    	if (straightFlush()) {
    		if (straightEndNum == 1)
    			return STRAIGHT_FLUSH * 14;
    		else
    			return STRAIGHT_FLUSH * straightEndNum;
    	}
    	else if (fourOfAKind()) {
    		if (fourKindNum == 1)
    			return FOUR_OF_A_KIND * 14;
    		else
    			return FOUR_OF_A_KIND * fourKindNum;
    	}
    	else if (fullHouse()) {
    		if (fHThreeKindNum == 1)
    			return FULL_HOUSE * 14;
    		else
    			return FULL_HOUSE * fHThreeKindNum;
    	}
    	else if (flush()) {
    		return FLUSH * flushHighCard;
    	}
    	else if (straight()) {
    		if (straightEndNum == 1)
    			return STRAIGHT * 14;
    		else
    			return STRAIGHT * straightEndNum;
    	}
    	else if (threeOfAKind()) {
    		if (threeKindNum == 1)
    			return THREE_OF_A_KIND * 14;
    		else
    			return THREE_OF_A_KIND * threeKindNum;
    	}
    	else if (twoPair()) {
    		if (secondPairNum == 1)
    			secondPairNum = 14;
    		
    		if (pairNum == 1)
    			pairNum = 14;
    		
    		if (secondPairNum > pairNum)
    			return TWO_PAIR * secondPairNum;
    		else
    			return TWO_PAIR * pairNum;
    	}
    	else if (pair()){
    		if (pairNum == 1)
    			return ONE_PAIR * 14;
    		else
    			return ONE_PAIR * pairNum;
    	}
    	else
    		return NOTHING;
    }
    
}