package jrummikub.control.turn;

import static jrummikub.model.StoneColor.*;
import static org.junit.Assert.*;

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

import jrummikub.control.ITurnTimer;
import jrummikub.control.RoundControl;
import jrummikub.control.RoundControl.InvalidTurnInfo;
import jrummikub.control.turn.ITurnControl.TurnInfo;
import jrummikub.model.GameSettings;
import jrummikub.model.IHand;
import jrummikub.model.IRoundState;
import jrummikub.model.ITable;
import jrummikub.model.MockHand;
import jrummikub.model.MockPlayer;
import jrummikub.model.MockRoundState;
import jrummikub.model.MockTable;
import jrummikub.model.Position;
import jrummikub.model.Stone;
import jrummikub.model.StoneColor;
import jrummikub.model.StoneSet;
import jrummikub.model.Table;
import jrummikub.util.Event;
import jrummikub.util.IEvent;
import jrummikub.util.IListener2;
import jrummikub.util.Pair;
import jrummikub.view.IView.BottomPanelType;
import jrummikub.view.MockView;

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

/**
 * Tests for {@link HumanTurnControl}
 */
public class TurnControlTest {
	@SuppressWarnings("serial")
	static class AccessibleTable extends Table {
		StoneSet[] getSetArray() {
			return objects.keySet().toArray(new StoneSet[0]);
		}

		AccessibleTable() {
			super(new GameSettings());
		}
	}

	class MockTimer implements ITurnTimer {
		public boolean timerRunning = false;
		public Event timeRunOutEvent = new Event();

		@Override
		public void startTimer() {
			timerRunning = true;
		}

		@Override
		public void stopTimer() {
			timerRunning = false;
		}

		@Override
		public IEvent getTimeRunOutEvent() {
			return timeRunOutEvent;
		}

	}

