teht3

package pokeritesti;

import java.util.List;
import java.util.Random;
import java.util.Stack;
import java.util.Collections;
import java.util.ArrayList;
import pokeritesti.KorttiPakka.DuplikaattiKorttiPoikkeus;


class PokeriPeli {



  private double stake;
  private ArrayList<Pelaaja> players;
  private KorttiPakka deck;

  public PokeriPeli() {
    stake = 0.0;
    deck = new KorttiPakka();
    players = new ArrayList<Pelaaja>();
  }

  public void addPlayer(String name, double credit) {
	players.add(new Pelaaja(name, credit, this));
  }

  public void play() {
    // pelin aloitus
    deck.sekoita();
    dealCards();
    // pelin kulku toteutetaan myöhemmin
  }

  public void dealCards() {
	// Jaetaan viisi korttia jokaiselle pelaajalle
    for(int i=0; i < 5; i++) {
      for(Pelaaja player : players) {
        player.takeCard(deck.annaKortti());
      }
    }
  }

  public Kortti getCard() {
    return deck.annaKortti();
  }

  public void raiseStake(double amount) {
    stake = stake + amount;
  }

  public boolean playerRaise(Pelaaja player, double amount) {
      return player.raiseStake(amount);
  }

  public boolean playerChangeCards(Pelaaja player, int[] cardsToChange) {
      return player.changeCards(cardsToChange);
  }

  public String toString() {
    String gameStatus = "Panos: " + stake + "\n";
    for(Pelaaja player : players) {
        gameStatus += player + "\n";
      }
    return gameStatus;
  }
}

class Pelaaja {
  private String name;
  private double money;
  private PokeriPeli game;
  private ArrayList<Kortti> hand;

  public Pelaaja(String playerName, double credit, PokeriPeli playes) {
    name = playerName;
    money = credit;
    game = playes;
    hand = new ArrayList<Kortti>();
  }

  public String getName() {
    return name;
  }

  public boolean takeCard(Kortti card) {
    if (hand.size() < 5) {
      hand.add(card);
      return true;
    }
    else
      return false;
  }

  public boolean raiseStake(double amount) {
    if( amount <= money ) {
      money = money - amount;
      game.raiseStake(amount);
      return true;
    }
    else
      return false;
  }

  public boolean changeCards(int[] cardsToChange) {
    if( cardsToChange.length > 0 && cardsToChange.length < 6 ) {
      for( int i=0; i < cardsToChange.length; i++ ) {
        Kortti card = game.getCard();
        hand.set(cardsToChange[i], card);
      }
      return true;
    }
    else
      return false;

  }

  public String playersHand() {
    String playersHand = hand.get(0).toString();
    for( int i=1; i < hand.size(); i++ ) {
        playersHand = playersHand + "\n" + hand.get(i).toString();
      }
    return playersHand;
  }

  public String toString() {
    String player = "Nimi: " + name + "\n";
    player = player + "Rahaa: " + money + "\n";
    player = player + "Kortit:\n" + playersHand();
    return player;
  }
}



class KorttiPakka {



    private Stack<Kortti> kortit;

    /**
     * Alustaa korttipakkaolion ja täyttää sen korteilla
     */
    KorttiPakka() {
        kortit = new Stack<Kortti>();
        uusiPakka();
    }

    /**
     * Tyhjentää korttipakan ja luo uuden, jossa kortit ovat neljää maata.
     * Jokaisella maalla on arvot 1-13. Järjestys on pata, hertta, ruutu, risti.
     */
    public void uusiPakka() {
        // tyhjentää korttipakan
        kortit.clear();
        // korttien maat
        int[] suites = {Kortti.PATA, Kortti.HERTTA, Kortti.RUUTU, Kortti.RISTI};
        // laittaa pakkaan jokaista maata kohti kortit arvoilla 1-13
        for(int i=0; i < 4; i++) {
            for(int j=1; j < 14; j++) {
                kortit.add(new Kortti(suites[i], j));
            }
        }
    }

    /** Sekoittaa korttipakan satunnaiseen järjestykseen */
    public void sekoita() {
        Collections.shuffle(kortit);
    }

    /** Palauttaa korttipakan päällimmäisen kortin ja poistaa sen pakasta */
    public Kortti annaKortti() {
        if(!kortit.empty()){
            return kortit.pop();
        } else{
            return null;
        }
    }

    /** Palautta korttipakan päälimmäisen kortin, mutta jättää sen pakkaan. */
    public Kortti naytaKortti(){
        if(!kortit.empty()){
            return kortit.peek();
        } else {
            return null;
        }
    }



