mod real;

use core::marker::PhantomData;

use super::{
	Write,
	Serialize,
	Serializer
};

use self::real::{
	RealSerializer,
	PrimitiveRealSerializer,
	FastRealSerializer
};

use crate::grammar::*;

pub trait Config {
	type RealSerializer: RealSerializer;
}

pub struct DefaultConfig {}

impl Config for DefaultConfig {
	type RealSerializer = FastRealSerializer;
}

pub struct BaseSerializer<C: Config, W: Write> {
    out: W,
	cfg: PhantomData<C>
}

impl<C, W> BaseSerializer<C, W>
where
	C: Config,
	W: Write
{
	pub fn new(out: W) -> Self {
		Self { out, cfg: PhantomData }
	}

	pub fn into_inner(self) -> W {
		self.out
	}

	#[inline]
	pub fn serialize_real<R>(&mut self, r: R) -> Result<(), W::Error>
	where
		C::RealSerializer: PrimitiveRealSerializer<R>
	{
		C::RealSerializer::serialize_real::<W>(&mut self.out, r)
	}

	#[inline]
	fn write_delim(&mut self, delim: u8) -> Result<(), W::Error> {
		self.out.write(&[delim])
	}

	#[inline]
	fn write_utf8(&mut self, s: &str) -> Result<(), W::Error> {
		self.out.write(s.as_bytes())
	}
}

impl<C: Config, W: Write> Serializer for &mut BaseSerializer<C, W> {
	type Error = W::Error;

	#[inline]
	fn serialize_real_u8(self, real: u8) -> Result<(), Self::Error> {
		self.serialize_real::<u8>(real)
	}
	
	#[inline]
	fn serialize_real_u16(self, real: u16) -> Result<(), Self::Error> {
		self.serialize_real::<u16>(real)
	}

	#[inline]
	fn serialize_real_u32(self, real: u32) -> Result<(), Self::Error> {
		self.serialize_real::<u32>(real)
	}

	#[inline]
	fn serialize_real_u64(self, real: u64) -> Result<(), Self::Error> {
		self.serialize_real::<u64>(real)
	}

	#[inline]
	fn serialize_real_i8(self, real: i8) -> Result<(), Self::Error> {
		self.serialize_real::<i8>(real)
	}

	#[inline]
	fn serialize_real_i16(self, real: i16) -> Result<(), Self::Error> {
		self.serialize_real::<i16>(real)
	}

	#[inline]
	fn serialize_real_i32(self, real: i32) -> Result<(), Self::Error> {
		self.serialize_real::<i32>(real)
	}

	#[inline]
	fn serialize_real_i64(self, real: i64) -> Result<(), Self::Error> {
		self.serialize_real::<i64>(real)
	}

	#[inline]
	fn serialize_real_f32(self, real: f32) -> Result<(), Self::Error> {
		self.serialize_real::<f32>(real)
	}

	#[inline]
	fn serialize_real_f64(self, real: f64) -> Result<(), Self::Error> {
		self.serialize_real::<f64>(real)
	}

	#[inline]
	fn serialize_unit<'a, V>(self, name: &'a str, value: V) -> Result<(), Self::Error>
		where V: Serialize
	{
		self.serialize_atom(name)?;
		self.write_delim(GRAMMAR_PAREN_OPEN)?;
		self.serialize_any(value)?;
		self.write_delim(GRAMMAR_PAREN_CLOSE)
	}

	#[inline]
	fn serialize_atom<'a>(self, atom: &'a str) -> Result<(), Self::Error> {
		self.write_utf8(atom)
	}

	#[inline]
	fn serialize_text<'a>(self, text: &'a str) -> Result<(), Self::Error> {
		self.write_delim(GRAMMAR_QUOTE)?;
		self.write_utf8(text)?;
		self.write_delim(GRAMMAR_QUOTE)
	}

	#[inline]
	fn serialize_multiline_text<'a, M>(self, lines: M) -> Result<(), Self::Error>
		where M: IntoIterator<Item = &'a str>
	{
		self.write_delim(GRAMMAR_BTICK)?;
		for line in lines.into_iter() {
			self.serialize_text(line)?;
		}
		self.write_delim(GRAMMAR_BTICK)
	}

	#[inline]
	fn serialize_dict<K, V, D>(self, dict: D) -> Result<(), Self::Error>
	where
		K: Serialize,
		V: Serialize,
		D: IntoIterator<Item = (K, V)>
	{
		self.write_delim(GRAMMAR_BRACE_OPEN)?;
		let mut first = true;
		for (k, v) in dict.into_iter() {
			if first {
				first = false;
			} else {
				self.write_delim(GRAMMAR_COMMA)?;
			}
			self.serialize_any(&k)?;
			self.write_delim(GRAMMAR_COLON)?;
			self.serialize_any(&v)?;
		}
		self.write_delim(GRAMMAR_BRACE_CLOSE)
	}

	#[inline]
	fn serialize_list<T, L>(self, list: L) -> Result<(), Self::Error>
	where
		T: Serialize,
		L: IntoIterator<Item = T>
	{
		self.write_delim(GRAMMAR_BRKET_OPEN)?;
		let mut first = true;
		for v in list.into_iter() {
			if first {
				first = false;
			} else {
				self.write_delim(GRAMMAR_COMMA)?;
			}
			self.serialize_any(&v)?;
		}
		self.write_delim(GRAMMAR_BRKET_CLOSE)
	}
}