import java.util.*;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
import card.*;

public class GameTest {
    @Test
    public void testPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(2, Suit.DIAMONDS));
        firstHand.add(new Card(3, Suit.SPADES));
        firstHand.add(new Card(4, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(1), ranks);
    }

    @Test
    public void testTwoPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(2, Suit.DIAMONDS));
        firstHand.add(new Card(2, Suit.SPADES));
        firstHand.add(new Card(4, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(2), ranks);
    }

    @Test
    public void testThreeOfKind() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(1, Suit.DIAMONDS));
        firstHand.add(new Card(2, Suit.SPADES));
        firstHand.add(new Card(4, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(3), ranks);
    }

    @Test
    public void testStraight() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(2, Suit.HEARTS));
        firstHand.add(new Card(3, Suit.DIAMONDS));
        firstHand.add(new Card(4, Suit.SPADES));
        firstHand.add(new Card(5, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(4), ranks);
    }

    @Test
    public void testFlush() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(7, Suit.HEARTS));
        firstHand.add(new Card(3, Suit.HEARTS));
        firstHand.add(new Card(9, Suit.HEARTS));
        firstHand.add(new Card(12, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(5), ranks);
    }

    @Test
    public void testFullHouse() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(1, Suit.DIAMONDS));
        firstHand.add(new Card(2, Suit.SPADES));
        firstHand.add(new Card(2, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(6), ranks);
    }

    @Test
    public void testFourOfKind() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(1, Suit.DIAMONDS));
        firstHand.add(new Card(1, Suit.SPADES));
        firstHand.add(new Card(2, Suit.HEARTS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(7), ranks);
    }

    @Test
    public void testStraightFlush() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(2, Suit.CLUBS));
        firstHand.add(new Card(3, Suit.CLUBS));
        firstHand.add(new Card(4, Suit.CLUBS));
        firstHand.add(new Card(5, Suit.CLUBS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(8), ranks);
    }

    @Test
    public void testRoyalFlush() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(10, Suit.CLUBS));
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(12, Suit.CLUBS));
        firstHand.add(new Card(13, Suit.CLUBS));
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(9), ranks);
    }

    @Test
    public void testUnsortedPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(2, Suit.CLUBS));
        firstHand.add(new Card(9, Suit.HEARTS));
        firstHand.add(new Card(2, Suit.DIAMONDS));
        firstHand.add(new Card(13, Suit.SPADES));
        firstHand.add(new Card(6, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(1), ranks);
    }

    @Test
    public void testUnsortedTwoPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(2, Suit.CLUBS));
        firstHand.add(new Card(4, Suit.CLUBS));
        firstHand.add(new Card(2, Suit.SPADES));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(4, Suit.DIAMONDS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(2), ranks);
    }

    @Test
    public void testUnsortedThreeOfKind() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(7, Suit.CLUBS));
        firstHand.add(new Card(4, Suit.DIAMONDS));
        firstHand.add(new Card(7, Suit.HEARTS));
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(7, Suit.SPADES));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(3), ranks);
    }

    @Test
    public void testUnsortedStraight() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(7, Suit.CLUBS));
        firstHand.add(new Card(4, Suit.HEARTS));
        firstHand.add(new Card(6, Suit.SPADES));
        firstHand.add(new Card(8, Suit.DIAMONDS));
        firstHand.add(new Card(5, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(4), ranks);
    }

    @Test
    public void testUnsortedFlush() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(7, Suit.SPADES));
        firstHand.add(new Card(2, Suit.SPADES));
        firstHand.add(new Card(6, Suit.SPADES));
        firstHand.add(new Card(11, Suit.SPADES));
        firstHand.add(new Card(3, Suit.SPADES));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(5), ranks);
    }

    @Test
    public void testUnsortedFullHouse() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(4, Suit.CLUBS));
        firstHand.add(new Card(8, Suit.HEARTS));
        firstHand.add(new Card(4, Suit.DIAMONDS));
        firstHand.add(new Card(8, Suit.SPADES));
        firstHand.add(new Card(4, Suit.HEARTS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(6), ranks);
    }

    @Test
    public void testUnsortedFourOfKind() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand.add(new Card(2, Suit.DIAMONDS));
        firstHand.add(new Card(1, Suit.SPADES));
        firstHand.add(new Card(1, Suit.HEARTS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(7), ranks);
    }

    @Test
    public void testUnsortedStraightFlush() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(2, Suit.CLUBS));
        firstHand.add(new Card(4, Suit.CLUBS));
        firstHand.add(new Card(3, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(5, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(8), ranks);
    }

    @Test
    public void testUnsortedRoyalFlush() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(13, Suit.CLUBS));
        firstHand.add(new Card(10, Suit.CLUBS));
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(12, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        assertEquals(Arrays.asList(9), ranks);
    }

    @Test
    public void highCardVsHighCard() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(3, Suit.DIAMONDS));
        firstHand.add(new Card(8, Suit.SPADES));
        firstHand.add(new Card(9, Suit.HEARTS));
        firstHand.add(new Card(5, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(1, Suit.CLUBS));
        secondHand.add(new Card(3, Suit.SPADES));
        secondHand.add(new Card(9, Suit.SPADES));
        secondHand.add(new Card(7, Suit.DIAMONDS));
        secondHand.add(new Card(5, Suit.HEARTS));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
    }

    @Test
    public void highCardVsPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(3, Suit.DIAMONDS));
        firstHand.add(new Card(8, Suit.SPADES));
        firstHand.add(new Card(9, Suit.HEARTS));
        firstHand.add(new Card(5, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(4, Suit.CLUBS));
        secondHand.add(new Card(3, Suit.SPADES));
        secondHand.add(new Card(9, Suit.SPADES));
        secondHand.add(new Card(9, Suit.DIAMONDS));
        secondHand.add(new Card(5, Suit.HEARTS));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
    }

    @Test
    public void pairVsPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(13, Suit.DIAMONDS));
        firstHand.add(new Card(5, Suit.SPADES));
        firstHand.add(new Card(6, Suit.DIAMONDS));
        firstHand.add(new Card(5, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(11, Suit.HEARTS));
        secondHand.add(new Card(2, Suit.CLUBS));
        secondHand.add(new Card(12, Suit.HEARTS));
        secondHand.add(new Card(9, Suit.SPADES));
        secondHand.add(new Card(12, Suit.CLUBS));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
    }

    @Test
    public void pairVsTwoPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(3, Suit.DIAMONDS));
        firstHand.add(new Card(8, Suit.SPADES));
        firstHand.add(new Card(9, Suit.HEARTS));
        firstHand.add(new Card(8, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(4, Suit.CLUBS));
        secondHand.add(new Card(3, Suit.SPADES));
        secondHand.add(new Card(9, Suit.SPADES));
        secondHand.add(new Card(9, Suit.DIAMONDS));
        secondHand.add(new Card(3, Suit.HEARTS));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
    }

    @Test
    public void twoPairVsTwoPair() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(1, Suit.CLUBS));
        firstHand.add(new Card(8, Suit.SPADES));
        firstHand.add(new Card(6, Suit.SPADES));
        firstHand.add(new Card(8, Suit.HEARTS));
        firstHand.add(new Card(6, Suit.CLUBS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(12, Suit.HEARTS));
        secondHand.add(new Card(9, Suit.CLUBS));
        secondHand.add(new Card(9, Suit.SPADES));
        secondHand.add(new Card(2, Suit.SPADES));
        secondHand.add(new Card(12, Suit.DIAMONDS));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
    }

    @Test
    public void threeOfKindVsThreeOfKind() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(2, Suit.CLUBS));
        firstHand.add(new Card(11, Suit.SPADES));
        firstHand.add(new Card(13, Suit.SPADES));
        firstHand.add(new Card(11, Suit.DIAMONDS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(9, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.CLUBS));
        secondHand.add(new Card(8, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.SPADES));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
    }

    @Test
    public void fullHouseVsfullHouse() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(11, Suit.HEARTS));
        firstHand.add(new Card(11, Suit.SPADES));
        firstHand.add(new Card(5, Suit.SPADES));
        firstHand.add(new Card(5, Suit.DIAMONDS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(12, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.CLUBS));
        secondHand.add(new Card(8, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.DIAMONDS));
        secondHand.add(new Card(8, Suit.SPADES));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
	}

    @Test
    public void fourOfKindVsfourOfKind() {
        Game g = new Game();
        List<Card> firstHand = new ArrayList<>();
        List<Card> secondHand = new ArrayList<>();
        List<List<Card>> hands = new ArrayList<>();
        List<Integer> ranks = new ArrayList<>();
        firstHand.add(new Card(11, Suit.CLUBS));
        firstHand.add(new Card(11, Suit.HEARTS));
        firstHand.add(new Card(11, Suit.SPADES));
        firstHand.add(new Card(13, Suit.SPADES));
        firstHand.add(new Card(11, Suit.DIAMONDS));
        firstHand = g.sort(firstHand);
        hands.add(firstHand);
        ranks.add(g.getRank(firstHand));
        secondHand.add(new Card(12, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.CLUBS));
        secondHand.add(new Card(8, Suit.HEARTS));
        secondHand.add(new Card(12, Suit.DIAMONDS));
        secondHand.add(new Card(12, Suit.SPADES));
        secondHand = g.sort(secondHand);
        hands.add(secondHand);
        ranks.add(g.getRank(secondHand));
        g.setHands(hands);
        g.setRanks(ranks);
        assertEquals(1, g.getWinner());
	}
}