#![feature(array_try_from_fn)]
#![feature(associated_type_bounds)]
#![feature(iterator_try_collect)]

pub use enumset;
pub use flate2;
pub use paste;

#[cfg(feature = "random")]
pub use generate_random;

#[cfg(feature = "random")]
pub use rand;

#[cfg(feature = "serde")]
pub use serde;

use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
use enumset::{EnumSet, EnumSetType, EnumSetTypeWithRepr};
use mt_data_derive::mt_derive;
pub use mt_data_derive::{MtDeserialize, MtSerialize};
use paste::paste as paste_macro;
use std::{
    collections::{HashMap, HashSet},
    convert::Infallible,
    fmt,
    io::{self, Read, Write},
    num::TryFromIntError,
    ops::Deref,
};
use thiserror::Error;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

#[cfg(feature = "random")]
use generate_random::GenerateRandom;

#[cfg(any(feature = "client", feature = "server"))]
use crate as mt_data;

#[derive(Error, Debug)]
pub enum SerializeError {
    #[error("io error: {0}")]
    IoError(#[from] io::Error),
    #[error("collection too big: {0}")]
    TooBig(#[from] TryFromIntError),
}

impl From<Infallible> for SerializeError {
    fn from(_err: Infallible) -> Self {
        unreachable!("infallible")
    }
}

#[derive(Error, Debug)]
pub enum DeserializeError {
    #[error("io error: {0}")]
    IoError(io::Error),
    #[error("unexpected end of file")]
    UnexpectedEof,
    #[error("collection too big: {0}")]
    TooBig(#[from] TryFromIntError),
    #[error("invalid UTF-16: {0}")]
    InvalidUtf16(#[from] std::char::DecodeUtf16Error),
    #[error("unimplemented")]
    Unimplemented,
}

impl From<Infallible> for DeserializeError {
    fn from(_err: Infallible) -> Self {
        unreachable!("infallible")
    }
}

impl From<io::Error> for DeserializeError {
    fn from(err: io::Error) -> Self {
        if err.kind() == io::ErrorKind::UnexpectedEof {
            DeserializeError::UnexpectedEof
        } else {
            DeserializeError::IoError(err)
        }
    }
}

pub trait OrDefault<T> {
    fn or_default(self) -> Self;
}

impl<T: MtDeserialize + Default> OrDefault<T> for Result<T, DeserializeError> {
    fn or_default(self) -> Self {
        match self {
            Err(DeserializeError::UnexpectedEof) => Ok(T::default()),
            x => x,
        }
    }
}

pub trait MtCfg:
    Sized + MtSerialize + MtDeserialize + TryFrom<usize, Error: Into<SerializeError>>
{
    type Range: Iterator<Item = usize> + 'static;

    fn utf16() -> bool {
        false
    }

    fn var_len() -> bool;

    fn write_len(len: usize, writer: &mut impl Write) -> Result<(), SerializeError> {
        Self::try_from(len)
            .map_err(Into::into)?
            .mt_serialize::<DefCfg>(writer)
    }

    fn read_len(reader: &mut impl Read) -> Result<Self::Range, DeserializeError>;
}

trait MtCfgLen:
    Sized
    + MtSerialize
    + MtDeserialize
    + TryFrom<usize, Error: Into<SerializeError>>
    + TryInto<usize, Error: Into<DeserializeError>>
{
}

impl<T: MtCfgLen> MtCfg for T {
    type Range = std::ops::Range<usize>;

    fn var_len() -> bool {
        false
    }

    fn read_len(reader: &mut impl Read) -> Result<Self::Range, DeserializeError> {
        let len = Self::mt_deserialize::<DefCfg>(reader)?
            .try_into()
            .map_err(Into::into)?;

        Ok(0..len)
    }
}

pub type DefCfg = u16;

pub trait MtSerialize: Sized {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError>;
}

pub trait MtDeserialize: Sized {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError>;
}

impl MtCfgLen for u8 {}
impl MtCfgLen for u16 {}
impl MtCfgLen for u32 {}
impl MtCfgLen for u64 {}

#[derive(Debug)]
pub struct NoLen;

impl MtSerialize for NoLen {
    fn mt_serialize<C: MtCfg>(&self, _writer: &mut impl Write) -> Result<(), SerializeError> {
        Ok(())
    }
}

impl MtDeserialize for NoLen {
    fn mt_deserialize<C: MtCfg>(_reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(Self)
    }
}

impl TryFrom<usize> for NoLen {
    type Error = Infallible;

    fn try_from(_x: usize) -> Result<Self, Self::Error> {
        Ok(Self)
    }
}

impl MtCfg for NoLen {
    fn var_len() -> bool {
        true
    }

    type Range = std::ops::RangeFrom<usize>;

    fn read_len(_reader: &mut impl Read) -> Result<Self::Range, DeserializeError> {
        Ok(0..)
    }
}

pub struct Utf16<B: MtCfg>(pub B);

impl<B: MtCfg> MtSerialize for Utf16<B> {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        self.0.mt_serialize::<DefCfg>(writer)
    }
}

impl<B: MtCfg> MtDeserialize for Utf16<B> {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(Self(B::mt_deserialize::<DefCfg>(reader)?))
    }
}

impl<B: MtCfg> TryFrom<usize> for Utf16<B> {
    type Error = <usize as TryInto<B>>::Error;

    fn try_from(x: usize) -> Result<Self, Self::Error> {
        Ok(Self(x.try_into()?))
    }
}

impl<B: MtCfg> MtCfg for Utf16<B> {
    type Range = B::Range;

    fn utf16() -> bool {
        true
    }

    fn var_len() -> bool {
        B::var_len()
    }

    fn read_len(reader: &mut impl Read) -> Result<Self::Range, DeserializeError> {
        B::read_len(reader)
    }
}

impl MtSerialize for u8 {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        writer.write_u8(*self)?;
        Ok(())
    }
}

impl MtDeserialize for u8 {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(reader.read_u8()?)
    }
}

