package geniusweb.bidspace.pareto;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.HashSet;

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

import geniusweb.issuevalue.Bid;
import geniusweb.issuevalue.Value;
import geniusweb.profile.utilityspace.LinearAdditive;

public class ParetoPointTest {
	private static final BigDecimal D0_2 = BigDecimal.valueOf(0.2);
	private static final BigDecimal D0_1 = BigDecimal.valueOf(0.1);
	private static final BigDecimal D0_3 = BigDecimal.valueOf(0.3);
	private static final BigDecimal D0_4 = BigDecimal.valueOf(0.4);
	private static final BigDecimal D0_5 = BigDecimal.valueOf(0.5);
	private final LinearAdditive space1 = mock(LinearAdditive.class),
			space2 = mock(LinearAdditive.class);
	private final Bid bid11 = mock(Bid.class), bid12 = mock(Bid.class),
			bid21 = mock(Bid.class), bid22 = mock(Bid.class);
	private ParetoPoint point11, point12, point21, point22;

	@Before
	public void before() {
		when(space1.getUtility(eq(bid11))).thenReturn(D0_1);
		when(space2.getUtility(eq(bid11))).thenReturn(D0_1);

		when(space1.getUtility(eq(bid12))).thenReturn(D0_1);
		when(space2.getUtility(eq(bid12))).thenReturn(D0_2);

		when(space1.getUtility(eq(bid21))).thenReturn(D0_2);
		when(space2.getUtility(eq(bid21))).thenReturn(D0_1);

		when(space1.getUtility(eq(bid22))).thenReturn(D0_2);
		when(space2.getUtility(eq(bid22))).thenReturn(D0_2);

		point11 = new ParetoPoint(bid11, Arrays.asList(space1, space2));
		point12 = new ParetoPoint(bid12, Arrays.asList(space1, space2));
		point21 = new ParetoPoint(bid21, Arrays.asList(space1, space2));
		point22 = new ParetoPoint(bid22, Arrays.asList(space1, space2));
	}

	@Test
	public void constructorTest() {
		assertEquals(bid11, point11.getBid());
		assertEquals(bid21, point21.getBid());

		assertEquals(Arrays.asList(D0_1, D0_1), point11.getUtilities());
		assertEquals(Arrays.asList(D0_2, D0_1), point21.getUtilities());
	}

	@Test
	public void dominationTest() {
		assertTrue(point11.isDominatedBy(point11));
		assertTrue(point11.isDominatedBy(point12));
		assertTrue(point11.isDominatedBy(point21));
		assertTrue(point11.isDominatedBy(point22));

		assertFalse(point12.isDominatedBy(point11));
		assertFalse(point12.isDominatedBy(point21));
		assertTrue(point12.isDominatedBy(point12));
		assertTrue(point12.isDominatedBy(point22));

		assertFalse(point21.isDominatedBy(point11));
		assertFalse(point21.isDominatedBy(point12));
		assertTrue(point21.isDominatedBy(point21));
		assertTrue(point21.isDominatedBy(point22));

		assertFalse(point22.isDominatedBy(point11));
		assertFalse(point22.isDominatedBy(point12));
		assertFalse(point22.isDominatedBy(point21));
		assertTrue(point22.isDominatedBy(point22));
	}

	@Test
	public void mergeTest() {
		// partial bid 020_010 has value 0.2 for issue 2 in space1 and 0.1 for
		// issue 2 in space2.
		Bid partialbid020_010 = mock(Bid.class),
				partialbid102_301 = mock(Bid.class);
		// merged this should be a bid 122_311 so it has utilities
		// 1+2+2=0.5 in space1 and 3+1+1=0.5 in space2

		when(partialbid020_010.getIssues())
				.thenReturn(new HashSet<String>(Arrays.asList("issue2")));
		when(partialbid102_301.getIssues()).thenReturn(
				new HashSet<String>(Arrays.asList("issue1", "issue3")));

		Value value1 = mock(Value.class), value2 = mock(Value.class),
				value3 = mock(Value.class);
		when(partialbid020_010.getValue(eq("issue2"))).thenReturn(value2);
		when(partialbid102_301.getValue(eq("issue1"))).thenReturn(value1);
		when(partialbid102_301.getValue(eq("issue3"))).thenReturn(value3);

		when(space1.getUtility(eq(partialbid020_010))).thenReturn(D0_2);
		when(space1.getUtility(eq(partialbid102_301))).thenReturn(D0_3);
		when(space2.getUtility(eq(partialbid020_010))).thenReturn(D0_1);
		when(space2.getUtility(eq(partialbid102_301))).thenReturn(D0_4);

		ParetoPoint p1 = new ParetoPoint(partialbid020_010,
				Arrays.asList(space1, space2));
		ParetoPoint p2 = new ParetoPoint(partialbid102_301,
				Arrays.asList(space1, space2));

		ParetoPoint p = p1.merge(p2);
		Bid bid = p.getBid();
		assertEquals(
				new HashSet<String>(
						Arrays.asList("issue1", "issue2", "issue3")),
				bid.getIssues());
		assertEquals(value1, bid.getValue("issue1"));
		assertEquals(value2, bid.getValue("issue2"));
		assertEquals(value3, bid.getValue("issue3"));
		assertEquals(D0_5, p.getUtilities().get(0));
		assertEquals(D0_5, p.getUtilities().get(1));
	}

}