package jrummikub.control;

import static jrummikub.model.StoneColor.BLACK;
import static jrummikub.model.StoneColor.BLUE;
import static jrummikub.model.StoneColor.ORANGE;
import static jrummikub.model.StoneColor.RED;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import jrummikub.model.Hand;
import jrummikub.model.IHand;
import jrummikub.model.ITable;
import jrummikub.model.MockRoundState;
import jrummikub.model.MockTable;
import jrummikub.model.Position;
import jrummikub.model.RoundState;
import jrummikub.model.Stone;
import jrummikub.model.StoneSet;
import jrummikub.model.Table;
import jrummikub.util.Pair;
import jrummikub.view.MockView;

import org.junit.Before;
import org.junit.Test;

/**
 * Tests for {@link RoundControl}
 */
public class RoundControlTest {
	private MockView view;
	private MockRoundState testRoundState;
	private RoundControl testRound;
	private MockTable testTable;

	/**
	 * For each test create a round control initialized by a mock model and view
	 */
	@Before
	public void setup() {
		view = new MockView();
		testRoundState = new MockRoundState();
		testRound = new RoundControl(testRoundState, view);
		Stone stone = testRoundState.getGameHeap().drawStone();
		testRoundState.table.drop(new StoneSet(stone), new Position(5, 0));
		testTable = new MockTable();
		testTable.sets.add(testRoundState.table.sets.get(0));
		testRoundState.table.clonedTable = testTable;
	}

	private void checkCorrectlyDealed() {
		assertEquals(106 - testRoundState.getPlayerCount() * 14
				- testRoundState.table.getSize(), testRoundState.getGameHeap()
				.getSize());
		for (int i = 0; i < testRoundState.getPlayerCount(); i++) {
			assertEquals(14, testRoundState.getNthNextPlayer(i).getHand()
					.getSize());
		}
	}

	private void checkTurnStartSetUp() {
		assertNotNull(view.currentPlayerName);
		assertNotNull(view.getTablePanel().leftPlayerName);
		assertNotNull(view.getTablePanel().topPlayerName);
		assertNotNull(view.getTablePanel().rightPlayerName);
		assertTrue(view.displayStartTurnPanel);
		assertFalse(view.startTurnEvent.listeners.isEmpty());
		assertFalse(view.displayWinPanel);
		checkTableDisplay();
	}

	private void checkTableDisplay() {
		Iterator<Pair<StoneSet, Position>> stoneSetsView = view.tablePanel.stoneSets
				.iterator();
		Iterator<Pair<StoneSet, Position>> stoneSetsModel = testRoundState.table
				.clone().sets.iterator();

		while (stoneSetsView.hasNext()) {
			assertTrue(stoneSetsModel.hasNext());
			assertSame(stoneSetsView.next(), stoneSetsModel.next());
		}
		assertFalse(stoneSetsModel.hasNext());
	}

	private void resetTurnStart() {
		view.currentPlayerName = null;
		view.getTablePanel().leftPlayerName = null;
		view.getTablePanel().topPlayerName = null;
		view.getTablePanel().rightPlayerName = null;
		view.displayStartTurnPanel = false;
	}

	// laidOut test cases
	/** */
	@Test
	public void laidOutValidTooFew() {
		Stone blueOne = new Stone(1, BLUE);
		Stone blueTwo = new Stone(2, BLUE);
		Stone blueThree = new Stone(3, BLUE);

		RoundState roundState = new RoundState();
		RoundControl roundControl = new RoundControl(roundState, view);

		IHand hand = roundState.getActivePlayer().getHand();
		hand.drop(blueOne, new Position(0, 0));
		hand.drop(blueTwo, new Position(0, 0));
		hand.drop(blueThree, new Position(0, 0));

		assertFalse(roundState.getActivePlayer().getLaidOut());

		hand.pickUp(blueOne);
		hand.pickUp(blueTwo);
		hand.pickUp(blueThree);

		roundState.getTable().drop(
				new StoneSet(Arrays.asList(blueOne, blueTwo, blueThree)),
				new Position(0, 0));

	}