impl MtSerialize for i8 {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        writer.write_i8(*self)?;
        Ok(())
    }
}

impl MtDeserialize for i8 {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(reader.read_i8()?)
    }
}

macro_rules! impl_num {
    ($T:ty) => {
        impl MtSerialize for $T {
            fn mt_serialize<C: MtCfg>(
                &self,
                writer: &mut impl Write,
            ) -> Result<(), SerializeError> {
                paste_macro! {
                    writer.[<write_ $T>]::<BigEndian>(*self)?;
                }
                Ok(())
            }
        }

        impl MtDeserialize for $T {
            fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
                paste_macro! {
                    Ok(reader.[<read_ $T>]::<BigEndian>()?)
                }
            }
        }
    };
}

impl_num!(u16);
impl_num!(i16);

impl_num!(u32);
impl_num!(i32);
impl_num!(f32);

impl_num!(u64);
impl_num!(i64);
impl_num!(f64);

impl MtSerialize for () {
    fn mt_serialize<C: MtCfg>(&self, _writer: &mut impl Write) -> Result<(), SerializeError> {
        Ok(())
    }
}

impl MtDeserialize for () {
    fn mt_deserialize<C: MtCfg>(_reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(())
    }
}

impl MtSerialize for bool {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        (*self as u8).mt_serialize::<DefCfg>(writer)
    }
}

impl MtDeserialize for bool {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(u8::mt_deserialize::<DefCfg>(reader)? != 0)
    }
}

impl<T: MtSerialize> MtSerialize for &T {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        (*self).mt_serialize::<C>(writer)
    }
}

fn mt_serialize_seq<C: MtCfg, T: MtSerialize>(
    writer: &mut impl Write,
    iter: impl ExactSizeIterator + IntoIterator<Item = T>,
) -> Result<(), SerializeError> {
    C::write_len(iter.len(), writer)?;

    iter.into_iter()
        .try_for_each(|item| item.mt_serialize::<DefCfg>(writer))
}

fn mt_deserialize_seq<'a, C: MtCfg, T: MtDeserialize>(
    reader: &'a mut impl Read,
) -> Result<impl Iterator<Item = Result<T, DeserializeError>> + 'a, DeserializeError> {
    Ok(C::read_len(reader)?
        .into_iter()
        .map_while(|_| match T::mt_deserialize::<DefCfg>(reader) {
            Err(DeserializeError::UnexpectedEof) if C::var_len() => None,
            x => Some(x),
        }))
}

impl<T: MtSerialize, const N: usize> MtSerialize for [T; N] {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        mt_serialize_seq::<NoLen, _>(writer, self.iter())
    }
}

