#![doc=include_str!("../../doc/serdes/slice.md")]

#[cfg(feature = "alloc")]
use alloc::vec::Vec;
use core::{
	any,
	fmt::{
		self,
		Formatter,
	},
	marker::PhantomData,
};

use serde::{
	de::{
		Deserialize,
		Deserializer,
		Error,
		MapAccess,
		SeqAccess,
		Visitor,
	},
	ser::{
		Serialize,
		SerializeStruct,
		Serializer,
	},
};
use wyz::comu::Const;

use super::{
	utils::TypeName,
	Field,
	FIELDS,
};
#[cfg(feature = "alloc")]
use crate::{
	boxed::BitBox,
	vec::BitVec,
};
use crate::{
	index::BitIdx,
	mem::bits_of,
	order::BitOrder,
	ptr::{
		AddressExt,
		BitSpan,
		BitSpanError,
	},
	slice::BitSlice,
	store::BitStore,
};

impl<T, O> Serialize for BitSlice<T, O>
where
	T: BitStore,
	O: BitOrder,
	T::Mem: Serialize,
{
	#[inline]
	fn serialize<S>(&self, serializer: S) -> super::Result<S>
	where S: Serializer {
		let head = self.as_bitspan().head();
		let mut state = serializer.serialize_struct("BitSeq", FIELDS.len())?;

		state.serialize_field("order", &any::type_name::<O>())?;
		state.serialize_field("head", &head)?;
		state.serialize_field("bits", &(self.len() as u64))?;
		state.serialize_field("data", &self.domain())?;

		state.end()
	}
}

#[cfg(feature = "alloc")]
impl<T, O> Serialize for BitBox<T, O>
where
	T: BitStore,
	O: BitOrder,
	BitSlice<T, O>: Serialize,
{
	#[inline]
	fn serialize<S>(&self, serializer: S) -> super::Result<S>
	where S: Serializer {
		self.as_bitslice().serialize(serializer)
	}
}

#[cfg(feature = "alloc")]
impl<T, O> Serialize for BitVec<T, O>
where
	T: BitStore,
	O: BitOrder,
	BitSlice<T, O>: Serialize,
{
	#[inline]
	fn serialize<S>(&self, serializer: S) -> super::Result<S>
	where S: Serializer {
		self.as_bitslice().serialize(serializer)
	}
}

impl<'de, O> Deserialize<'de> for &'de BitSlice<u8, O>
where O: BitOrder
{
	#[inline]
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where D: Deserializer<'de> {
		deserializer.deserialize_struct(
			"BitSeq",
			FIELDS,
			BitSeqVisitor::<u8, O, &'de [u8], Self, _>::new(
				|data, head, bits| unsafe {
					BitSpan::new(data.as_ptr().into_address(), head, bits)
						.map(|span| BitSpan::into_bitslice_ref(span))
				},
			),
		)
	}
}

#[cfg(feature = "alloc")]
impl<'de, T, O> Deserialize<'de> for BitBox<T, O>
where
	T: BitStore,
	O: BitOrder,
	Vec<T>: Deserialize<'de>,
{
	#[inline]
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where D: Deserializer<'de> {
		<BitVec<T, O> as Deserialize<'de>>::deserialize(deserializer)
			.map(BitVec::into_boxed_bitslice)
	}
}

#[cfg(feature = "alloc")]
impl<'de, T, O> Deserialize<'de> for BitVec<T, O>
where
	T: BitStore,
	O: BitOrder,
	Vec<T>: Deserialize<'de>,
{
	#[inline]
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where D: Deserializer<'de> {
		deserializer.deserialize_struct(
			"BitSeq",
			FIELDS,
			BitSeqVisitor::<T, O, Vec<T>, Self, _>::new(
				|vec, head, bits| unsafe {
					let addr = vec.as_ptr().into_address();
					let mut bv = BitVec::try_from_vec(vec).map_err(|_| {
						BitSpan::<Const, T, O>::new(addr, head, bits)
							.unwrap_err()
					})?;
					bv.set_head(head);
					bv.set_len(bits);
					Ok(bv)
				},
			),
		)
	}
}