	/** */
	@Test
	public void laidOutInvalidEnough() {
		Stone blueOne = new Stone(1, BLUE);
		Stone blueTwo = new Stone(2, BLUE);
		Stone blueThree = new Stone(3, BLUE);

		Stone redEight = new Stone(8, RED);
		Stone redNine = new Stone(9, RED);
		Stone redTen = new Stone(10, RED);

		Stone orangeOne = new Stone(1, ORANGE);

		RoundState roundState = new RoundState();
		RoundControl roundControl = new RoundControl(roundState, view);

		IHand hand = roundState.getActivePlayer().getHand();
		hand.drop(blueOne, new Position(0, 0));
		hand.drop(blueTwo, new Position(0, 0));
		hand.drop(blueThree, new Position(0, 0));

		hand.drop(redEight, new Position(0, 0));
		hand.drop(redNine, new Position(0, 0));
		hand.drop(redTen, new Position(0, 0));

		hand.drop(orangeOne, new Position(0, 0));
	}

	/** */
	@Test
	public void laidOutEnoughChangedTable() {
		Stone redEight = new Stone(8, RED);
		Stone redNine = new Stone(9, RED);
		Stone redTen = new Stone(10, RED);

		Stone blueSeven = new Stone(7, BLUE);
		Stone blackSeven = new Stone(7, BLACK);
		Stone redSeven = new Stone(7, RED);
		Stone orangeSeven = new Stone(7, ORANGE);

		StoneSet sevenSet = new StoneSet(Arrays.asList(blueSeven, blackSeven,
				redSeven, orangeSeven));

		RoundState roundState = new RoundState();
		RoundControl roundControl = new RoundControl(roundState, view);

	}

	/** */
	@Test
	public void laidOutTooFewChangedTable() {
		Stone redEight = new Stone(8, RED);
		Stone redNine = new Stone(9, RED);
		Stone redTen = new Stone(10, RED);
		Stone redEleven = new Stone(11, RED);

		Stone blueSeven = new Stone(7, BLUE);
		Stone blackSeven = new Stone(7, BLACK);
		Stone redSeven = new Stone(7, RED);
		Stone orangeSeven = new Stone(7, ORANGE);

		StoneSet sevenSet = new StoneSet(Arrays.asList(blueSeven, blackSeven,
				redSeven, orangeSeven));

		RoundState roundState = new RoundState();
		RoundControl roundControl = new RoundControl(roundState, view);

	}

	/** */
	@Test
	public void laidOutValid() {

		Stone blueOne = new Stone(1, BLUE);
		Stone blueTwo = new Stone(2, BLUE);
		Stone blueThree = new Stone(3, BLUE);

		Stone redEight = new Stone(8, RED);
		Stone redNine = new Stone(9, RED);
		Stone redTen = new Stone(10, RED);

		RoundState roundState = new RoundState();
		RoundControl roundControl = new RoundControl(roundState, view);

		IHand hand = roundState.getActivePlayer().getHand();
		hand.drop(blueOne, new Position(0, 0));
		hand.drop(blueTwo, new Position(0, 0));
		hand.drop(blueThree, new Position(0, 0));

		hand.drop(redEight, new Position(0, 0));
		hand.drop(redNine, new Position(0, 0));
		hand.drop(redTen, new Position(0, 0));

		assertFalse(roundState.getActivePlayer().getLaidOut());

		hand.pickUp(blueOne);
		hand.pickUp(blueTwo);
		hand.pickUp(blueThree);

		roundState.getTable().drop(
				new StoneSet(Arrays.asList(blueOne, blueTwo, blueThree)),
				new Position(0, 0));

		hand.pickUp(redEight);
		hand.pickUp(redNine);
		hand.pickUp(redTen);

		roundState.getTable().drop(
				new StoneSet(Arrays.asList(redEight, redNine, redTen)),
				new Position(0, 0));

		view.playerPanel.endTurnEvent.emit();

		assertTrue(roundState.getNthNextPlayer(roundState.getPlayerCount() - 1)
				.getLaidOut());
	}

