use std::cell::UnsafeCell;
use std::ops::{DerefMut,Deref};
use std::borrow::{BorrowMut, Borrow};

#[cfg(feature = "serialize")]
use serde::ser::SerializeStruct;
#[cfg(any(feature = "serialize", feature="ecs"))]
use serde_derive::Deserialize;

/// A Lazy value that defers updates until the result is needed for the first time
#[derive(Debug)]
pub struct LazyUpdate<T>{
	value: UnsafeCell<T>,
	has_changed: UnsafeCell<bool>
}

impl<T: Clone> Clone for LazyUpdate<T>{
	fn clone(&self) -> LazyUpdate<T> {
		unsafe{
			LazyUpdate{
				value: UnsafeCell::new((*self.value.get()).clone()),
				has_changed: UnsafeCell::new(*self.has_changed.get()),
			}
		}
	}
}

#[cfg(feature = "serialize")]
impl <T: serde::Serialize> serde::Serialize for LazyUpdate<T>{
	fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<<S as serde::Serializer>::Ok, <S as serde::Serializer>::Error>{
		unsafe{
			let mut state = serializer.serialize_struct("Lazy", 2)?;
			state.serialize_field("value", &*self.value.get())?;
			state.serialize_field("has_changed", &*self.has_changed.get())?;
			state.end()
		}
	}
}


#[cfg(feature = "serialize")]
impl<'a, T: serde::Deserialize<'a>> serde::Deserialize<'a> for LazyUpdate<T>{
	fn deserialize<S: serde::Deserializer<'a>>(deserializer: S) -> Result<Self, <S as serde::Deserializer<'a>>::Error>{

		#[derive(Deserialize)]
		struct Value<T>{
			value: T,
			has_changed: bool
		}

		let value = Value::deserialize(deserializer);

		value.map(|v|{
			LazyUpdate{
				value: UnsafeCell::new(v.value),
				has_changed: UnsafeCell::new(v.has_changed)
			}
		})
	}
}

impl<T> LazyUpdate<T>{
	pub fn new(v: T) -> LazyUpdate<T>{
		LazyUpdate{ value: UnsafeCell::new(v), has_changed: UnsafeCell::new(false) }
	}

	pub fn new_dirty(v: T) -> LazyUpdate<T>{
		LazyUpdate{ value: UnsafeCell::new(v), has_changed: UnsafeCell::new(true) }
	}

	pub fn set_changed(&self){
		unsafe{ (*self.has_changed.get()) = true };
	}

	pub fn update<F>(&self, mut f: F)
		where F: FnMut(&mut T)
	{
		unsafe{
			if *self.has_changed.get(){
				f(&mut *self.value.get());
			}
			*self.has_changed.get() = false;
		}
	}

}

impl<T> Borrow<T> for LazyUpdate<T>{
	fn borrow(&self) -> &T{
		unsafe{
			&*self.value.get()
		}
	}
}

impl<T> BorrowMut<T> for LazyUpdate<T>{
	fn borrow_mut(&mut self) -> &mut T{
		unsafe{
			&mut *self.value.get()
		}
	}
}

impl<T> Deref for LazyUpdate<T>{
	type Target = T;
	fn deref(&self) -> &T{
		unsafe{
			&*self.value.get()
		}
	}
}

impl<T> DerefMut for LazyUpdate<T>{
	fn deref_mut(&mut self) -> &mut T{
		unsafe{
			&mut *self.value.get()
		}
	}
}

impl<T> AsRef<T> for LazyUpdate<T>{
	fn as_ref(&self) -> &T{
		unsafe{
			&*self.value.get()
		}
	}
}

impl<T> AsMut<T> for LazyUpdate<T>{
	fn as_mut(&mut self) -> &mut T{
		unsafe{
			&mut *self.value.get()
		}
	}
}

impl<T> From<T> for LazyUpdate<T>{
	fn from(t: T) -> LazyUpdate<T>{
		LazyUpdate::new(t)
	}
}


/// A Lazy value that defers computations until the
/// result is needed for the first time
pub struct Lazy<T>{
	func: UnsafeCell<Option<Box<dyn FnOnce() -> T>>>,
	value_cache: UnsafeCell<Option<T>>,
}

impl<T> Lazy<T>{
	pub fn defer<F>(f: F)-> Lazy<T>
	where F: FnOnce() -> T + 'static
	{
		let b: Box<dyn FnOnce() -> T> = Box::new(f);
		Lazy{
			func: UnsafeCell::new(Some(b)),
			value_cache: UnsafeCell::new(None)
		}
	}

	pub fn defer_with_input<F,I>(input: I, f: F)-> Lazy<T>
	where
		F: FnOnce(I) -> T + 'static,
		I: 'static,
	{
		let b: Box<dyn FnOnce() -> T> = Box::new(move || (f)(input));
		Lazy{
			func: UnsafeCell::new(Some(b)),
			value_cache: UnsafeCell::new(None)
		}
	}

	pub fn force(&self){
		unsafe{
			if (*self.value_cache.get()).is_none(){
				let f = (*self.func.get()).take().unwrap();
				*self.value_cache.get() = Some(f());
			}
		}
	}

	pub fn computed(t: T) -> Lazy<T> {
		Lazy{
			func: UnsafeCell::new(None),
			value_cache: UnsafeCell::new(Some(t))
		}
	}

	pub fn unwrap(self) -> T{
		self.force();
		self.value_cache.into_inner().unwrap()
	}
}

impl<T> Borrow<T> for Lazy<T>{
	fn borrow(&self) -> &T{
		self.force();
		unsafe{
			(*self.value_cache.get()).as_ref().unwrap()
		}
	}
}

impl<T> BorrowMut<T> for Lazy<T>{
	fn borrow_mut(&mut self) -> &mut T{
		self.force();
		unsafe{
			(*self.value_cache.get()).as_mut().unwrap()
		}
	}
}

impl<T> Deref for Lazy<T>{
	type Target = T;
	fn deref(&self) -> &T{
		self.force();
		unsafe{
			(*self.value_cache.get()).as_ref().unwrap()
		}
	}
}

impl<T> DerefMut for Lazy<T>{
	fn deref_mut(&mut self) -> &mut T{
		self.force();
		unsafe{
			(*self.value_cache.get()).as_mut().unwrap()
		}
	}
}

impl<T> From<T> for Lazy<T>{
	fn from(t: T) -> Lazy<T>{
		Lazy::computed(t)
	}
}