    public String toString(){
        StringBuilder builder = new StringBuilder();
        for(Kortti kortti : kortit) {
            builder.append(kortti);
            builder.append("\n");
        }
        return builder.toString();
    }


    public void lisaaKortti(Kortti kortti) throws DuplikaattiKorttiPoikkeus {
        kortit.add(kortti);
        if (kortit.contains(kortti)) {
      throw new DuplikaattiKorttiPoikkeus();
    }
    }


class DuplikaattiKorttiPoikkeus extends Exception{
   public DuplikaattiKorttiPoikkeus(){
      super("kortti jo pakassa");
   }

}

}


/*class Kortti {

    // Luokkamuuttujat eri maille
    public static final int PATA = 1;
    public static final int HERTTA = 2;
    public static final int RUUTU = 3;
    public static final int RISTI = 4;

    // Attribuutit vakiota (final), koska kortin maan ja arvon vaihtoa ei sallita luonnin jälkeen
    private final int maa;
    private final int arvo;

    public Kortti(int suit, int value) {
        this.maa = suit;
        this.arvo = value;
    }

    public int annaMaa(){
        return maa;
    }
    public int annaArvo(){
        return arvo;
    }

    public String toString(){
        switch(maa){
            case Kortti.PATA:
                return "Pata" + arvo;
            case Kortti.HERTTA:
                return "Hertta" + arvo;
            case Kortti.RUUTU:
                return "Ruutu" + arvo;
            case Kortti.RISTI:
                return "Risti" + arvo;
        }
        return null;
    }
}
*/
class Pokerikasi implements Comparable<Pokerikasi>{

    /** Eri arvoisten käsien tyypit. Tyypeille asetetaan myös kokonaislukuarvot,
      * jotka kuvaavat käden paremmuuttaa. */
    public enum Kasi{
        HAI(1),PARI(2),KAKSI_PARIA(3),KOLME_SAMAA(4),
        SUORA(5),VARI(6),TAYSKASI(7),NELJA_SAMAA(8),VARISUORA(9);

        /** Käden arvo kokonaislukuna. */
        private final int arvo;

        Kasi(int arvo){
            this.arvo = arvo;
        }

        public int arvo(){
            return arvo;
        }

    }

    private List<Kortti> kortit;

    private Kasi tyyppi;

    /** Mikä korteista on käden arvoltaan merkitsevin kortti.
      * Esim. kädessä 3,3,3,2,2, merkitsevin kortti on 3
      */
    private Kortti merkitseva1;

    /** Mikä korteista on käden arvoltaan toiseksi merkitsevin kortti.
      * Esim. kädessä 3,3,3,2,2, toiseksi merkitsevin kortti on 2
      */
    private Kortti merkitseva2;

    public Pokerikasi(){
        kortit = new ArrayList<Kortti>();
    }

    public void lisaaKortti(Kortti kortti){
        kortit.add(kortti);
    }

    public Kasi annaKadenTyyppi(){
        return tyyppi;
    }

    public String toString(){
        String tulos = "";
        for(Kortti kortti : kortit){
            tulos += kortti + " ";
        }
        return tulos;
    }

    /** Selvittää käden tyypin ja tallentaa sen attribuuttin tyyppi.
      * @return Pokerikäden tyyppi (Kasi.VARISUORA, ...)
      */
    public Kasi selvitaKadenTyyppi(){
        // Kortit järjestykseen pienimmästä suurimpaan
        // Ässä on Kortti-luokkaa tehdyssä compareTo-metodissa märitelty suurin kortit,
        // joten mikäli käsi sisältää ässiä, ne ovat listassa viimeisinä
        Collections.sort(kortit);
        if(onkoVariSuora()){
            tyyppi = Kasi.VARISUORA;
        } else if(onkoNeljaSamaa()){
            tyyppi = Kasi.NELJA_SAMAA;
        } else if(onkoTaysKasi()){
            tyyppi = Kasi.TAYSKASI;
        } else if(onkoVari()){
            tyyppi = Kasi.VARI;
        } else if(onkoSuora()){
            tyyppi = Kasi.SUORA;
        } else if(onkoKolmeSamaa()){
            tyyppi = Kasi.KOLME_SAMAA;
        } else if(onkoKaksiParia()){
            tyyppi = Kasi.KAKSI_PARIA;
        } else if(onkoPari()){
            tyyppi = Kasi.PARI;
        } else {
            tyyppi = Kasi.HAI;
            merkitseva1 = kortit.get(kortit.size()-1);
        }
        return tyyppi;
    }

