//use rand::Rng;
use std::{collections::{hash_map::Entry, HashMap}, fmt, sync::{Arc, RwLock}};

use super::builder::LocalNodeBuilder;
use crate::{descriptor::ObjectDescriptor, events::{EventMerge, EventMergeInput}, node::core::NodeCore, object::core::ObjectCore, tag::core::TagCore, TagDescriptor};

/// Main access point to the Hakuban network
#[derive(Clone)]
pub struct LocalNode {
	pub(crate) shared: Arc<LocalNodeShared>,
}

pub(crate) struct LocalNodeShared {
	pub(crate) node_core: Option<Arc<NodeCore>>,
	objects: RwLock<HashMap<ObjectDescriptor, ObjectAllocation>>,
	tags: RwLock<HashMap<TagDescriptor, TagAllocation>>,
	objects_changes: EventMerge<ObjectDescriptor>,
	tags_changes: EventMerge<TagDescriptor>,
}

struct ObjectAllocation {
	object_core: Arc<ObjectCore>,
	users_count: usize,
	//we keep this only to be droppen when allocation is dropped
	_registered_merge_input: EventMergeInput<ObjectDescriptor>,
}

struct TagAllocation {
	tag_core: Arc<TagCore>,
	users_count: usize,
	//we keep this only to be droppen when allocation is dropped
	_registered_merge_input: EventMergeInput<TagDescriptor>,
}


impl LocalNode {
	pub(super) fn new(name: Option<String>, capacity: Option<u32>, limit: Option<u32>) -> LocalNode {
		LocalNode {
			shared: Arc::new(LocalNodeShared {
				node_core: Some(NodeCore::new(false, capacity, limit, name)),
				objects: RwLock::new(HashMap::new()),
				tags: RwLock::new(HashMap::new()),
				objects_changes: EventMerge::new(),
				tags_changes: EventMerge::new(),
			}),
		}
	}

	pub fn builder() -> LocalNodeBuilder {
		LocalNodeBuilder::new()
	}

	pub fn object(&self, descriptor: impl Into<ObjectDescriptor>) -> crate::object::builder::ObjectContractBuilder {
		self.shared.object(descriptor.into())
	}

	pub fn tag(&self, descriptor: impl Into<TagDescriptor>) -> crate::tag::builder::TagContractBuilder {
		self.shared.tag(descriptor.into())
	}
}


impl LocalNodeShared {
	pub fn local_node(self: &Arc<Self>) -> LocalNode {
		LocalNode { shared: self.clone() }
	}

	fn object(self: &Arc<Self>, descriptor: ObjectDescriptor) -> crate::object::builder::ObjectContractBuilder {
		crate::object::builder::ObjectContractBuilder::new(self.local_node(), descriptor)
	}

	fn tag(self: &Arc<Self>, descriptor: TagDescriptor) -> crate::tag::builder::TagContractBuilder {
		crate::tag::builder::TagContractBuilder::new(self.local_node(), descriptor)
	}

	pub(crate) fn object_acquire(self: &Arc<Self>, descriptor: &ObjectDescriptor) -> Arc<ObjectCore> {
		match self.objects.write().unwrap().entry(descriptor.clone()) {
			Entry::Occupied(mut entry) => {
				entry.get_mut().users_count += 1;
				entry.get().object_core.clone()
			}
			Entry::Vacant(entry) => {
				let tags: HashMap<TagDescriptor, Arc<TagCore>> =
					descriptor.tags.iter().map(|tag_descriptor| (tag_descriptor.clone(), self.tag_acquire(tag_descriptor))).collect();
				let object_core = Arc::new(ObjectCore::new(descriptor.clone(), tags.clone()));
				entry.insert(ObjectAllocation {
					object_core: object_core.clone(),
					users_count: 1,
					_registered_merge_input: self.objects_changes.include(object_core.changes()),
				});
				for tag in tags.values() {
					tag.object_insert(object_core.clone());
				}
				object_core
			}
		}
	}

	pub(crate) fn tag_acquire(self: &Arc<Self>, descriptor: &TagDescriptor) -> Arc<TagCore> {
		match self.tags.write().unwrap().entry(descriptor.clone()) {
			Entry::Occupied(mut entry) => {
				entry.get_mut().users_count += 1;
				entry.get().tag_core.clone()
			}
			Entry::Vacant(entry) => {
				let tag = Arc::new(TagCore::new(descriptor.clone()));
				entry.insert(TagAllocation { tag_core: tag.clone(), users_count: 1, _registered_merge_input: self.tags_changes.include(tag.changes()) });
				tag
			}
		}
	}

	pub(crate) fn object_release(self: &Arc<Self>, descriptor: &ObjectDescriptor) {
		match self.objects.write().unwrap().entry(descriptor.clone()) {
			Entry::Occupied(mut entry) => {
				entry.get_mut().users_count -= 1;
				if entry.get().users_count == 0 {
					let object_core = entry.remove().object_core;
					object_core.destroy();
					assert_eq!(Arc::strong_count(&object_core), 1);
					drop(object_core);
				}
			}
			Entry::Vacant(_entry) => {
				panic!();
			}
		}
	}

	pub(crate) fn tag_release(self: &Arc<Self>, descriptor: &TagDescriptor) {
		match self.tags.write().unwrap().entry(descriptor.clone()) {
			Entry::Occupied(mut entry) => {
				entry.get_mut().users_count -= 1;
				if entry.get().users_count == 0 {
					let tag_core = entry.remove().tag_core;
					assert_eq!(Arc::strong_count(&tag_core), 1);
					drop(tag_core);
				}
			}
			Entry::Vacant(_entry) => {
				panic!();
			}
		}
	}

	pub(crate) fn objects_changes(&self) -> EventMerge<ObjectDescriptor> {
		self.objects_changes.clone()
	}

	pub(crate) fn tags_changes(&self) -> EventMerge<TagDescriptor> {
		self.tags_changes.clone()
	}

	#[doc(hidden)]
	#[allow(dead_code)]
	pub fn inspect(self: &Arc<Self>) -> String {
		let mut ret = format!(
			"┌───────────────────────────────────────────────────────────────────── {}\n",
			*self.node_core.as_ref().unwrap().name.read().unwrap().as_ref().unwrap()
		);
		for (_descriptor, object) in self.objects.read().unwrap().iter() {
			ret.push_str(&object.object_core.inspect(None));
		}
		for (_descriptor, tag) in self.tags.read().unwrap().iter() {
			ret.push_str(&tag.tag_core.inspect());
		}
		ret.push_str("└╼");
		ret
	}
}


impl fmt::Debug for LocalNode {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		f.write_fmt(format_args!("LocalNode({})", self.shared.node_core.as_ref().unwrap().name.read().unwrap().as_ref().unwrap()))
	}
}