/// Assists in deserialization of a dynamic `BitSeq`.
struct BitSeqVisitor<T, O, In, Out, Func>
where
	T: BitStore,
	O: BitOrder,
	Func: FnOnce(In, BitIdx<T::Mem>, usize) -> Result<Out, BitSpanError<T>>,
{
	/// As well as a final output value.
	out:   PhantomData<Result<Out, BitSpanError<T>>>,
	/// The deserialized bit-ordering string.
	order: Option<TypeName<O>>,
	/// The deserialized head-bit index.
	head:  Option<BitIdx<T::Mem>>,
	/// The deserialized bit-count.
	bits:  Option<u64>,
	/// The deserialized data buffer.
	data:  Option<In>,
	/// A functor responsible for final transformation of the deserialized
	/// components into the output value.
	func:  Func,
}

impl<'de, T, O, In, Out, Func> BitSeqVisitor<T, O, In, Out, Func>
where
	T: 'de + BitStore,
	O: BitOrder,
	In: Deserialize<'de>,
	Func: FnOnce(In, BitIdx<T::Mem>, usize) -> Result<Out, BitSpanError<T>>,
{
	/// Creates a new visitor with a given transform functor.
	#[inline]
	fn new(func: Func) -> Self {
		Self {
			out: PhantomData,
			order: None,
			head: None,
			bits: None,
			data: None,
			func,
		}
	}

	/// Attempts to assemble deserialized components into an output value.
	#[inline]
	fn assemble<E>(mut self) -> Result<Out, E>
	where E: Error {
		self.order.take().ok_or_else(|| E::missing_field("order"))?;
		let head = self.head.take().ok_or_else(|| E::missing_field("head"))?;
		let bits = self.bits.take().ok_or_else(|| E::missing_field("bits"))?;
		let data = self.data.take().ok_or_else(|| E::missing_field("data"))?;

		(self.func)(data, head, bits as usize).map_err(|_| todo!())
	}
}

impl<'de, T, O, In, Out, Func> Visitor<'de>
	for BitSeqVisitor<T, O, In, Out, Func>
where
	T: 'de + BitStore,
	O: BitOrder,
	In: Deserialize<'de>,
	Func: FnOnce(In, BitIdx<T::Mem>, usize) -> Result<Out, BitSpanError<T>>,
{
	type Value = Out;

	#[inline]
	fn expecting(&self, fmt: &mut Formatter) -> fmt::Result {
		write!(
			fmt,
			"a `BitSlice<u{}, {}>`",
			bits_of::<T::Mem>(),
			any::type_name::<O>(),
		)
	}

	#[inline]
	fn visit_seq<V>(mut self, mut seq: V) -> Result<Self::Value, V::Error>
	where V: SeqAccess<'de> {
		self.order = Some(
			seq.next_element()?
				.ok_or_else(|| <V::Error>::invalid_length(0, &self))?,
		);
		self.head = Some(
			seq.next_element()?
				.ok_or_else(|| <V::Error>::invalid_length(1, &self))?,
		);
		self.bits = Some(
			seq.next_element()?
				.ok_or_else(|| <V::Error>::invalid_length(2, &self))?,
		);
		self.data = Some(
			seq.next_element()?
				.ok_or_else(|| <V::Error>::invalid_length(3, &self))?,
		);

		self.assemble()
	}

	#[inline]
	fn visit_map<V>(mut self, mut map: V) -> Result<Self::Value, V::Error>
	where V: MapAccess<'de> {
		while let Some(key) = map.next_key()? {
			match key {
				Field::Order => {
					if self.order.replace(map.next_value()?).is_some() {
						return Err(<V::Error>::duplicate_field("order"));
					}
				},
				Field::Head => {
					if self.head.replace(map.next_value()?).is_some() {
						return Err(<V::Error>::duplicate_field("head"));
					}
				},
				Field::Bits => {
					if self.bits.replace(map.next_value()?).is_some() {
						return Err(<V::Error>::duplicate_field("bits"));
					}
				},
				Field::Data => {
					if self.data.replace(map.next_value()?).is_some() {
						return Err(<V::Error>::duplicate_field("data"));
					}
				},
			}
		}

		self.assemble()
	}
}

#[cfg(test)]
mod tests {
	#[cfg(all(feature = "alloc", not(feature = "std")))]
	use alloc::format;
	use core::any;

	use serde_test::{
		assert_de_tokens,
		assert_de_tokens_error,
		assert_ser_tokens,
		Token,
	};

	use crate::prelude::*;

