import java.lang.reflect.Method;

import org.junit.Assert;
import org.junit.Test;

/**
 * Test Klasse für die HA5: testet die grundlegende Funktionalitäten
 * 
 * Realisiert mit JUnit4: Das müsst ihr zuerst zum Project class path dazu tun, damits funktioniert. (Siehe Links)
 * 
 * @author Kordian bruck <bruck@in.tum.de>
 * @since 21.12.2013
 * @version 1.3
 * @see http://kbruck.name/2013/11/23/junit-zum-classpath-hinzufugen-eclipse-kepler/
 * @see http://kbruck.name/2014/01/03/pgp-ha5-junit-file/
 * 
 */
public class TestHA5 {

	private final double delta = 0.000000001;

	@Test
	public void testMatrixMultiply() throws Exception {
		double[][] matrix = { { 1, 1 }, { 1, 1 } };
		double[] vector = { 0.25, 0.25 };
		vector = (double[]) this.executeMethod(new LinkedDocumentCollection(), "multiply", new Object[] { matrix,
				vector });
		Assert.assertEquals(0.5, vector[0], this.delta);
		Assert.assertEquals(0.5, vector[1], this.delta);
	}

	@Test
	public void testMuenzen() throws Exception {
		List<Integer> coinsEU = List.node(1, List.node(2,
				List.node(5, List.node(10, List.node(20, List.node(50, List.node(100, List.node(200, null))))))));
		List<Integer> coinsUS = List.node(1, List.node(5, List.node(10, List.node(25, null))));

		// Ein paar beispielsfälle :)
		Assert.assertEquals(4, Muenzen.numPossibilities(0, 5, coinsEU));
		Assert.assertEquals(41454, Muenzen.numPossibilities(0, 175, coinsEU));
		Assert.assertEquals(451, Muenzen.numPossibilities(0, 50, coinsEU));
		Assert.assertEquals(1, Muenzen.numPossibilities(0, 1, coinsEU));
		Assert.assertEquals(0, Muenzen.numPossibilities(0, 0, coinsEU));
		Assert.assertEquals(0, Muenzen.numPossibilities(0, -1, coinsEU));
		Assert.assertEquals(4563, Muenzen.numPossibilities(0, 100, coinsEU));
		Assert.assertEquals(116827, Muenzen.numPossibilities(0, 222, coinsEU));

		// Sollte auch mit anderen Münzsystemen funktionieren ;)
		Assert.assertEquals(6, Muenzen.numPossibilities(0, 15, coinsUS));
		Assert.assertEquals(242, Muenzen.numPossibilities(0, 100, coinsUS));

		// Solltes sowieso abgefangen werden
		Assert.assertEquals(0, Muenzen.numPossibilities(0, 100, null));

		// Negative Werte sind immer lustig >:D
		Assert.assertEquals(4, Muenzen.numPossibilities(-6, -1, coinsEU));
		Assert.assertEquals(41454, Muenzen.numPossibilities(-176, -1, coinsEU));
	}

	@Test
	public void testPageRank() throws Exception {
		LinkedDocumentCollection ldc = new LinkedDocumentCollection();
		LinkedDocument ld = LinkedDocument.createLinkedDocumentFromFile("JA");
		ldc.addLast(ld);
		ldc = ldc.crawl();
		double[] result = ldc.pageRank(0.85);

		// Werte testen
		Assert.assertEquals(0.05471340596873514, result[0], this.delta);
		Assert.assertEquals(0.060753197536712406, result[1], this.delta);
		Assert.assertEquals(0.4485513458171195, result[2], this.delta);
		Assert.assertEquals(0.43598205067743273, result[3], this.delta);

	}

	@Test
	public void testRelevance() throws Exception {
		LinkedDocumentCollection ldc = new LinkedDocumentCollection();
		LinkedDocument ld = new LinkedDocument("B", "", "", null, null, "link:A link:E", "B");
		ldc.addLast(ld);
		ldc = ldc.crawl();
		double[] result = ldc.pageRank(0.85);

		// Werte testen
		Assert.assertEquals(0.14897680763983684, result[0], this.delta);
		Assert.assertEquals(0.0933151432469308, result[1], this.delta);
		Assert.assertEquals(0.34291508382082525, result[2], this.delta);
		Assert.assertEquals(0.32147782204547976, result[3], this.delta);
		Assert.assertEquals(0.0933151432469308, result[4], this.delta);

		ldc.match("einmal");

		// Reihenfolge sollte erstmal stimmen
		Assert.assertEquals("A", ldc.get(0).getTitle());
		Assert.assertEquals("C", ldc.get(1).getTitle());
		Assert.assertEquals("D", ldc.get(2).getTitle());
		Assert.assertEquals("B", ldc.get(3).getTitle());
		Assert.assertEquals("E", ldc.get(4).getTitle());

		// Schauen ob auch genau genug gerechnet wurde
		Assert.assertEquals(0.285917709527423, ldc.getQueryRelevance(0), this.delta);
		Assert.assertEquals(0.1371660335283301, ldc.getQueryRelevance(1), this.delta);
		Assert.assertEquals(0.1285911288181919, ldc.getQueryRelevance(2), this.delta);
		Assert.assertEquals(0.05959072305593474, ldc.getQueryRelevance(3), this.delta);
		Assert.assertEquals(0.03732605729877232, ldc.getQueryRelevance(4), this.delta);

		// Array sollte natürlich auch richtig sortiert sein :D
		double damping = 0.85;
		double weighting = 0.6;
		result = (double[]) this.executeMethod(ldc, "sortByRelevance", new Object[] { damping, weighting });
		Assert.assertEquals(0.285917709527423, result[0], this.delta);
		Assert.assertEquals(0.1371660335283301, result[1], this.delta);
		Assert.assertEquals(0.1285911288181919, result[2], this.delta);
		Assert.assertEquals(0.05959072305593474, result[3], this.delta);
		Assert.assertEquals(0.03732605729877232, result[4], this.delta);
	}

	/**
	 * Diese methode hilft nur das private von methoden zu umgehen, kann igonriert werden
	 * 
	 * Executes a method on an object instance. The name and parameters of the method are specified. The method will be
	 * executed and the value of it returned, even if the method would have private or protected access.
	 */
	private Object executeMethod(Object instance, String name, Object[] params) throws Exception {
		Class<?> c = instance.getClass();
		Class<?>[] types = new Class[params.length]; // Fetch the Class types of all method parameters
		for (int i = 0; i < params.length; i++) {
			if (params[i].getClass() != Double.class) {
				types[i] = params[i].getClass();
			} else {
				types[i] = double.class;
			}
		}
		Method m = c.getDeclaredMethod(name, types);
		m.setAccessible(true);// *BLACK MAGIC* make sure the method is accessible
		return m.invoke(instance, params);
	}
}