package geniusweb.actions;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;

import org.junit.Test;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.DiscreteValue;
import tudelft.utilities.junit.GeneralTests;

public class VotesTest extends GeneralTests<Votes> {
	private final ObjectMapper jackson = new ObjectMapper();
	private final String votestring = "{\"Votes\":{\"actor\":\"partyA\",\"votes\":[{\"vote\":{\"actor\":\"partyA\",\"bid\":{\"issuevalues\":{\"is1\":\"val1\"}},\"minPower\":2,\"maxPower\":9}},{\"vote\":{\"actor\":\"partyA\",\"bid\":{\"issuevalues\":{\"is1\":\"val2\"}},\"minPower\":2,\"maxPower\":9}}]}}";

	private PartyId partyA = new PartyId("partyA");
	private PartyId partyB = new PartyId("partyB");
	private Bid bid1 = new Bid("is1", new DiscreteValue("val1")),
			bid2 = new Bid("is1", new DiscreteValue("val2"));
	private Vote voteA1 = new Vote(partyA, bid1, 2, 9);
	private Vote voteA2 = new Vote(partyA, bid2, 2, 9);
	private Vote voteB1 = new Vote(partyB, bid1, 2, 9);
	private Vote voteB2 = new Vote(partyB, bid2, 2, 9);

	private Votes votes1 = new Votes(partyA,
			new HashSet<>(Arrays.asList(voteA1, voteA2)));
	private Votes votes1a = new Votes(partyA,
			new HashSet<>(Arrays.asList(voteA1, voteA2)));
	private Votes votes2 = new Votes(partyB,
			new HashSet<>(Arrays.asList(voteB1, voteB2)));

	@Override
	public List<List<Votes>> getGeneralTestData() {
		return Arrays.asList(Arrays.asList(votes1, votes1a),
				Arrays.asList(votes2));
	}

	@Override
	public List<String> getGeneralTestStrings() {
		return Arrays.asList(
				"Votes.*Vote.*partyA,Bid.*is1.*val1.*2.*Vote.*partyA,Bid.*is1.*val2.*2.*",
				"Votes.*Vote.*partyB,Bid.*is1.*val2.*2.*Vote.*partyB,Bid.*is1.*val1.*2.*");
	}

	@SuppressWarnings("unused")
	@Test(expected = IllegalArgumentException.class)
	public void testRejectVoteWithIncorrectParty() {
		new Votes(partyA, Collections.singleton(voteB1));
	}

	@Test
	public void serializeTest() throws JsonProcessingException {
		System.out.println(jackson.writeValueAsString(votes1));
		assertEquals(votestring, jackson.writeValueAsString(votes1));
	}

	@Test
	public void deserializeTest() throws IOException {
		Action act = jackson.readValue(votestring, Action.class);
		assertEquals(votes1, act);
	}

	@Test(expected = IllegalArgumentException.class)
	public void testWrongPartyName() {
		new Votes(partyA, new HashSet<>(Arrays.asList(voteB1, voteB2)));
	}

	@Test
	public void isExtendingTestExtraVote() {
		Votes otherVotes = new Votes(partyA, Collections.singleton(voteA1));
		assertTrue(votes1.isExtending(otherVotes));
	}

	@Test
	public void isExtendingTestNoVotes() {
		Votes otherVotes = new Votes(partyA, Collections.emptySet());
		assertTrue(votes1.isExtending(otherVotes));
	}

	@Test
	public void isExtendingTestMissing() {
		Votes otherVotes = new Votes(partyA, Collections.singleton(voteA1));
		assertFalse(otherVotes.isExtending(votes1));
	}

	@Test
	public void isExtendingIdenticalVotes() {
		assertTrue(votes1.isExtending(votes1));
	}

	@Test
	public void isReallyExtendingVotesMin() {
		Vote powervoteA1 = new Vote(partyA, bid1, 1, 9);
		Votes powerVotes = new Votes(partyA,
				new HashSet<>(Arrays.asList(powervoteA1, voteA2)));
		assertTrue(powerVotes.isExtending(votes1));
	}

	@Test
	public void isReallyExtendingVotesMax() {
		Vote powervoteA1 = new Vote(partyA, bid1, 2, 10);
		Votes powerVotes = new Votes(partyA,
				new HashSet<>(Arrays.asList(powervoteA1, voteA2)));
		assertTrue(powerVotes.isExtending(votes1));
	}

	@Test
	public void IsNarrowingOneVoteRemoved() {
		Votes narrowVotes = new Votes(partyA, Collections.singleton(voteA2));
		assertFalse(narrowVotes.isExtending(votes1));
	}

	@Test
	public void isNarrowingTestMoreMinPower() {
		Vote narrowVoteA1 = new Vote(partyA, bid1, 3, 9);
		Votes narrowVotes = new Votes(partyA,
				new HashSet<>(Arrays.asList(narrowVoteA1, voteA2)));
		assertFalse(narrowVotes.isExtending(votes1));
		assertTrue(votes1.isExtending(narrowVotes));
	}

	@Test
	public void isNarrowingLessMaxPower() {
		Vote powervoteA1 = new Vote(partyA, bid1, 2, 8);
		Votes narrowVotes = new Votes(partyA,
				new HashSet<>(Arrays.asList(powervoteA1, voteA2)));
		assertFalse(narrowVotes.isExtending(votes1));
		assertTrue(votes1.isExtending(narrowVotes));
	}

	@Test(expected = IllegalArgumentException.class)
	public void testDuplicateBidsNotAllowed() {
		Vote voteA1similar = new Vote(partyA, bid1, 3, 9);
		Votes votes = new Votes(partyA,
				new HashSet<>(Arrays.asList(voteA1, voteA1similar)));
	}
}