	#[test]
	#[cfg(feature = "alloc")]
	fn roundtrip() -> Result<(), alloc::boxed::Box<bincode::ErrorKind>> {
		let bits = bits![u8, Msb0; 1, 0, 1, 1, 0];
		let encoded = bincode::serialize(&bits)?;
		let bits2 = bincode::deserialize::<&BitSlice<u8, Msb0>>(&encoded)?;
		assert_eq!(bits, bits2);
		Ok(())
	}

	#[test]
	fn tokens() {
		let slice = bits![u8, Lsb0; 0, 1, 0, 0, 1];
		let tokens = &mut [
			Token::Struct {
				name: "BitSeq",
				len:  4,
			},
			Token::Str("order"),
			Token::Str(any::type_name::<Lsb0>()),
			Token::Str("head"),
			Token::Struct {
				name: "BitIdx",
				len:  2,
			},
			Token::Str("width"),
			Token::U8(8),
			Token::Str("index"),
			Token::U8(0),
			Token::StructEnd,
			Token::Str("bits"),
			Token::U64(5),
			Token::Str("data"),
			Token::Seq { len: Some(1) },
			Token::U8(18),
			Token::SeqEnd,
			Token::StructEnd,
		];
		assert_ser_tokens(&slice, tokens);
		tokens[8] = Token::U8(1);
		tokens[11] = Token::U64(4);
		assert_ser_tokens(&&slice[1 ..], tokens);

		let tokens = &[
			Token::Seq { len: Some(4) },
			Token::BorrowedStr(any::type_name::<Lsb0>()),
			Token::Seq { len: Some(2) },
			Token::U8(8),
			Token::U8(0),
			Token::SeqEnd,
			Token::U64(5),
			Token::BorrowedBytes(&[18]),
			Token::SeqEnd,
		];
		assert_de_tokens(&slice, tokens);
	}

	#[test]
	#[cfg(feature = "alloc")]
	fn errors() {
		assert_de_tokens_error::<&BitSlice<u8, Msb0>>(
			&[
				Token::Seq { len: Some(4) },
				Token::BorrowedStr(any::type_name::<Lsb0>()),
			],
			&format!(
				"invalid value: string \"{}\", expected the string \"{}\"",
				any::type_name::<Lsb0>(),
				any::type_name::<Msb0>(),
			),
		);

		assert_de_tokens_error::<&BitSlice<u8, Msb0>>(
			&[
				Token::Struct {
					name: "BitSeq",
					len:  1,
				},
				Token::BorrowedStr("unknown"),
			],
			&format!(
				"unknown field `unknown`, expected one of `{}`",
				super::FIELDS.join("`, `"),
			),
		);

		assert_de_tokens_error::<&BitSlice<u8, Msb0>>(
			&[
				Token::Struct {
					name: "BitSeq",
					len:  2,
				},
				Token::BorrowedStr("order"),
				Token::BorrowedStr(any::type_name::<Msb0>()),
				Token::BorrowedStr("order"),
				Token::BorrowedStr(any::type_name::<Msb0>()),
				Token::StructEnd,
			],
			"duplicate field `order`",
		);
		assert_de_tokens_error::<&BitSlice<u8, Msb0>>(
			&[
				Token::Struct {
					name: "BitSeq",
					len:  2,
				},
				Token::BorrowedStr("head"),
				Token::Seq { len: Some(2) },
				Token::U8(8),
				Token::U8(0),
				Token::SeqEnd,
				Token::BorrowedStr("head"),
				Token::Seq { len: Some(2) },
				Token::U8(8),
				Token::U8(0),
				Token::SeqEnd,
				Token::StructEnd,
			],
			"duplicate field `head`",
		);
		assert_de_tokens_error::<&BitSlice<u8, Msb0>>(
			&[
				Token::Struct {
					name: "BitSeq",
					len:  2,
				},
				Token::BorrowedStr("bits"),
				Token::U64(10),
				Token::BorrowedStr("bits"),
				Token::U64(10),
				Token::StructEnd,
			],
			"duplicate field `bits`",
		);
		assert_de_tokens_error::<&BitSlice<u8, Msb0>>(
			&[
				Token::Struct {
					name: "BitSeq",
					len:  2,
				},
				Token::BorrowedStr("data"),
				Token::BorrowedBytes(&[0x3C, 0xA5]),
				Token::BorrowedStr("data"),
				Token::BorrowedBytes(&[0x3C, 0xA5]),
				Token::StructEnd,
			],
			"duplicate field `data`",
		);
	}
}