package jcgp.tests;

import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Random;

import jcgp.Parameters;
import jcgp.Utilities;
import jcgp.function.Function;
import jcgp.function.InsufficientArgumentsException;
import jcgp.population.Chromosome;
import jcgp.population.Connection;
import jcgp.population.InsufficientConnectionsException;
import jcgp.population.Node;

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

/**
 * 
 * Tests which cover the behaviour specified for a node.
 * 
 *  - A node should contain read-only row and column values which are set upon construction.
 *  - It should contain a fully accessible Function object.
 *  - It should contain a set of connections which can be initialised and randomly 
 *    modified. It should be able to return an addressed connection.
 *  - It should be able to compute a value using its function with its connections as arguments.
 *  
 *  WARNING: changing parameters may cause the tests to incorrectly fail!
 * 
 * @author Eduardo Pedroni
 *
 */
public class NodeTests {

	private Node node;
	private static Chromosome chromosome;
	// these numbers will be used by the node under test
	private final int arg1 = 2;
	private final int arg2 = 5;

	@BeforeClass
	public static void setUpBeforeClass() {
		// initialise utilities
		Utilities.setResources(new Random(1234), null);

		// initialise parameters
		Parameters.setColumns(0);
		Parameters.setRows(0);
		Parameters.setInputs(0);
		Parameters.setOutputs(0);
		Parameters.setLevelsBack(0);
		Parameters.setMutationRate(10);
		Parameters.setTotalGenerations(100);
		Parameters.setTotalRuns(5);
		Parameters.setMaxArity(2);

		chromosome = new Chromosome();
	}

	@Before
	public void setUp() throws Exception {
		node = new Node(chromosome, 0, 0);
		// make node with anonymous addition function and hard-coded value connections
		node.initialise(new Function() {
			private int arity = 2;

			@Override
			public int run(Connection... connections) {

				// add together the first n inputs if they exist, else throw exception
				if (connections.length >= arity) {
					return connections[0].getValue() + connections[1].getValue();
				} else {
					throw new InsufficientArgumentsException();
				}
			}

			@Override
			public int getArity() {
				// addition with arity 2
				return arity;
			}

		}, new Connection[]{new Connection() {

			@Override
			public int getValue() {
				// hardcode a value
				return arg1;
			}

			@Override
			public void getActive(ArrayList<Connection> activeNodes) {
				// irrelevant for this test
			}

		},
		new Connection() {

			@Override
			public int getValue() {
				// hardcode a value
				return arg2;
			}

			@Override
			public void getActive(ArrayList<Connection> activeNodes) {
				// irrelevant for this test
			}

		}});
	}

	@Test
	public void rowAndColumnTest() {
		assertTrue("Incorrect row.", node.getRow() == 0);
		assertTrue("Incorrect column.", node.getColumn() == 0);
	}

	@Test
	public void functionTest() {
		// make a new function and assign to node
		Function f = new Function() {

			@Override
			public int run(Connection... connections)
					throws InsufficientConnectionsException {
				// blank
				return 0;
			}

			@Override
			public int getArity() {
				// blank
				return 0;
			}
		};

		node.setFunction(f);

		// check that the function returned by the node is f
		assertTrue("Incorrect function returned.", node.getFunction() == f);
		// check that it outputs 0 as it should
		assertTrue("Incorrect function output.", node.getValue() == 0);
	}

	@Test
	public void evaluationTest() {
		// check that addition is working
		assertTrue("Node did not return expected value (sum of arguments).", node.getValue() == arg1 + arg2);

		// put in a different function, check the output has changed appropriately
		node.setFunction(new Function() {

			private int arity = 2;

			@Override
			public int run(Connection... connections) throws InsufficientConnectionsException {
				// add together the first n inputs if they exist, else throw exception
				if (connections.length >= arity) {
					return connections[0].getValue() - connections[1].getValue();
				} else {
					throw new InsufficientArgumentsException();
				}
			}

			@Override
			public int getArity() {
				return arity;
			}
		});

		assertTrue("Node did not return expected value (difference of arguments).", node.getValue() == arg1 - arg2);

	}

	@Test
	public void connectionsTest() {
		// make new blank connections, check that they are returned correctly when addressed
		Connection conn0, conn1, conn2;
		conn0 = new Connection() {

			@Override
			public int getValue() {
				// blank
				return 0;
			}

			@Override
			public void getActive(ArrayList<Connection> activeNodes) {
				// blank

			}
		};
		conn1 = new Connection() {

			@Override
			public int getValue() {
				// blank
				return 0;
			}

			@Override
			public void getActive(ArrayList<Connection> activeNodes) {
				// blank

			}
		};
		node.initialise(null, conn0, conn1);
		
		assertTrue("Connection 0 is incorrect.", node.getConnection(0) == conn0);
		assertTrue("Connection 1 is incorrect.", node.getConnection(1) == conn1);
		
		// make yet another connection, set it randomly, check that it is one of the node's connections
		conn2 = new Connection() {

			@Override
			public int getValue() {
				// blank
				return 0;
			}

			@Override
			public void getActive(ArrayList<Connection> activeNodes) {
				// blank

			}
		};
		node.setConnection(conn2);
		
		assertTrue("Connection was not found in node.", node.getConnection(0) == conn2 || node.getConnection(1) == conn2);
		
	}

}