package geniusweb.protocol.session.learn;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.List;

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

import geniusweb.actions.EndNegotiation;
import geniusweb.actions.LearningDone;
import geniusweb.actions.PartyId;
import geniusweb.deadline.Deadline;
import geniusweb.deadline.DeadlineTime;
import geniusweb.inform.Finished;
import geniusweb.protocol.partyconnection.ProtocolToPartyConn;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.protocol.session.TeamInfo;
import geniusweb.references.Parameters;
import geniusweb.references.PartyRef;
import geniusweb.references.PartyWithParameters;
import geniusweb.references.PartyWithProfile;
import geniusweb.references.ProfileRef;
import tudelft.utilities.logging.Reporter;
import tudelft.utilities.repository.NoResourcesNowException;

public class LearnTest {

	private final Reporter reporter = mock(Reporter.class);
	private Parameters params = new Parameters();
	private Deadline deadline = new DeadlineTime(1800);
	private PartyId party1id = new PartyId("party1");;
	private PartyId party2id = new PartyId("party2");;
	private final ProtocolToPartyConn conn1 = mock(ProtocolToPartyConn.class),
			conn2 = mock(ProtocolToPartyConn.class);

	@Before
	public void before() {
		params = params.with("persistentstate",
				"6bb5f909-0079-43ac-a8ac-a31794391074");
		params = params.with("negotiationdata",
				Arrays.asList("12b5f909-0079-43ac-a8ac-a31794391012"));

	}

	@SuppressWarnings("unused")
	@Test
	public void smokeTest() {
		new Learn(mock(LearnState.class), mock(Reporter.class));
	}

	@Test
	public void getDescrTest() {
		Learn l = new Learn(mock(LearnState.class), mock(Reporter.class));

		assertNotNull(l.getDescription());
	}

	@Test
	public void getStateTest() {
		LearnState state = mock(LearnState.class);
		Learn l = new Learn(state, mock(Reporter.class));
		assertEquals(state, l.getState());
	}

	@Test
	public void getRefTest() {
		Learn l = new Learn(mock(LearnState.class), mock(Reporter.class));
		assertEquals("Learn", l.getRef().getURI().getPath().toString());
	}

	@Test
	public void finalStateNotificationTest() {
		// check that listeners get notified when session ends.

	}

	@Test
	public void testStartStopBasic() throws IOException,
			NoResourcesNowException, InterruptedException, URISyntaxException {
		Learn learn = createBasicLearn();
		ProtocolToPartyConnFactory factory = createFactory();
		learn.start(factory);
		assertFalse(learn.getState().isFinal(System.currentTimeMillis()));
		Thread.sleep(2000);
		assertTrue(learn.getState().isFinal(System.currentTimeMillis()));
	}

	@Test
	public void testStartStopLearn() throws IOException,
			NoResourcesNowException, InterruptedException, URISyntaxException {
		Learn learn = createBasicLearn();
		ProtocolToPartyConnFactory factory = createFactory();
		learn.start(factory);
		assertFalse(learn.getState().isFinal(System.currentTimeMillis()));

		// Instead of mocking connectin we call actionRequest directly
		learn.actionRequest(conn1, new LearningDone(party1id));
		assertFalse(learn.getState().isFinal(System.currentTimeMillis()));
		learn.actionRequest(conn2, new LearningDone(party2id));
		assertTrue(learn.getState().isFinal(System.currentTimeMillis()));
	}

	@Test(expected = IllegalStateException.class)
	public void testAddParty() {
		Learn l = new Learn(mock(LearnState.class), mock(Reporter.class));
		l.addParticipant(mock(PartyWithProfile.class));
	}

	@Test
	public void isFinishSentNormally()
			throws URISyntaxException, IOException, NoResourcesNowException {
		Learn learn = createBasicLearn();
		ProtocolToPartyConnFactory factory = createFactory();
		learn.start(factory);
		learn.actionRequest(conn1, new LearningDone(party1id));
		learn.actionRequest(conn2, new LearningDone(party2id));
		verify(conn1, times(1)).send(isA(Finished.class));
		verify(conn2, times(1)).send(isA(Finished.class));
	}

	@Test
	public void isFinishSentInError()
			throws URISyntaxException, IOException, NoResourcesNowException {
		Learn learn = createBasicLearn();
		ProtocolToPartyConnFactory factory = createFactory();
		learn.start(factory);
		learn.actionRequest(conn1, new EndNegotiation(party1id));
		verify(conn1, times(1)).send(isA(Finished.class));
		verify(conn2, times(1)).send(isA(Finished.class));
	}

	private Learn createBasicLearn() throws URISyntaxException {
		TeamInfo team1 = createTeam(1);
		TeamInfo team2 = createTeam(2);
		LearnSettings settings = new LearnSettings(Arrays.asList(team1, team2),
				deadline);
		return (Learn) settings.getProtocol(reporter);

	}

	private TeamInfo createTeam(int nr) throws URISyntaxException {
		PartyRef party1ref = new PartyRef("party" + nr);
		PartyWithParameters party1 = new PartyWithParameters(party1ref, params);
		ProfileRef profile1 = new ProfileRef("prof" + nr);
		PartyWithProfile partywithp1 = new PartyWithProfile(party1, profile1);
		List<PartyWithProfile> team1pp = Arrays.asList(partywithp1);
		TeamInfo team = new TeamInfo(team1pp);
		return team;
	}

	private ProtocolToPartyConnFactory createFactory()
			throws IOException, NoResourcesNowException {
		when(conn1.getParty()).thenReturn(party1id);
		when(conn2.getParty()).thenReturn(party2id);

		ProtocolToPartyConnFactory factory = mock(
				ProtocolToPartyConnFactory.class);
		// connections = mock(List.class);
		List<ProtocolToPartyConn> connections = Arrays.asList(conn1, conn2);
		when(factory.connect(any(List.class))).thenReturn(connections);
		return factory;
	}

}