'use strict';

import { network } from './topology';


test('basic network functionality', () => {
	const n = network(0, 5, 0);
	expect(n).toEqual({
		input_count: 0,
		output_count: 0,
		adjacency: [ [], [], [], [], [] ],
		weight: [],
	});

	expect(() => n.adjacency = []).toThrow();
	expect(() => n.weight = []).toThrow();

	const nn = n.connect(0, 1, -2);
	expect(nn).toEqual({
		input_count: 0,
		output_count: 0,
		adjacency: [
			[ 1 ],
			[ -1 ],
			[ 0 ],
			[ 0 ],
			[ 0 ]
		],
		weight: [ -2 ],
	});

	expect(() => nn.adjacency = []).toThrow();
	expect(() => nn.weight = []).toThrow();

	const nnn = nn.connect(2, 4, 3);
	expect(nnn).toEqual({
		input_count: 0,
		output_count: 0,
		adjacency: [
			[ 1, 0 ],
			[ -1, 0 ],
			[ 0, 1 ],
			[ 0, 0 ],
			[ 0, -1 ]
		],
		weight: [ -2, 3 ],
	});

	expect(() => nnn.adjacency = []).toThrow();
	expect(() => nnn.weight = []).toThrow();
});


test(
'networks are restricted from sinking to inputs or sourcing from outputs', 
() => {
	const n = network(2, 2, 2);

	expect(n.connect(1,2,0)).toEqual({
		input_count: 2,
		output_count: 2,
		adjacency: [
			[ 0 ],
			[ 1 ],
			[ -1 ],
			[ 0 ],
			[ 0 ],
			[ 0 ],
		],
		weight: [ 0 ],
	});
	expect(() => n.connect(2, 1, 0)).toThrow();

	expect(n.connect(3, 4, 2)).toEqual({
		input_count: 2,
		output_count: 2,
		adjacency: [
			[ 0 ],
			[ 0 ],
			[ 0 ],
			[ 1 ],
			[ -1 ],
			[ 0 ],
		],
		weight: [ 2 ],
	});
	expect(() => n.connect(4, 3, 2)).toThrow();
});


test('self-connections work correctly', () => {
	const n = network(0, 1, 0).connect(0, 0, 2.0);
	expect(n).toEqual({
		input_count: 0,
		output_count: 0,
		adjacency: [
			[ 2 ],
		],
		weight: [ 2 ],
	});
});


test('network computations', () => {
	const n = network(1, 0, 1).connect(0, 1, 2.0);
	const input = [ -0.5 ];
	const state = [];
	const result = n.compute(input, state);
	expect(result).toEqual([
		[ Math.tanh(-0.5 * 2.0) ],
		[],
	]);

	expect(input).toEqual([ -0.5 ]);
	expect(state).toEqual([]);

	expect(() => result[0] = 'hi').toThrow();
	expect(() => result[0].push('hi')).toThrow();
	expect(() => result[1] = 'hi').toThrow();
	expect(() => result[1].push('hi')).toThrow();
});


test('multiple input network', () => {
	const n = network(4, 0, 1)
		.connect(0, 4, -1.0)
		.connect(1, 4, -2.0)
		.connect(2, 4,  1.0)
		.connect(3, 4,  2.0)
	
	expect(n.compute([1, 2, 3, 5], [])).toEqual([
		[ Math.tanh(
			(-1.0 * 1) +
			(-2.0 * 2) +
			(1.0  * 3) +
			(2.0  * 5))],
		[],
	]);
});