	/** */
	@Test
	public void testDealStones() {
		testRound.deal();
		checkCorrectlyDealed();
		for (int i = 0; i < 14; i++) {
			testRound.dealStones(2);
		}
		assertEquals(2 * 14 + 14, testRoundState.getActivePlayer().getHand()
				.getSize());
	}

	/** */
	@Test
	public void testDeal() {
		testRound.deal();
		checkCorrectlyDealed();
	}

	/** */
	@Test
	public void testStartRound() {
		testRound.startRound();
		checkCorrectlyDealed();

		checkTurnStartSetUp();
	}

	/** */
	@Test
	public void testTableDisplay() {
		testRound.startRound();
		checkCorrectlyDealed();
		view.startTurnEvent.emit();
		checkTableDisplay();
		view.getPlayerPanel().endTurnEvent.emit();
	}

	/** */
	@Test
	public void testTableValidHandChanged() {
		testRound.startRound();
		MockTable oldTable = testRoundState.table;
		testTable.valid = true;
		oldTable.clonedTable = testTable;

		view.startTurnEvent.emit();
		assertFalse(view.displayStartTurnPanel);

		IHand hand = testRoundState.players.get(0).hand;
		hand.pickUp(hand.iterator().next().getFirst());
		resetTurnStart();
		view.getPlayerPanel().endTurnEvent.emit();

		assertSame(testTable, testRoundState.setTable);
		assertEquals(1, testRoundState.activePlayer);

		checkTurnStartSetUp();
	}

	/** */
	@Test
	public void testTableInvalidHandChanged() {
		testRound.startRound();
		MockTable oldTable = testRoundState.table;
		testTable.valid = false;
		oldTable.clonedTable = testTable;

		view.startTurnEvent.emit();
		assertFalse(view.displayStartTurnPanel);
		IHand hand = testRoundState.players.get(0).hand;
		Stone stone = hand.iterator().next().getFirst();
		hand.pickUp(stone);
		testTable.drop(new StoneSet(stone), new Position(0, 0));
		resetTurnStart();
		view.getPlayerPanel().endTurnEvent.emit();

		assertNull(testRoundState.setTable);
		assertEquals(1, testRoundState.activePlayer);
		assertEquals(14 + 3, testRoundState.players.get(0).hand.getSize());
		checkTurnStartSetUp();
	}

	/** */
	@Test
	public void testTableValidHandUnchanged() {
		testRound.startRound();
		MockTable oldTable = testRoundState.table;
		testTable.valid = true;
		oldTable.clonedTable = testTable;

		view.startTurnEvent.emit();
		assertFalse(view.displayStartTurnPanel);
		resetTurnStart();
		view.getPlayerPanel().endTurnEvent.emit();

		assertSame(testTable, testRoundState.setTable);
		assertEquals(14 + 1, testRoundState.players.get(0).hand.getSize());
		assertEquals(1, testRoundState.activePlayer);

		checkTurnStartSetUp();
	}

	/** */
	@Test
	public void testTableInvalidHandUnchanged() {
		testRound.startRound();
		MockTable oldTable = testRoundState.table;
		testTable.valid = false;
		oldTable.clonedTable = testTable;

		view.startTurnEvent.emit();
		assertFalse(view.displayStartTurnPanel);
		resetTurnStart();
		view.getPlayerPanel().endTurnEvent.emit();

		assertNull(testRoundState.setTable);
		assertEquals(14 + 1, testRoundState.players.get(0).hand.getSize());
		assertEquals(1, testRoundState.activePlayer);

		checkTurnStartSetUp();
	}

	/** */
	@Test
	public void testWinning() {
		testRound.startRound();
		MockTable oldTable = testRoundState.table;
		testTable.valid = true;
		oldTable.clonedTable = testTable;

		view.startTurnEvent.emit();
		assertFalse(view.displayStartTurnPanel);
		IHand hand = testRoundState.players.get(0).hand;
		Stone stone = hand.iterator().next().getFirst();
		hand.pickUp(stone);
		testTable.drop(new StoneSet(stone), new Position(0, 0));
		testRoundState.players.get(0).hand = new Hand();
		resetTurnStart();
		view.getPlayerPanel().endTurnEvent.emit();

		assertTrue(view.displayWinPanel);
	}

