const {assert} = require('chai');
const Event = require('../src/r3/r3-event.js');

//GENERATED_COMPONENT_IMPORTS_START
const ComponentCode = require('../src/r3/r3-component/./r3-component-code.js');
const ComponentDOM = require('../src/r3/r3-component/./r3-component-d-o-m.js');
const ComponentCanvas = require('../src/r3/r3-component/./r3-component-canvas.js');
const ComponentGeometry = require('../src/r3/r3-component/./r3-component-geometry.js');
const ComponentBufferGeometry = require('../src/r3/r3-component/./r3-component-buffer-geometry.js');
const ComponentPlaneGeometry = require('../src/r3/r3-component/./r3-component-plane-geometry.js');
const ComponentGraphics = require('../src/r3/r3-component/./r3-component-graphics.js');
const ComponentImage = require('../src/r3/r3-component/./r3-component-image.js');
const ComponentInput = require('../src/r3/r3-component/./r3-component-input.js');
const ComponentTouch = require('../src/r3/r3-component/./r3-component-touch.js');
const ComponentMaterial = require('../src/r3/r3-component/./r3-component-material.js');
const ComponentMesh = require('../src/r3/r3-component/./r3-component-mesh.js');
const ComponentTexture = require('../src/r3/r3-component/./r3-component-texture.js');
//GENERATED_COMPONENT_IMPORTS_END

//GENERATED_ENTITY_IMPORTS_START
const EntitySlider = require('../src/r3/r3-entity/./r3-entity-slider.js');
//GENERATED_ENTITY_IMPORTS_END

//GENERATED_RUNTIME_IMPORTS_START
const RuntimeCoder = require('../src/r3/r3-runtime/./r3-runtime-coder.js');
const RuntimeCodeMirror = require('../src/r3/r3-runtime/./r3-runtime-code-mirror.js');
const RuntimeDOM = require('../src/r3/r3-runtime/./r3-runtime-d-o-m.js');
const RuntimeJSDOM = require('../src/r3/r3-runtime/./r3-runtime-j-s-d-o-m.js');
const RuntimeWebDOM = require('../src/r3/r3-runtime/./r3-runtime-web-d-o-m.js');
const RuntimeGUI = require('../src/r3/r3-runtime/./r3-runtime-g-u-i.js');
const RuntimeControlKit = require('../src/r3/r3-runtime/./r3-runtime-control-kit.js');
const RuntimeGraphics = require('../src/r3/r3-runtime/./r3-runtime-graphics.js');
const RuntimeThree = require('../src/r3/r3-runtime/./r3-runtime-three.js');
const RuntimeImage = require('../src/r3/r3-runtime/./r3-runtime-image.js');
const RuntimePhysics = require('../src/r3/r3-runtime/./r3-runtime-physics.js');
const RuntimeBullet = require('../src/r3/r3-runtime/./r3-runtime-bullet.js');
const RuntimeSocket = require('../src/r3/r3-runtime/./r3-runtime-socket.js');
const RuntimeStatistics = require('../src/r3/r3-runtime/./r3-runtime-statistics.js');
const RuntimeStats = require('../src/r3/r3-runtime/./r3-runtime-stats.js');
//GENERATED_RUNTIME_IMPORTS_END

//GENERATED_R3_OBJECT_IMPORTS_START
const Project = require('../src/r3/r3-object/./r3-project.js');
//GENERATED_R3_OBJECT_IMPORTS_END