    public int compareTo(Pokerikasi kasi){
        selvitaKadenTyyppi();
        kasi.selvitaKadenTyyppi();

        // Käsien tyyppi sama, joten selvitetään, kumman merkitsevät kortit ovat suurempia
        if(this.annaKadenTyyppi() == kasi.annaKadenTyyppi()){
            if(this.merkitseva1 == kasi.merkitseva1){
                if(this.merkitseva2 == kasi.merkitseva2){
                    // Molemmat merkitsevät kortit yhtäsuuria, joten selvitetään
                    // kummassa kädessä on suurempi hai
                    return parempiHai(kasi);
                } else {
                    // Toiseksi merkitsevimmät kortit erisuuria, joten
                    // palautetaan korttien vertailu
                    return this.merkitseva2.compareTo(kasi.merkitseva2);
                }
            } else {
                // Merkitsevimmät kortit erisuuria, joten
                // palautetaan korttien vertailu
                return this.merkitseva1.compareTo(kasi.merkitseva1);
            }
        }

        // Muuten palautetaan tämän käden tyypin arvo - verrattaven käden tyypin arvo.
        // Esim. Kasi.PARI - Kasi.KAKSI_PARIA (2 - 3 = -1), eli verrattava käsi isompi, joten
        // palautetaan negatiivinen arvo
        return this.tyyppi.arvo() - kasi.tyyppi.arvo();
    }


    /** Palauttaa positiivisen luvun, jos tässä kädessä suurempi hai,
      * 0, jos molempien käsien hai-kortit samoja ja negatiivisen, jos
      * tässä kädessä olevat hait ovat pienempiä. Merkitseviä kortteja
      * ei vertailla.
      */
    private int parempiHai(Pokerikasi kasi){
        List<Kortti> hait1 = new ArrayList<Kortti>();
        List<Kortti> hait2 = new ArrayList<Kortti>();
        // Otetaan talteen tämän käden hai-kortit
        for(Kortti kortti : kortit){
            if(merkitseva1.compareTo(kortti) != 0 && merkitseva2.compareTo(kortti) != 0){
                hait1.add(kortti);
            }
        }
        // Otetaan talteen parametrikäden hai-kortit
        for(Kortti kortti : kasi.kortit){
            if(kasi.merkitseva1.compareTo(kortti) != 0 && kasi.merkitseva2.compareTo(kortti) != 0){
                hait2.add(kortti);
            }
        }
        for(int i = 0; i < hait1.size(); i++){
            int vertailu = hait1.get(i).compareTo(hait2.get(i));
            if(vertailu != 0){
                return vertailu;
            }
        }
        return 0;
    }

    private boolean onkoVariSuora(){
        // Testataan, että käsi on sekä väri että suora
        return onkoVari() && onkoSuora();
    }

    private boolean onkoSuora(){
        int viimeinen = kortit.size();
        // Testataan viimeinen kortti erikseen, koska se voi olla ässä
        if(kortit.get(kortit.size()-1).annaArvo() == 1){
            // Toiseksi viimeisen kortin tulee olla kuningas
            if(kortit.get(kortit.size()-2).annaArvo() != 13){
                return false;
            }
            viimeinen--;
        }
        for(int i = 1; i < viimeinen; i++){
            if(kortit.get(i).annaArvo() != kortit.get(i-1).annaArvo() + 1){
                return false;
            }
        }
        return true;
    }

    private boolean onkoVari(){
        // Tarkastetaan, ovatko peräkkäiset kortit samaa maata
        for(int i = 1; i < kortit.size(); i++){
            if(kortit.get(i).annaMaa() != kortit.get(i-1).annaMaa()){
                return false;
            }
        }
        merkitseva1 = kortit.get(kortit.size()-1);
        return true;
    }

    private boolean onkoNeljaSamaa(){
        // Neljä samaa joko muodossa 8,8,8,8,12 tai 6,8,8,8,8
        // joka tapauksessa käsi voidaan tarkastaa esimerkiksi toisen kortin
        // arvon frekvenssin mukaan
        if(laskeFrekvenssi(kortit.get(1).annaArvo()) == 4){
            merkitseva1 = kortit.get(1);
            return true;
        }
        return false;
    }

