#[macro_use]
extern crate log;

pub mod node_registry;

pub mod document;
pub mod proto;

#[cfg(test)]
mod tests {

	use std::marker::PhantomData;

	use graphene_core::value::ValueNode;
	use graphene_core::{structural::*, RefNode};

	use borrow_stack::BorrowStack;
	use borrow_stack::FixedSizeStack;
	use dyn_any::{downcast, IntoDynAny};
	use graphene_std::any::{Any, DowncastNode, DynAnyNode, TypeErasedNode};
	use graphene_std::ops::AddNode;

	#[test]
	fn borrow_stack() {
		let stack = borrow_stack::FixedSizeStack::new(256);
		unsafe {
			let dynanynode: DynAnyNode<ValueNode<u32>, (), _, _> = DynAnyNode::new(ValueNode(2_u32));
			stack.push(dynanynode.into_box());
		}
		stack.push_fn(|nodes| {
			let pre_node = nodes.get(0).unwrap();
			let downcast: DowncastNode<&TypeErasedNode, &u32> = DowncastNode::new(pre_node);
			let dynanynode: DynAnyNode<ConsNode<_, Any<'_>>, u32, _, _> = DynAnyNode::new(ConsNode(downcast, PhantomData));
			dynanynode.into_box()
		});
		stack.push_fn(|_| {
			let dynanynode: DynAnyNode<_, (u32, &u32), _, _> = DynAnyNode::new(AddNode);
			dynanynode.into_box()
		});
		stack.push_fn(|nodes| {
			let compose_node = nodes[1].after(&nodes[2]);
			TypeErasedNode(Box::new(compose_node))
		});

		let result = unsafe { &stack.get()[0] }.eval_ref(().into_dyn());
		assert_eq!(*downcast::<&u32>(result).unwrap(), &2_u32);
		let result = unsafe { &stack.get()[1] }.eval_ref(4_u32.into_dyn());
		assert_eq!(*downcast::<(u32, &u32)>(result).unwrap(), (4_u32, &2_u32));
		let result = unsafe { &stack.get()[1] }.eval_ref(4_u32.into_dyn());
		let add = unsafe { &stack.get()[2] }.eval_ref(result);
		assert_eq!(*downcast::<u32>(add).unwrap(), 6_u32);
		let add = unsafe { &stack.get()[3] }.eval_ref(4_u32.into_dyn());
		assert_eq!(*downcast::<u32>(add).unwrap(), 6_u32);
	}

	#[test]
	fn execute_add() {
		use crate::document::*;
		use crate::node_registry::push_node;
		use crate::proto::*;
		use graphene_core::Node;

		fn add_network() -> NodeNetwork {
			NodeNetwork {
				inputs: vec![0, 0],
				output: 1,
				nodes: [
					(
						0,
						DocumentNode {
							name: "cons".into(),
							inputs: vec![NodeInput::Network, NodeInput::Network],
							implementation: DocumentNodeImplementation::Unresolved(NodeIdentifier::new(
								"graphene_core::structural::ConsNode",
								&[Type::Concrete(std::borrow::Cow::Borrowed("u32")), Type::Concrete(std::borrow::Cow::Borrowed("u32"))],
							)),
						},
					),
					(
						1,
						DocumentNode {
							name: "add".into(),
							inputs: vec![NodeInput::Node(0)],
							implementation: DocumentNodeImplementation::Unresolved(NodeIdentifier::new(
								"graphene_core::ops::AddNode",
								&[Type::Concrete(std::borrow::Cow::Borrowed("u32")), Type::Concrete(std::borrow::Cow::Borrowed("u32"))],
							)),
						},
					),
				]
				.into_iter()
				.collect(),
			}
		}

		let mut network = NodeNetwork {
			inputs: vec![0],
			output: 0,
			nodes: [(
				0,
				DocumentNode {
					name: "Inc".into(),
					inputs: vec![NodeInput::Network, NodeInput::Value(value::TaggedValue::U32(1))],
					implementation: DocumentNodeImplementation::Network(add_network()),
				},
			)]
			.into_iter()
			.collect(),
		};

		let stack = FixedSizeStack::new(256);
		println!("flattening");
		network.flatten(0);
		//println!("flat_network: {:#?}", network);
		let mut proto_network = network.into_proto_network();
		proto_network.reorder_ids();
		//println!("reordered_ides: {:#?}", proto_network);
		for (_id, node) in proto_network.nodes {
			push_node(node, &stack);
		}

		let result = unsafe { stack.get().last().unwrap().eval(32_u32.into_dyn()) };
		let val = *dyn_any::downcast::<u32>(result).unwrap();
		assert_eq!(val, 33_u32);
	}
}