describe('R3 Tests', () => {

	it (
		'R3 loads',
		() => {

			const R3 = require('../src/r3/');

			assert.typeOf(R3.Version, 'string');
			assert.typeOf(R3.CompileDate, 'string');

			console.log('R3 Version : ' + R3.Version);
			console.log('R3 Compile Date : ' + R3.CompileDate);

		}
	);

	it (
		'Creation of all components succeed',
		() => {

			//GENERATED_COMPONENT_CREATE_START
			const componentCode = new ComponentCode();
			assert.isTrue(componentCode.initialized);
			const componentDOM = new ComponentDOM();
			assert.isTrue(componentDOM.initialized);
			const componentCanvas = new ComponentCanvas();
			assert.isTrue(componentCanvas.initialized);
			const componentGeometry = new ComponentGeometry();
			assert.isTrue(componentGeometry.initialized);
			const componentBufferGeometry = new ComponentBufferGeometry();
			assert.isTrue(componentBufferGeometry.initialized);
			const componentPlaneGeometry = new ComponentPlaneGeometry();
			assert.isTrue(componentPlaneGeometry.initialized);
			const componentGraphics = new ComponentGraphics();
			assert.isTrue(componentGraphics.initialized);
			const componentImage = new ComponentImage();
			assert.isTrue(componentImage.initialized);
			const componentInput = new ComponentInput();
			assert.isTrue(componentInput.initialized);
			const componentTouch = new ComponentTouch();
			assert.isTrue(componentTouch.initialized);
			const componentMaterial = new ComponentMaterial();
			assert.isTrue(componentMaterial.initialized);
			const componentMesh = new ComponentMesh();
			assert.isTrue(componentMesh.initialized);
			const componentTexture = new ComponentTexture();
			assert.isTrue(componentTexture.initialized);
			//GENERATED_COMPONENT_CREATE_END

		}
	);

	it (
		'Creation of all entities succeed',
		() => {

			//GENERATED_ENTITY_CREATE_START
			const entitySlider = new EntitySlider();
			assert.isTrue(entitySlider.initialized);
			//GENERATED_ENTITY_CREATE_END

		}
	);

	it (
		'Creation of all runtimes succeed',
		() => {

			//GENERATED_RUNTIME_CREATE_START
			const runtimeCoder = new RuntimeCoder();
			const runtimeCodeMirror = new RuntimeCodeMirror();
			const runtimeDOM = new RuntimeDOM();
			const runtimeJSDOM = new RuntimeJSDOM();
			const runtimeWebDOM = new RuntimeWebDOM();
			const runtimeGUI = new RuntimeGUI();
			const runtimeControlKit = new RuntimeControlKit();
			const runtimeGraphics = new RuntimeGraphics();
			const runtimeThree = new RuntimeThree();
			const runtimeImage = new RuntimeImage();
			const runtimePhysics = new RuntimePhysics();
			const runtimeBullet = new RuntimeBullet();
			const runtimeSocket = new RuntimeSocket();
			const runtimeStatistics = new RuntimeStatistics();
			const runtimeStats = new RuntimeStats();
			//GENERATED_RUNTIME_CREATE_END

		}
	);

	it (
		'Creation of all objects succeed',
		() => {

			//GENERATED_R3_OBJECT_CREATE_START
			const project = new Project();
			//GENERATED_R3_OBJECT_CREATE_END

		}
	);

	it (
		'Linking system sets parent / child relationships correctly',
		() => {

			const slider1 = new EntitySlider(
				{
					name : 'slider1'
				}
			);

			const canvas = new ComponentCanvas();
			const touch = new ComponentTouch();

			const image1 = new ComponentImage();
			const image2 = new ComponentImage();
			const image3 = new ComponentImage();

			// test normal assignment

			slider1.canvas = canvas;

			assert.deepEqual(canvas.parents, [slider1]);
			assert.deepEqual(slider1.children, [canvas]);
			assert.deepEqual(slider1.components, [canvas]);

			slider1.images = [image1];

			assert.deepEqual(image1.parents, [slider1]);
			assert.deepEqual(slider1.children, [canvas, image1]);
			assert.deepEqual(slider1.images, [image1]);
			assert.deepEqual(slider1.components, [canvas, image1]);

			// test assignment through constructor

			const slider2 = new EntitySlider(
				{
					name : 'slider2',
					canvas : canvas,
					images : [image1, image2]
				}
			)

			assert.deepEqual(canvas.parents, [slider1, slider2]);
			assert.deepEqual(image1.parents, [slider1, slider2]);
			assert.deepEqual(image2.parents, [slider2]);

			assert.deepEqual(slider2.images, [image1, image2]);
			assert.deepEqual(slider2.children, [canvas, image1, image2]);
			assert.deepEqual(slider2.components, [canvas, image1, image2]);

			try {
				const slider3 = new EntitySlider(
					{
						name: 'badSlider3',
						canvas: canvas,
						images: null
					}
				)
			} catch (err) {
				assert.isTrue(err instanceof TypeError);
			}

			const slider3 = new EntitySlider(
				{
					name : 'slider3',
					canvas
				}
			);
			slider3.images = [image1, image2, image3];

			assert.deepEqual(image1.parents, [slider1, slider2, slider3]);
			assert.deepEqual(slider3.children, [canvas, image1, image2, image3]);
			assert.deepEqual(slider3.components, [canvas, image1, image2, image3]);

			//test normal re-assignment
			slider3.images = [image1, image3];
			assert.deepEqual(image1.parents, [slider1, slider2, slider3]);
			assert.deepEqual(image2.parents, [slider2]);
			assert.deepEqual(slider3.children, [canvas, image1, image3]);
			assert.deepEqual(slider3.components, [canvas, image1, image3]);

			//test via splice
			slider3.images = [];//splice(0,2);
			assert.deepEqual(image1.parents, [slider1, slider2]);
			assert.deepEqual(image2.parents, [slider2]);
			assert.deepEqual(image3.parents, []);
			assert.deepEqual(slider3.children, [canvas]);
			assert.deepEqual(slider3.components, [canvas]);

			slider3.canvas = null;
			assert.deepEqual(canvas.parents, [slider1, slider2]);
			assert.deepEqual(slider3.children, []);
			assert.deepEqual(slider3.components, []);

			try {
				const slider4 = new EntitySlider(
					{
						canvas,
						images: [{}]
					}
				);
			} catch (err) {
				assert.isTrue(err instanceof TypeError);
			}

			assert.deepEqual(canvas.parents, [slider1, slider2]);

			try {
				const slider5 = new EntitySlider(
					{
						name : 'slider5',
						canvas : image1
					}
				);
			} catch (err) {
				assert.isTrue(err instanceof TypeError);
			}

			// test if delete works on an object
			const slider6 = new EntitySlider(
				{
					name : 'slider6',
					canvas : canvas
				}
			);

			delete slider6.canvas;

			// assert.deepEqual(canvas.parents, [slider1, slider2]);

			console.log('DELETE AND SPLICE DOES NOT WORK');
		}
	);

	it(
		'Linking system detects future ready state correctly',
		() => {

			const R3 = require('../src/r3/');

			let touch1 = new ComponentTouch(
				{
					name : 'touch1'
				}
			)

			let canvas = new ComponentCanvas();

			assert.isFalse(touch1.ready[0]);

			touch1.domComponent = canvas;

			assert.isTrue(touch1.ready[0]);

			let slider1 = new EntitySlider();

			assert.isFalse(slider1.ready[0]);

			let images = [];

			slider1.images = images;

			assert.isFalse(slider1.ready[0]);

			let image1 = new ComponentImage();

			slider1.images = [image1];

			assert.isFalse(slider1.ready[0]);

			slider1.canvas = canvas;

			assert.isFalse(slider1.ready[0]);

			slider1.touch = touch1;

			assert.isTrue(slider1.ready[0]);

			touch1.domComponent = null;

			assert.isFalse(touch1.ready[0]);
			assert.isFalse(slider1.ready[0]);

		}
	);


	it(
		'Tests the Graph building process',
		() => {
			const R3 = require('../src/r3/');
			let canvas = new ComponentCanvas();
			let image1 = new ComponentImage();
			let image2 = new ComponentImage();
			let image3 = new ComponentImage();
			let image4 = new ComponentImage();

			let touch = new ComponentTouch(
				{
					domComponent : canvas
				}
			);
			let slider = new EntitySlider(
				{
					canvas,
					images : [image1, image2, image3, image4],
				}
			)
			slider.touch = touch;

			assert.isTrue(slider.ready[0]);

			touch.domComponent = null;

			assert.isFalse(slider.ready[0]);

			touch.domComponent = canvas;

			assert.isTrue(slider.ready[0]);

		}
	);

});