/*
 * 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
 */

package FinalProject;
/* Useful imports */

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 FinalProject.Card;
import FinalProject.CardDeck;

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

// displays one inputted five card hand
public class SingleHandDisplay extends DisplayPanel{
	
	// hash set of cards
    private HashSet cardSet = new HashSet();
    
    int size = 250;
    
    Rectangle2D bounds = new Rectangle2D.Double(0, 0, size, size);
    
    // arrays of rank/suit values
    public int[] cardValues = new int[5];
    public int[] cardSuitValues = new int[5];
    
    // sorted arrays of rank/suit values
    public int[] cardValuesSorted = new int[5];
    public int[] cardSuitValuesSorted = new int[5];
    
    // card array
    public Card[] cardArray;
    
    // hand-specific values
    public int fourKindNum;
    public int fHThreeKindNum;
    public int fHPairNum;
    public int flushSuitNum;
    public int straightStartNum;
    public int straightEndNum;
    public int threeKindNum;
    public int pairNum;
    public int secondPairNum;
    
    // constructor
    public SingleHandDisplay(Card[] cards) {
    	
    	// card deck
    	CardDeck deck = new CardDeck();

		TablePanel mainPanel = new TablePanel(3, 1);

		// add given cards from array to hash set
		addCards(cards);

		// define card array
		cardArray = getCardsAsArray();

		initialize();

		// produce DisplayPanel
		mainPanel.addObject(cardPanel(5));

		mainPanel.addObject(cardText());

		mainPanel.addObject(madeHand());

		addObject(mainPanel);

        frame("Single Hand");
    }
    
    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);

    	}
    	
    }
       
    // panel of card images
    public TablePanel cardPanel(int howmany) {
        TablePanel panel = new TablePanel(1, howmany, 10, 10);
        
        panel.addObject(cardArray[0].getPicture());
        panel.addObject(cardArray[1].getPicture());
        panel.addObject(cardArray[2].getPicture());
        panel.addObject(cardArray[3].getPicture());
        panel.addObject(cardArray[4].getPicture());
        
        return panel;
    }
    

    // text representing 5 cards in the hand
    public TablePanel cardText(){
    	TablePanel panel = new TablePanel();
    	
        String rank1 = cardArray[0].getRankAsString();
        String rank2 = cardArray[1].getRankAsString();
        String rank3 = cardArray[2].getRankAsString();
        String rank4 = cardArray[3].getRankAsString();
        String rank5 = cardArray[4].getRankAsString();

        String suit1 = cardArray[0].getSuitAsString();
        String suit2 = cardArray[1].getSuitAsString();
        String suit3 = cardArray[2].getSuitAsString();
        String suit4 = cardArray[3].getSuitAsString();
        String suit5 = cardArray[4].getSuitAsString();
        
        String s = rank1 + " of " + suit1 + ", " + 
        			rank2 + " of " + suit2 + ", " +
    				rank3 + " of " + suit3 + ", " +
    				rank4 + " of " + suit4 + ", " +
    				rank5 + " of " + suit5;
        
        TextPaintable tp = new TextPaintable
        (s, null, null, null, null, 500, 500);
    	
    	panel.addObject(tp);
    	
    	return panel;
    }
       
    // text representing 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;
    }
    
    /** Hand-Determining Functions **/
    
    private boolean straightFlush(){
		straightStartNum = cardValuesSorted[0];
		straightEndNum = cardValuesSorted[4];
    	return straight() && flush();
    }
    
    private boolean fourOfAKind(){
    	if ( ((cardValuesSorted[3] - cardValuesSorted[0]) == 0) ||
    			((cardValuesSorted[4] - cardValuesSorted[1]) == 0) ){
    		fourKindNum = cardValuesSorted[4];
    		return true;
    	}
    	else
    		return false;
    }
    
    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;
    }
    
    private boolean flush(){
    	flushSuitNum = cardSuitValues[0];
    	return ( cardSuitValuesSorted[0] == cardSuitValuesSorted[4] );
    }
    
    private boolean straight(){
    	
        // make an array of ranks from the cards array

        // sort the ranks array

        // make sure that if ranks[0] is a value k then
        // the next 4 values are k+1, k+2, k+3, k+4
    	
        // or ... if ace can be both low and high
        // deal also with this possibility as well
        // ... which amounts to 1, 10, 11, 12, 13
        // ... so it's just another case to test
    	    	
    	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;
    }
    
    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;
    }
    
    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;
    }
    
    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;
    }
    
    /** Hand-Specific String Functions **/
    
    private String straightFlushString(){
    	return "Straight Flush: " + Card.rankList[straightStartNum] + " to " + Card.rankList[straightEndNum];
    }
    
    private String fourOfAKindString(){
    	return "Four of a Kind " + Card.rankList[fourKindNum] + "s";
    }
    
    private String fullHouseString(){
    	return "Full House: " + Card.rankList[fHThreeKindNum] + "s full of " + Card.rankList[fHPairNum] + "s";
    }
    
    private String flushString(){
    	return Card.suitList[flushSuitNum] + " Flush";
    }
    
    private String straightString(){
    	return "Straight: " + Card.rankList[straightStartNum] + " to " + Card.rankList[straightEndNum];
    }
    
    private String threeOfAKindString(){
    	return "Three of a Kind " + Card.rankList[threeKindNum] + "s";
    }
    
    private String twoPairString(){
    	return "Two Pair: " + Card.rankList[pairNum] + "s and " + Card.rankList[secondPairNum] + "s";
    }

    private String pairString(){
    	return "Pair of " + Card.rankList[pairNum] + "s";
    }
    
    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]);
    }
    
}