'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 ],
	});
});