package geniusweb.protocol.tournament.allpermutations;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyLong;
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.math.BigInteger;
import java.util.LinkedList;
import java.util.List;

import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;

import geniusweb.events.ProtocolEvent;
import geniusweb.issuevalue.Bid;
import geniusweb.protocol.CurrentNegoState;
import geniusweb.protocol.NegoState;
import geniusweb.protocol.partyconnection.ProtocolToPartyConnFactory;
import geniusweb.protocol.session.SessionProtocol;
import geniusweb.protocol.session.SessionResult;
import geniusweb.protocol.session.SessionSettings;
import geniusweb.protocol.session.SessionState;
import geniusweb.references.PartyWithProfile;
import geniusweb.references.ProtocolRef;
import tudelft.utilities.listener.Listener;
import tudelft.utilities.logging.ReportToLogger;

public class AllPermutationsProtocolTest {

	private final AllPermutationsState state = mock(AllPermutationsState.class),
			newstate = mock(AllPermutationsState.class);
	private final ReportToLogger log = new ReportToLogger("test");
	private final AllPermutationsProtocol app = new AllPermutationsProtocol(
			state, log);
	private final ProtocolToPartyConnFactory factory = mock(
			ProtocolToPartyConnFactory.class);
	private final SessionSettings settings = mock(SessionSettings.class);
	private final SessionState finalsessionstate = mock(SessionState.class);
	private Bid agreement = mock(Bid.class);
	private final long NOW = 1000;
	private SessionResult finalstate = mock(SessionResult.class);

	@Before
	public void before() {
		when(state.getSize()).thenReturn(BigInteger.ZERO);
		when(finalsessionstate.isFinal(anyLong())).thenReturn(true);
		when(finalsessionstate.getSettings()).thenReturn(settings);
		when(finalsessionstate.getAgreement()).thenReturn(agreement);
		when(finalsessionstate.getResult()).thenReturn(finalstate);
		when(finalstate.getAgreement()).thenReturn(agreement);
		when(state.with(any())).thenReturn(newstate);
	}

	@Test
	public void smokeTest() {
	}

	@Test
	public void startTestNoSessions() {
		AllPermutationsProtocol app = new AllPermutationsProtocol(state, log);
		app.start(factory);

	}

	@Test
	public void getDescrTest() {
		assertNotNull(app.getDescription());
	}

	@Test
	public void getStateTest() {
		assertEquals(state, app.getState());
	}

	@Test
	public void getRefTest() {
		assertEquals("APP", app.getRef().getURI().toString());
	}

	@Test
	public void runOneSessionTest() throws InterruptedException {
		MockSessionProtocol sessionprotocol = startSession();
		sessionprotocol.getListener();
	}

	@Test
	public void runOneSessionAndUnhandledEvent() throws InterruptedException {
		MockSessionProtocol sessionprotocol = startSession();
		sessionprotocol.getListener().notifyChange(mock(ProtocolEvent.class));
		verify(state, times(0)).with(any());
	}

	/**
	 * Check that a started session correctly handles a session event.
	 */
	@Test
	public void CurrentNegoStateEventTest() throws InterruptedException {
		MockSessionProtocol sessionprotocol = startSession();

		CurrentNegoState evt = mock(CurrentNegoState.class);
		when(evt.getState()).thenReturn(finalsessionstate);
		sessionprotocol.getListener().notifyChange(evt);

		ArgumentCaptor<SessionResult> argument = ArgumentCaptor
				.forClass(SessionResult.class);
		verify(state, times(1)).with(argument.capture());
		assertEquals(agreement, argument.getValue().getAgreement());
		assertNull(argument.getValue().getError());
	}

	private MockSessionProtocol startSession() throws InterruptedException {
		SessionSettings setting = mock(SessionSettings.class);
		MockSessionProtocol sessionprotocol = new MockSessionProtocol();
		when(setting.getProtocol(log)).thenReturn(sessionprotocol);
		when(state.getNextSettings()).thenReturn(setting);

		app.start(factory);
		Thread.sleep(500); // allow app to start session
		// this call should return fine, and have listener registered to our
		// protocol. app now waits for a notification
		return sessionprotocol;
	}

}

/**
 * 
 * The protocol needs to record the listners, we need a listener to trigger
 * further protocol actions. Mockito can't handle this, we mneed our own mock...
 *
 */
class MockSessionProtocol implements SessionProtocol {
	private final List<Listener<ProtocolEvent>> listeners = new LinkedList<>();

	@Override
	public void start(ProtocolToPartyConnFactory connectionfactory) {

	}

	@Override
	public String getDescription() {
		return null;
	}

	@Override
	public NegoState getState() {
		return null;
	}

	@Override
	public ProtocolRef getRef() {
		return null;
	}

	@Override
	public void addParticipant(PartyWithProfile party) {
	}

	@Override
	public void addListener(Listener<ProtocolEvent> l) {
		listeners.add(l);
	}

	@Override
	public void removeListener(Listener<ProtocolEvent> l) {
	}

	public Listener<ProtocolEvent> getListener() {
		if (listeners.size() != 1) {
			throw new IllegalStateException("Not having exactly 1 listener");
		}
		return listeners.get(0);
	}

}