	/** */
	@Test
	public void testTableDifference() {
		MockTable oldTable = new MockTable();
		MockTable newTable = new MockTable();
		Stone blueOne = new Stone(1, BLUE);
		Stone redOne = new Stone(1, RED);
		Stone blackOne = new Stone(1, BLACK);
		Stone blueTwo = new Stone(2, BLUE);
		Stone blueThree = new Stone(3, BLUE);
		Stone blueFour = new Stone(4, BLUE);
		StoneSet oldSet1 = new StoneSet(
				Arrays.asList(blueOne, redOne, blackOne));
		StoneSet oldSet2 = new StoneSet(blueTwo);
		oldTable.drop(oldSet1, new Position(0, 0));
		oldTable.drop(oldSet2, new Position(0, 0));
		StoneSet newSet1 = new StoneSet(Arrays.asList(blueOne, blueTwo,
				blueFour));
		StoneSet newSet2 = new StoneSet(Arrays.asList(redOne, blackOne,
				blueThree));
		newTable.drop(newSet1, new Position(0, 0));
		newTable.drop(newSet2, new Position(0, 0));

		Set<Stone> expectedStones = new HashSet<Stone>();
		expectedStones.add(blueThree);
		expectedStones.add(blueFour);

		Set<Stone> stones = RoundControl.tableDifference(oldTable, newTable);

		assertTrue(expectedStones.containsAll(stones));
		assertTrue(stones.containsAll(expectedStones));
	}

	@Test
	public void testTableSetDifference() {
		ITable oldTable = new Table();
		Stone blueOne = new Stone(1, BLUE);
		Stone redOne = new Stone(1, RED);
		Stone blackOne = new Stone(1, BLACK);
		Stone orangeOne = new Stone(1, ORANGE);
		Stone blueTwo = new Stone(2, BLUE);
		Stone blueThree = new Stone(3, BLUE);
		Stone blueFour = new Stone(4, BLUE);
		StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne,
				blackOne, orangeOne));
		StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blueThree,
				blueFour));
		oldTable.drop(oldSet1, new Position(0, 0));
		oldTable.drop(oldSet2, new Position(0, 0));
		ITable newTable = (Table) oldTable.clone();
		List<StoneSet> newSets = RoundControl.tableSetDifference(oldTable,
				newTable);
		List<StoneSet> vanishedSets = RoundControl.tableSetDifference(newTable,
				oldTable);

		assertTrue(newSets.isEmpty());
		assertTrue(vanishedSets.isEmpty());

		newTable.pickUp(oldSet2);
		newTable.drop(oldSet2.join(new StoneSet(new Stone(5, BLUE))),
				new Position(0, 0));
		newSets = RoundControl.tableSetDifference(oldTable, newTable);
		vanishedSets = RoundControl.tableSetDifference(newTable, oldTable);

		assertFalse(newSets.isEmpty());
		assertFalse(vanishedSets.isEmpty());
		assertEquals(1, newSets.size());
		assertEquals(1, vanishedSets.size());

		Stone redTwo = new Stone(2, RED);
		Stone redThree = new Stone(3, RED);
		Stone redFour = new Stone(4, RED);
		StoneSet oldSet3 = new StoneSet(
				Arrays.asList(redTwo, redThree, redFour));
		ITable newTable2 = (Table) oldTable.clone();
		newTable2.drop(oldSet3, new Position(0, 0));
		newSets = RoundControl.tableSetDifference(oldTable, newTable2);
		vanishedSets = RoundControl.tableSetDifference(newTable2, oldTable);

		assertFalse(newSets.isEmpty());
		assertTrue(vanishedSets.isEmpty());
		assertEquals(1, newSets.size());
	}
}