impl<T: MtDeserialize, const N: usize> MtDeserialize for [T; N] {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        std::array::try_from_fn(|_| T::mt_deserialize::<DefCfg>(reader))
    }
}

impl<T: MtSerialize, E: EnumSetTypeWithRepr<Repr = T>> MtSerialize for EnumSet<E> {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        self.as_repr().mt_serialize::<DefCfg>(writer)
    }
}

impl<T: MtDeserialize, E: EnumSetTypeWithRepr<Repr = T>> MtDeserialize for EnumSet<E> {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(Self::from_repr_truncated(T::mt_deserialize::<DefCfg>(
            reader,
        )?))
    }
}

impl<T: MtSerialize> MtSerialize for Option<T> {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        match self {
            Some(item) => item.mt_serialize::<C>(writer),
            None => Ok(()),
        }
    }
}

impl<T: MtDeserialize> MtDeserialize for Option<T> {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        T::mt_deserialize::<C>(reader).map(Some).or_default()
    }
}

impl<T: MtSerialize> MtSerialize for Vec<T> {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        mt_serialize_seq::<C, _>(writer, self.iter())
    }
}

impl<T: MtDeserialize> MtDeserialize for Vec<T> {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        mt_deserialize_seq::<C, _>(reader)?.try_collect()
    }
}

impl<T: MtSerialize + std::cmp::Eq + std::hash::Hash> MtSerialize for HashSet<T> {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        mt_serialize_seq::<C, _>(writer, self.iter())
    }
}

impl<T: MtDeserialize + std::cmp::Eq + std::hash::Hash> MtDeserialize for HashSet<T> {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        mt_deserialize_seq::<C, _>(reader)?.try_collect()
    }
}

impl<A: MtSerialize, B: MtSerialize> MtSerialize for (A, B) {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        self.0.mt_serialize::<DefCfg>(writer)?;
        self.1.mt_serialize::<DefCfg>(writer)?;

        Ok(())
    }
}

impl<A: MtDeserialize, B: MtDeserialize> MtDeserialize for (A, B) {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        let a = A::mt_deserialize::<DefCfg>(reader)?;
        let b = B::mt_deserialize::<DefCfg>(reader)?;

        Ok((a, b))
    }
}

impl<K, V> MtSerialize for HashMap<K, V>
where
    K: MtSerialize + std::cmp::Eq + std::hash::Hash,
    V: MtSerialize,
{
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        mt_serialize_seq::<C, _>(writer, self.iter())
    }
}

impl<K, V> MtDeserialize for HashMap<K, V>
where
    K: MtDeserialize + std::cmp::Eq + std::hash::Hash,
    V: MtDeserialize,
{
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        mt_deserialize_seq::<C, _>(reader)?.try_collect()
    }
}

impl MtSerialize for String {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        if C::utf16() {
            self.encode_utf16()
                .collect::<Vec<_>>() // FIXME: is this allocation necessary?
                .mt_serialize::<C>(writer)
        } else {
            mt_serialize_seq::<C, _>(writer, self.as_bytes().iter())
        }
    }
}

impl MtDeserialize for String {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        if C::utf16() {
            let mut err = None;

            let res =
                char::decode_utf16(mt_deserialize_seq::<C, _>(reader)?.map_while(|x| match x {
                    Ok(v) => Some(v),
                    Err(e) => {
                        err = Some(e);
                        None
                    }
                }))
                .try_collect();

            match err {
                None => Ok(res?),
                Some(e) => Err(e),
            }
        } else {
            // TODO: UTF-8 decode
            Ok("".into())
        }
    }
}

impl<T: MtSerialize> MtSerialize for Box<T> {
    fn mt_serialize<C: MtCfg>(&self, writer: &mut impl Write) -> Result<(), SerializeError> {
        self.deref().mt_serialize::<C>(writer)
    }
}

impl<T: MtDeserialize> MtDeserialize for Box<T> {
    fn mt_deserialize<C: MtCfg>(reader: &mut impl Read) -> Result<Self, DeserializeError> {
        Ok(Self::new(T::mt_deserialize::<C>(reader)?))
    }
}

mod to_clt;
mod to_srv;

pub use to_clt::*;
pub use to_srv::*;