    private boolean onkoTaysKasi(){
        // Täyskäsi muotoa 3,3,3,8,8
        if(laskeFrekvenssi(kortit.get(0).annaArvo()) == 3 && laskeFrekvenssi(kortit.get(3).annaArvo()) == 2){
            merkitseva1 = kortit.get(0);
            merkitseva2 = kortit.get(3);
            return true;
        // Täyskäsi muotoa 3,3,8,8,8
        } else if(laskeFrekvenssi(kortit.get(0).annaArvo()) == 2 && laskeFrekvenssi(kortit.get(3).annaArvo()) == 3){
            merkitseva1 = kortit.get(3);
            merkitseva2 = kortit.get(0);
            return true;
        }
        return false;
    }

    private boolean onkoKolmeSamaa(){
        // Kolme samaa joko muodossa 8,8,8,10,11, 3,8,8,8,13 tai 3,6,8,8,8
        // Merkitsevä kortti on joka tapauksessa kolmas korteista
        if(laskeFrekvenssi(kortit.get(2).annaArvo()) == 3){
            merkitseva1 = kortit.get(2);
            return true;
        }
        return false;
    }


    private boolean onkoKaksiParia(){
        // Kaksi paria muodossa 2,2,5,7,7
        if(laskeFrekvenssi(kortit.get(0).annaArvo()) == 2 && laskeFrekvenssi(kortit.get(kortit.size()-1).annaArvo()) == 2){
            merkitseva1 = kortit.get(kortit.size()-1);
            merkitseva2 = kortit.get(0);
            return true;
        // Kaksi paria muodossa 2,5,5,7,7
        } else if(laskeFrekvenssi(kortit.get(2).annaArvo()) == 2 && laskeFrekvenssi(kortit.get(kortit.size()-1).annaArvo()) == 2){
            merkitseva1 = kortit.get(kortit.size()-1);
            merkitseva2 = kortit.get(2);
            return true;
        // Kaksi paria muodossa 2,2,5,5,7
        } else if(laskeFrekvenssi(kortit.get(0).annaArvo()) == 2 && laskeFrekvenssi(kortit.get(2).annaArvo()) == 2){
            merkitseva1 = kortit.get(2);
            merkitseva2 = kortit.get(0);
            return true;
        }
        return false;
    }

    private boolean onkoPari(){
        // Tarkistetaan, löytyykö kaksi peräkkäistä saman arvoista korttia
        for(int i = 1; i < kortit.size(); i++){
            if(kortit.get(i).annaArvo() == kortit.get(i-1).annaArvo()){
                merkitseva1 = kortit.get(i);
                return true;
            }
        }
        return false;
    }

    /** Laskee tietyn arvoisten korttien lukumäärän kädessä. */
    private int laskeFrekvenssi(int kortinArvo){
        int frekvenssi = 0;
        for(Kortti kortti : kortit){
            if(kortti.annaArvo() == kortinArvo){
                frekvenssi++;
            }
        }
        return frekvenssi;
    }
}




class Kortti implements Comparable<Kortti>{

    // Luokkaamuuttujat eri maille
    public static final int PATA = 1;
    public static final int HERTTA = 2;
    public static final int RUUTU = 3;
    public static final int RISTI = 4;

    // Attribuutit vakiota (final), koska kortin maan ja arvon vaihtoa ei sallita luonnin jälkeen
    private final int maa;
    private final int arvo;

    public Kortti(int maa, int arvo) {
        this.maa = maa;
        this.arvo = arvo;
    }

    public int annaMaa(){
        return maa;
    }
    public int annaArvo(){
        return arvo;
    }

    public String toString(){
        switch(maa){
            case Kortti.PATA:
                return ("pata " + arvo);
            case Kortti.HERTTA:
                return ("hertta " + arvo);
            case Kortti.RUUTU:
                return ("ruutu " + arvo);
            case Kortti.RISTI:
                return ("risti " + arvo);
        }
        return null;
    }

    public int compareTo(Kortti card){
        int value1 = this.arvo;
        int value2 = card.annaArvo();
        // Ässä vertailussa suurin kortti
        if(value1 == 1){
            value1 = 14;
        }
        if(value2 == 1){
            value2 = 14;
        }
        return value1 - value2;
    }
}

public class PokeriTesti {

      public static void main(String[] args) throws DuplikaattiKorttiPoikkeus{
        System.out.println("Luodaan pakka");
        KorttiPakka dc = new KorttiPakka();
        System.out.println(dc);
        dc.uusiPakka();
        dc.sekoita();
        Kortti k1=new Kortti(1,1);
        System.out.println(dc);
         try{

        dc.lisaaKortti(k1);

        } catch (IllegalArgumentException iae){

        }
     }
}