	HumanTurnControl testControl;
	MockPlayer mockPlayer;
	MockView mockView;
	MockTimer mockTimer;
	MockTable mockTable;
	MockHand mockHand;
	private MockRoundState mockRoundState;
	boolean eventFired;
	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);
	Stone redTwo = new Stone(2, RED);
	Stone redThree = new Stone(3, RED);
	Stone redFour = new Stone(4, RED);
	Stone blackTwo = new Stone(2, BLACK);
	Stone blackThree = new Stone(3, BLACK);
	Stone blackFour = new Stone(4, BLACK);
	Stone blackFive = new Stone(5, BLACK);
	Stone redJoker = new Stone(RED);
	Stone blackJoker = new Stone(BLACK);
	Stone orange10 = new Stone(10, StoneColor.ORANGE);
	Stone blue4a = new Stone(4, StoneColor.BLUE);
	Stone orange13 = new Stone(13, StoneColor.ORANGE);
	Stone red11 = new Stone(11, StoneColor.RED);
	Stone black10 = new Stone(10, StoneColor.BLACK);
	Stone black13 = new Stone(13, StoneColor.BLACK);
	Stone orangeOne = new Stone(1, StoneColor.ORANGE);

	private void checkTableDisplay(ITable table) {
		Iterator<Pair<StoneSet, Position>> stoneSetsView = mockView.tablePanel.stoneSets
				.iterator();
		Iterator<Pair<StoneSet, Position>> stoneSetsModel = table.iterator();

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

	private void checkHandDisplay(IHand hand) {
		Iterator<Pair<Stone, Position>> stoneSetsView = mockView.handPanel.stones
				.iterator();
		Iterator<Pair<Stone, Position>> stoneSetsModel = hand.iterator();

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

	/** */
	@Before
	public void setUp() {
		mockView = new MockView();
		mockRoundState = new MockRoundState();
		mockTimer = new MockTimer();
		mockTable = new MockTable();

		mockRoundState.table = mockTable;
		mockHand = new MockHand();
		mockRoundState.players.get(0).hand = mockHand;
		mockPlayer = new MockPlayer(null, null);
		mockPlayer.hand = mockHand;
		testControl = new HumanTurnControl(mockTimer);
		testControl.setup(new ITurnControl.TurnInfo(mockRoundState,
				TurnMode.NORMAL_TURN, false), new GameSettings(), mockView);
	}

	/** */
	@Test
	public void startTimer() {
		testControl.startTurn();

		assertTrue(mockTimer.timerRunning);
	}

	/** */
	@SuppressWarnings("unchecked")
	@Test
	public void showInitialHand() {
		mockRoundState.turnNumber = -1;
		mockView.bottomPanelType = BottomPanelType.START_TURN_PANEL;

		List<Pair<Stone, Position>> stones = Arrays.asList(
				new Pair<Stone, Position>(redJoker, new Position(0, 0)),
				new Pair<Stone, Position>(blackJoker, new Position(1, 0)));

		mockHand.iterable = stones;
		mockRoundState.players.get(0).hand = mockHand;

		testControl = new HumanTurnControl(mockTimer);
		testControl.setup(new ITurnControl.TurnInfo(mockRoundState,
				TurnMode.INSPECT_ONLY, false), new GameSettings(), mockView);
		testControl.startTurn();
		mockView.startTurnEvent.emit();

		int i = 0;
		for (Pair<Stone, Position> pair : mockView.handPanel.stones) {
			assertSame(stones.get(i), pair);
			i++;
		}
		assertEquals(stones.size(), i);

		assertSame(BottomPanelType.HUMAN_HAND_PANEL, mockView.bottomPanelType);
	}

	/** */
	@Test
	public void viewEndOfTurn() {
		testControl.startTurn();

		eventFired = false;
		mockTimer.timerRunning = true;

		testControl.getEndOfTurnEvent().add(
				new IListener2<IRoundState, RoundControl.InvalidTurnInfo>() {
					@Override
					public void handle(IRoundState roundState,
							RoundControl.InvalidTurnInfo invalidTurnInfo) {
						eventFired = true;
					}
				});

		mockView.playerPanel.endTurnEvent.emit();

		assertTrue(eventFired);
		assertFalse(mockTimer.timerRunning);
		assertTrue(mockView.playerPanel.endTurnEvent.listeners.isEmpty());
	}

	/** */
	@Test
	public void timerEndOfTurn() {
		testControl.startTurn();

		eventFired = false;
		mockTimer.timerRunning = true;

		testControl.getEndOfTurnEvent().add(
				new IListener2<IRoundState, RoundControl.InvalidTurnInfo>() {
					@Override
					public void handle(IRoundState value1,
							InvalidTurnInfo value2) {
						eventFired = true;
					}
				});

		mockTimer.timeRunOutEvent.emit();

		assertTrue(eventFired);
		assertFalse(mockTimer.timerRunning);
	}

	/** */
	@Test
	public void deselctOnEndOfTurn() {
		testControl.startTurn();

		Stone firstStone = new Stone(StoneColor.RED);

		// Select first stone
		mockView.handPanel.stoneClickEvent.emit(firstStone, false);
		mockTimer.timeRunOutEvent.emit();

		assertCollection(new ArrayList<Stone>());
	}

	/** */
	@Test
	public void selectStoneInHand() {
		testControl.startTurn();

		// Select first stone
		mockView.handPanel.stoneClickEvent.emit(redJoker, false);

		assertCollection(Arrays.asList(redJoker));

		// Select second stone
		mockView.handPanel.stoneClickEvent.emit(blackJoker, false);

		assertCollection(Arrays.asList(blackJoker));
	}

	/** */
	@Test
	public void collectStoneInHand() {
		testControl.startTurn();

		// Select first stone
		mockView.handPanel.stoneClickEvent.emit(redJoker, true);

		assertCollection(Arrays.asList(redJoker));

		// Select second stone
		mockView.handPanel.stoneClickEvent.emit(blackJoker, true);

		assertCollection(Arrays.asList(redJoker, blackJoker));

		// De-select first stone
		mockView.handPanel.stoneClickEvent.emit(redJoker, true);

		assertCollection(Arrays.asList(blackJoker));
	}

	/** */
	@Test
	public void deselectStoneInCollection() {
		testControl.startTurn();

		mockView.handPanel.stoneClickEvent.emit(redJoker, true);
		mockView.handPanel.stoneClickEvent.emit(blackJoker, true);

		mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(redJoker,
				false);

		assertCollection(Arrays.asList(blackJoker));
	}

	/** */
	@Test
	public void reorderCollection() {
		testControl.startTurn();

		mockView.handPanel.stoneClickEvent.emit(redJoker, true);
		mockView.handPanel.stoneClickEvent.emit(blackJoker, true);

		mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(
				blackJoker, true);

		assertCollection(Arrays.asList(redJoker, blackJoker));
	}

	/** */
	@Test
	public void deselectWholeCollection() {
		testControl.startTurn();

		mockView.handPanel.stoneClickEvent.emit(redJoker, true);
		mockView.handPanel.stoneClickEvent.emit(blackJoker, true);

		mockView.tablePanel.stoneCollectionPanel.stoneClickEvent.emit(redJoker,
				true);

		mockView.tablePanel.stoneCollectionPanel.setClickEvent.emit(redJoker,
				true);

		assertCollection(new ArrayList<Stone>());
	}

	/** */
	@Test
	public void selectStoneOnTable() {
		testControl.startTurn();

		// Select first stone
		mockView.tablePanel.stoneClickEvent.emit(redJoker, false);
		assertCollection(Arrays.asList(redJoker));

		// Select second stone
		mockView.tablePanel.stoneClickEvent.emit(blackJoker, false);
		assertCollection(Arrays.asList(blackJoker));
	}

	/** */
	@Test
	public void collectStoneOnTable() {
		testControl.startTurn();

		// Select first stone
		mockView.tablePanel.stoneClickEvent.emit(redJoker, true);
		assertCollection(Arrays.asList(redJoker));

		// Select second stone
		mockView.tablePanel.stoneClickEvent.emit(blackJoker, true);
		assertCollection(Arrays.asList(redJoker, blackJoker));

		// De-select first stone
		mockView.tablePanel.stoneClickEvent.emit(redJoker, true);
		assertCollection(Arrays.asList(blackJoker));
	}

	/** */
	@Test
	public void selectSetOnTable() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redJoker, blackJoker));
		StoneSet set2 = new StoneSet(Arrays.asList(redOne, blackOne));

		mockTable.findStoneSet.put(redJoker, set1);
		mockTable.findStoneSet.put(blackOne, set2);

		mockView.tablePanel.stoneClickEvent.emit(redJoker, false);
		mockView.tablePanel.setClickEvent.emit(redJoker, false);
		assertCollection(Arrays.asList(redJoker, blackJoker));
		mockView.tablePanel.stoneClickEvent.emit(blackOne, false);
		mockView.tablePanel.setClickEvent.emit(blackOne, false);
		assertCollection(Arrays.asList(redOne, blackOne));
	}

	/** */
	@Test
	public void collectSetOnTable() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redJoker, blackJoker));
		StoneSet set2 = new StoneSet(Arrays.asList(redOne, blackOne));

		mockTable.findStoneSet.put(redJoker, set1);
		mockTable.findStoneSet.put(blackOne, set2);

		mockView.tablePanel.stoneClickEvent.emit(redJoker, true);
		mockView.tablePanel.setClickEvent.emit(redJoker, true);
		assertCollection(Arrays.asList(redJoker, blackJoker));
		mockView.tablePanel.stoneClickEvent.emit(blackOne, true);
		mockView.tablePanel.setClickEvent.emit(blackOne, true);
		assertCollection(Arrays.asList(redJoker, blackJoker, redOne, blackOne));
	}

	/** */
	@Test
	public void rangeSelectOnTableReverse() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redOne, redTwo, redThree,
				redFour));

		mockTable.findStoneSet.put(redOne, set1);
		mockTable.findStoneSet.put(redThree, set1);

		mockView.tablePanel.stoneClickEvent.emit(redThree, false);
		mockView.tablePanel.rangeClickEvent.emit(redOne, true);

		assertCollection(Arrays.asList(redOne, redTwo, redThree));
	}

	/** */
	@Test
	public void rangeSelectOnTable() {
		testControl.startTurn();

		Stone stone4 = new Stone(4, StoneColor.RED);
		StoneSet set1 = new StoneSet(Arrays.asList(redOne, redTwo, redThree,
				stone4));

		mockTable.findStoneSet.put(redOne, set1);
		mockTable.findStoneSet.put(redThree, set1);

		mockView.tablePanel.stoneClickEvent.emit(redOne, false);
		mockView.tablePanel.rangeClickEvent.emit(redThree, true);

		assertCollection(Arrays.asList(redOne, redTwo, redThree));
	}

	/** */
	@Test
	public void rangeCollectOnTable() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redOne, redTwo, redThree,
				redFour));

		mockTable.findStoneSet.put(redOne, set1);
		mockTable.findStoneSet.put(redThree, set1);

		mockView.tablePanel.stoneClickEvent.emit(redJoker, false);

		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.rangeClickEvent.emit(redThree, false);

		assertCollection(Arrays.asList(redJoker, redOne, redTwo, redThree));
	}

	/** */
	@Test
	public void rangeFailSelect() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redOne));
		StoneSet set2 = new StoneSet(Arrays.asList(redTwo));

		mockTable.findStoneSet.put(redOne, set1);
		mockTable.findStoneSet.put(redTwo, set2);

		// Select first stone
		mockView.tablePanel.stoneClickEvent.emit(redOne, false);
		assertCollection(Arrays.asList(redOne));

		// Select second stone
		mockView.tablePanel.rangeClickEvent.emit(redTwo, false);
		assertCollection(Arrays.asList(redOne, redTwo));
	}

	/** */
	@Test
	public void rangeFailCollect() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redOne));
		StoneSet set2 = new StoneSet(Arrays.asList(redTwo));

		mockTable.findStoneSet.put(redOne, set1);
		mockTable.findStoneSet.put(redTwo, set2);

		// Select first stone
		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		assertCollection(Arrays.asList(redOne));

		// Select second stone
		mockView.tablePanel.rangeClickEvent.emit(redTwo, true);
		assertCollection(Arrays.asList(redOne, redTwo));
	}

	/** */
	@Test
	public void rangeSelectOnHandReverse() {
		testControl.startTurn();

		mockHand.drop(redOne, new Position(0, 0));
		mockHand.drop(redTwo, new Position(1.5f, 0));
		mockHand.drop(redThree, new Position(0, 1));
		mockHand.drop(redFour, new Position(1, 1));

		mockView.handPanel.stoneClickEvent.emit(redThree, false);
		mockView.handPanel.rangeClickEvent.emit(redOne, true);

		assertCollection(Arrays.asList(redOne, redTwo, redThree));
	}

	/** */
	@Test
	public void rangeSelectOnHand() {
		testControl.startTurn();

		mockHand.drop(redOne, new Position(0, 0));
		mockHand.drop(redTwo, new Position(1.5f, 0));
		mockHand.drop(redThree, new Position(0, 1));
		mockHand.drop(redFour, new Position(1, 1));

		mockView.handPanel.stoneClickEvent.emit(redOne, false);
		mockView.handPanel.rangeClickEvent.emit(redThree, true);

		assertCollection(Arrays.asList(redOne, redTwo, redThree));
	}

	/** */
	@Test
	public void rangeCollectOnHand() {
		testControl.startTurn();

		mockHand.drop(redOne, new Position(0, 0));
		mockHand.drop(redTwo, new Position(1.5f, 0));
		mockHand.drop(redThree, new Position(0, 1));
		mockHand.drop(redFour, new Position(1, 1));

		mockView.handPanel.stoneClickEvent.emit(redJoker, false);

		mockView.handPanel.stoneClickEvent.emit(redOne, true);
		mockView.handPanel.rangeClickEvent.emit(redThree, false);
		assertCollection(Arrays.asList(redJoker, redOne, redTwo, redThree));
	}

	/** */
	@Test
	public void rangeFailSelectHand() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redOne));
		mockTable.findStoneSet.put(redOne, set1);
		mockHand.drop(redTwo, new Position(0, 0));
		// Select first stone
		mockView.tablePanel.stoneClickEvent.emit(redOne, false);

		assertCollection(Arrays.asList(redOne));

		// Select second stone
		mockView.handPanel.rangeClickEvent.emit(redTwo, false);

		assertCollection(Arrays.asList(redOne, redTwo));
	}

	/** */
	@Test
	public void rangeFailCollectHand() {
		testControl.startTurn();

		StoneSet set1 = new StoneSet(Arrays.asList(redOne));
		mockTable.findStoneSet.put(redOne, set1);
		mockHand.drop(redTwo, new Position(0, 0));
		// Select first stone
		mockView.tablePanel.stoneClickEvent.emit(redOne, false);
		assertCollection(Arrays.asList(redOne));

		// Select second stone
		mockView.handPanel.rangeClickEvent.emit(redTwo, true);
		assertCollection(Arrays.asList(redOne, redTwo));
	}

	private void assertCollection(List<Stone> expected) {
		ArrayList<Stone> selectedStones = new ArrayList<Stone>(
				mockView.selectedStones);
		ArrayList<Stone> expectedStones = new ArrayList<Stone>(expected);
		assertEquals(expectedStones, selectedStones);
	}

	/** */
	@Test
	public void testAddLeft() {
		AccessibleTable table = new AccessibleTable();
		HumanTurnControl turnControl = new HumanTurnControl(mockTimer);
		mockTable.clonedTable = table;

		mockHand.drop(blueThree, new Position(0, 0));
		mockHand.drop(blueFour, new Position(0, 0));
		StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne,
				blackOne, redTwo, redThree, redFour, blackTwo, blackThree));
		StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blackFour,
				blackFive));
		table.drop(oldSet1, new Position(0, 0));
		table.drop(oldSet2, new Position(0, 0));

		turnControl.setup(new ITurnControl.TurnInfo(mockRoundState,
				TurnMode.NORMAL_TURN, false), new GameSettings(), mockView);
		turnControl.startTurn();

		mockView.handPanel.stoneClickEvent.emit(blueThree, false);
		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.stoneClickEvent.emit(redThree, true);
		mockView.tablePanel.leftConnectorClickEvent.emit(oldSet1);

		// handcheck
		assertEquals(1, mockHand.getSize());
		assertSame(mockHand.stones.get(0).getFirst(), blueFour);
		// tablecheck
		assertEquals(2, table.getSize());
		Pair<StoneSet, StoneSet> newSets = assignNewSets(table, 3);
		assertSame(oldSet2, newSets.getSecond());
		// setcheck
		assertEquals(9, newSets.getFirst().getSize());
		assertions(newSets.getFirst(), Arrays.asList(blueThree, redOne,
				redThree, blueOne, blackOne, redTwo, redFour, blackTwo,
				blackThree));

		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.stoneClickEvent.emit(redThree, true);
		mockView.tablePanel.leftConnectorClickEvent.emit(oldSet2);
		// handcheck
		assertEquals(1, mockHand.getSize());
		assertSame(mockHand.stones.get(0).getFirst(), blueFour);
		// tablecheck
		assertEquals(2, table.getSize());
		newSets = assignNewSets(table, 5);
		// setcheck1
		assertEquals(7, newSets.getFirst().getSize());
		assertions(newSets.getFirst(), Arrays.asList(blueThree, blueOne,
				blackOne, redTwo, redFour, blackTwo, blackThree));
		// setcheck2
		assertEquals(5, newSets.getSecond().getSize());
		assertions(newSets.getSecond(),
				Arrays.asList(redOne, redThree, blueTwo, blackFour, blackFive));
		// versuche, links was wegzunehmen und wieder anzuhängen
		mockView.handPanel.stoneClickEvent.emit(blueFour, false);
		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.leftConnectorClickEvent.emit(newSets.getSecond());

		// handcheck
		assertEquals(0, mockHand.getSize());
		// tablecheck
		assertEquals(2, table.getSize());
		newSets = assignNewSets(table, 6);
		// setcheck1
		assertEquals(7, newSets.getFirst().getSize());
		// setcheck2
		assertEquals(6, newSets.getSecond().getSize());
		assertions(newSets.getSecond(), Arrays.asList(blueFour, redOne,
				redThree, blueTwo, blackFour, blackFive));
	}

	private Pair<StoneSet, StoneSet> assignNewSets(AccessibleTable table, int i) {
		StoneSet set1, set2;
		if (table.getSetArray()[0].getSize() == i) {
			set2 = table.getSetArray()[0];
			set1 = table.getSetArray()[1];
		} else {
			set1 = table.getSetArray()[0];
			set2 = table.getSetArray()[1];
		}
		return new Pair<StoneSet, StoneSet>(set1, set2);
	}

	private void assertions(StoneSet set, List<Stone> stones) {
		for (int i = 0; i < stones.size(); i++) {
			assertSame(set.get(i), stones.get(i));
		}
	}

	/** */
	@Test
	public void testAddRight() {
		AccessibleTable table = new AccessibleTable();
		mockTable.clonedTable = table;
		HumanTurnControl turnControl = new HumanTurnControl(mockTimer);

		StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne,
				blackOne, redTwo, redThree, redFour, blackTwo, blackThree));
		StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blackFour,
				blackFive));
		table.drop(oldSet1, new Position(0, 0));
		table.drop(oldSet2, new Position(0, 0));
		mockHand.drop(blueThree, new Position(0, 0));
		mockHand.drop(blueFour, new Position(0, 0));

		turnControl.setup(new TurnInfo(mockRoundState, TurnMode.NORMAL_TURN,
				false), new GameSettings(), mockView);
		turnControl.startTurn();

		mockView.handPanel.stoneClickEvent.emit(blueThree, false);
		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.stoneClickEvent.emit(redThree, true);
		mockView.tablePanel.rightConnectorClickEvent.emit(oldSet1);
		// handcheck
		assertEquals(1, mockHand.getSize());
		assertSame(mockHand.stones.get(0).getFirst(), blueFour);
		// tablecheck
		assertEquals(2, table.getSize());
		
		Pair <StoneSet, StoneSet> newSets = assignNewSets(table, 3);
		assertSame(oldSet2, newSets.getSecond());
		// setcheck
		assertEquals(9, newSets.getFirst().getSize());
		assertions(newSets.getFirst(), Arrays.asList(blueOne, blackOne, redTwo, redFour,
				blackTwo, blackThree, blueThree, redOne, redThree));

		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.stoneClickEvent.emit(redThree, true);
		mockView.tablePanel.rightConnectorClickEvent.emit(oldSet2);
		// handcheck
		assertEquals(1, mockHand.getSize());
		assertSame(mockHand.stones.get(0).getFirst(), blueFour);
		// tablecheck
		assertEquals(2, table.getSize());
		newSets = assignNewSets(table, 5);
		// setcheck1
		assertEquals(7, newSets.getFirst().getSize());
		assertions(newSets.getFirst(), Arrays.asList(blueOne, blackOne, redTwo, redFour,
				blackTwo, blackThree, blueThree));
		// setcheck2
		assertEquals(5, newSets.getSecond().getSize());
		assertions(newSets.getSecond(),
				Arrays.asList(blueTwo, blackFour, blackFive, redOne, redThree));
		// versuche, rechts was wegzunehmen und wieder anzuhängen
		mockView.handPanel.stoneClickEvent.emit(blueFour, false);
		mockView.tablePanel.stoneClickEvent.emit(redThree, true);
		mockView.tablePanel.rightConnectorClickEvent.emit(newSets.getSecond());

		// handcheck
		assertEquals(0, mockHand.getSize());
		// tablecheck
		assertEquals(2, table.getSize());
		newSets = assignNewSets(table, 6);
		// setcheck1
		assertEquals(7, newSets.getFirst().getSize());
		// setcheck2
		assertEquals(6, newSets.getSecond().getSize());
		assertions(newSets.getSecond(), Arrays.asList(blueTwo, blackFour, blackFive,
				redOne, blueFour, redThree));
	}

	/** */
	@Test
	public void testAddNewSet() {
		AccessibleTable table = new AccessibleTable();
		mockTable.clonedTable = table;
		StoneSet oldSet1 = new StoneSet(Arrays.asList(blueOne, redOne,
				blackOne, redTwo, redThree, redFour, blackTwo, blackThree));
		StoneSet oldSet2 = new StoneSet(Arrays.asList(blueTwo, blackFour,
				blackFive));
		table.drop(oldSet1, new Position(0, 0));
		table.drop(oldSet2, new Position(0, 0));
		mockHand.drop(blueThree, new Position(0, 0));
		mockHand.drop(blueFour, new Position(0, 0));

		HumanTurnControl turnControl = new HumanTurnControl(mockTimer);
		turnControl.setup(new TurnInfo(mockRoundState, TurnMode.NORMAL_TURN,
				false), new GameSettings(), mockView);
		turnControl.startTurn();
		mockView.handPanel.stoneClickEvent.emit(blueThree, false);
		mockView.tablePanel.stoneClickEvent.emit(redOne, true);
		mockView.tablePanel.stoneClickEvent.emit(redThree, true);
		mockView.tablePanel.stoneClickEvent.emit(blueTwo, true);
		mockView.tablePanel.clickEvent.emit(new Position(0, 0));

		// handcheck
		assertEquals(1, mockHand.getSize());
		assertSame(blueFour, mockHand.stones.get(0).getFirst());
		// tablecheck
		StoneSet newSet1, newSet2, newSet3;
		assertEquals(3, table.getSize());
		if (table.getSetArray()[0].getSize() == 2) {
			newSet2 = table.getSetArray()[0];
			if (table.getSetArray()[1].getSize() == 4) {
				newSet3 = table.getSetArray()[1];
				newSet1 = table.getSetArray()[2];
			} else {
				newSet3 = table.getSetArray()[2];
				newSet1 = table.getSetArray()[1];
			}
		} else if (table.getSetArray()[0].getSize() == 4) {
			newSet3 = table.getSetArray()[0];
			if (table.getSetArray()[1].getSize() == 2) {
				newSet2 = table.getSetArray()[1];
				newSet1 = table.getSetArray()[2];
			} else {
				newSet2 = table.getSetArray()[2];
				newSet1 = table.getSetArray()[1];
			}
		} else {
			newSet1 = table.getSetArray()[0];
			if (table.getSetArray()[1].getSize() == 2) {
				newSet2 = table.getSetArray()[1];
				newSet3 = table.getSetArray()[2];
			} else {
				newSet2 = table.getSetArray()[2];
				newSet3 = table.getSetArray()[1];
			}
		}

		// setcheck1
		assertEquals(6, newSet1.getSize());
		assertions(newSet1, Arrays.asList(blueOne, blackOne, redTwo, redFour,
				blackTwo, blackThree));
		// setcheck2
		assertEquals(2, newSet2.getSize());
		assertions(newSet2, Arrays.asList(blackFour, blackFive));
		// setcheck1
		assertEquals(4, newSet3.getSize());
		assertions(newSet3, Arrays.asList(blueThree, redOne, redThree, blueTwo));

		checkTableDisplay(table);
		checkHandDisplay(mockHand);
	}

	/** */
	@Test
	public void testSortByGroups() {
		testControl.startTurn();

		mockHand.drop(redOne, new Position(0, 0));
		mockHand.drop(blueTwo, new Position(0, 0));
		mockHand.drop(redFour, new Position(0, 0));
		mockHand.drop(redThree, new Position(0, 0));
		mockHand.drop(orange10, new Position(0, 0));
		mockHand.drop(blueOne, new Position(0, 0));
		mockHand.drop(blueFour, new Position(0, 0));
		mockHand.drop(blue4a, new Position(0, 0));
		mockHand.drop(blackJoker, new Position(0, 0));
		mockHand.drop(blackFive, new Position(0, 0));
		mockHand.drop(orange13, new Position(0, 0));
		mockHand.drop(red11, new Position(0, 0));
		mockHand.drop(black10, new Position(0, 0));

		mockView.playerPanel.sortByGroupsEvent.emit();

		List<Pair<Stone, Position>> stones = new ArrayList<Pair<Stone, Position>>(
				mockHand.stones);
		Collections.sort(stones,
				new HumanTurnControl.HandStonePositionComparator());

		assertEquals(stones.size(), 13);

		assertSame(stones.get(0).getFirst(), blueOne);
		assertSame(stones.get(1).getFirst(), redOne);
		assertSame(stones.get(2).getFirst(), blueTwo);
		assertSame(stones.get(3).getFirst(), redThree);

		assertTrue(stones.get(4).getFirst() == blueFour
				|| stones.get(4).getFirst() == blue4a);
		assertTrue(stones.get(5).getFirst() == blueFour
				|| stones.get(5).getFirst() == blue4a);

		assertSame(stones.get(6).getFirst(), redFour);
		assertSame(stones.get(7).getFirst(), blackFive);
		assertSame(stones.get(8).getFirst(), black10);
		assertSame(stones.get(9).getFirst(), orange10);
		assertSame(stones.get(10).getFirst(), red11);
		assertSame(stones.get(11).getFirst(), orange13);
		assertSame(stones.get(12).getFirst(), blackJoker);

		checkHandDisplay(mockHand);
	}

	/** */
	@Test
	public void testSortByRuns() {
		testControl.startTurn();

		mockHand.drop(redOne, new Position(0, 0));
		mockHand.drop(blueTwo, new Position(0, 0));
		mockHand.drop(redFour, new Position(0, 0));
		mockHand.drop(redThree, new Position(0, 0));
		mockHand.drop(orange10, new Position(0, 0));
		mockHand.drop(blueOne, new Position(0, 0));
		mockHand.drop(blueFour, new Position(0, 0));
		mockHand.drop(blue4a, new Position(0, 0));
		mockHand.drop(blackJoker, new Position(0, 0));
		mockHand.drop(blackFive, new Position(0, 0));
		mockHand.drop(orange13, new Position(0, 0));
		mockHand.drop(red11, new Position(0, 0));
		mockHand.drop(black10, new Position(0, 0));

		mockView.playerPanel.sortByRunsEvent.emit();

		List<Pair<Stone, Position>> stones = new ArrayList<Pair<Stone, Position>>(
				mockHand.stones);
		Collections.sort(stones,
				new HumanTurnControl.HandStonePositionComparator());

		assertEquals(stones.size(), 13);

		assertSame(stones.get(0).getFirst(), blackFive);
		assertSame(stones.get(1).getFirst(), black10);
		assertSame(stones.get(2).getFirst(), orange10);
		assertSame(stones.get(3).getFirst(), orange13);
		assertSame(stones.get(4).getFirst(), blueOne);
		assertSame(stones.get(5).getFirst(), blueTwo);

		assertTrue(stones.get(6).getFirst() == blueFour
				|| stones.get(6).getFirst() == blue4a);
		assertTrue(stones.get(7).getFirst() == blueFour
				|| stones.get(7).getFirst() == blue4a);

		assertSame(stones.get(8).getFirst(), redOne);
		assertSame(stones.get(9).getFirst(), redThree);
		assertSame(stones.get(10).getFirst(), redFour);
		assertSame(stones.get(11).getFirst(), red11);
		assertSame(stones.get(12).getFirst(), blackJoker);

		checkHandDisplay(mockHand);
	}

	/** */
	@Test
	public void testDropHandValid() {
		testControl.startTurn();

		mockHand.drop(redJoker, new Position(0, 0));
		mockHand.drop(blackJoker, new Position(1, 0));

		mockView.handPanel.stoneClickEvent.emit(redJoker, true);
		mockView.handPanel.stoneClickEvent.emit(blackJoker, true);

		mockView.handPanel.clickEvent.emit(new Position(2, 0.25f));

		assertCollection(new ArrayList<Stone>());

		Set<Stone> expected = new HashSet<Stone>(Arrays.asList(redJoker,
				blackJoker));
		assertEquals(expected, mockHand.pickups);

		Set<Stone> handStones = new HashSet<Stone>();
		for (Pair<Stone, Position> stone : mockHand.stones) {
			assertEquals(stone.getSecond().getY(), 0, 0.0001);
			handStones.add(stone.getFirst());
		}
		assertEquals(expected, handStones);
	}

	/** */
	@Test
	public void testDropHandInvalid() {
		testControl.startTurn();

		mockHand.drop(redJoker, new Position(0, 0));
		mockHand.drop(black13, new Position(1, 0));

		mockView.handPanel.stoneClickEvent.emit(redJoker, true);
		mockView.tablePanel.stoneClickEvent.emit(blackJoker, true);
		mockView.handPanel.stoneClickEvent.emit(black13, true);

		mockView.handPanel.clickEvent.emit(new Position(2, 0.25f));

		assertCollection(Arrays.asList(blackJoker));

		Set<Stone> expected = new HashSet<Stone>(Arrays.asList(redJoker,
				black13));
		assertEquals(expected, mockHand.pickups);

		Set<Stone> handStones = new HashSet<Stone>();
		for (Pair<Stone, Position> stone : mockHand.stones) {
			assertEquals(stone.getSecond().getY(), 0, 0.0001);
			handStones.add(stone.getFirst());
		}
		assertEquals(expected, handStones);
	}

	/** */
	@Test
	public void testTableDifference() {
		MockTable oldTable = new MockTable();
		MockTable newTable = new MockTable();
		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 = AbstractTurnControl.tableDifference(oldTable,
				newTable);

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

	/** */
	@Test
	public void testTableSetDifference() {
		ITable oldTable = new AccessibleTable();
		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 = AbstractTurnControl.tableSetDifference(
				oldTable, newTable);
		List<StoneSet> vanishedSets = AbstractTurnControl.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 = AbstractTurnControl.tableSetDifference(oldTable, newTable);
		vanishedSets = AbstractTurnControl.tableSetDifference(newTable,
				oldTable);

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

		StoneSet oldSet3 = new StoneSet(
				Arrays.asList(redTwo, redThree, redFour));
		ITable newTable2 = (Table) oldTable.clone();
		newTable2.drop(oldSet3, new Position(0, 0));
		newSets = AbstractTurnControl.tableSetDifference(oldTable, newTable2);
		vanishedSets = AbstractTurnControl.tableSetDifference(newTable2,
				oldTable);

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

}
