use std::error::Error;
use std::fmt;

use crate::content;
use crate::data::command::{self, UnitCommand};
use crate::data::{self, DataRead, DataWrite, GridPos, Serializer};
use crate::logic::LogicField;
use crate::team::Team;

#[derive(Clone, Debug, PartialEq)]
pub enum DynData {
    Empty,
    Int(i32),
    Long(i64),
    Float(f32),
    String(Option<String>),
    Content(content::Type, u16),
    IntArray(Vec<i32>),
    Point2(i32, i32),
    Point2Array(Vec<(i16, i16)>),
    TechNode(content::Type, u16),
    Boolean(bool),
    Double(f64),
    Building(GridPos),
    LogicField(LogicField),
    ByteArray(Vec<u8>),
    UnitCommand(UnitCommand),
    BoolArray(Vec<bool>),
    Unit(u32),
    Vec2Array(Vec<(f32, f32)>),
    Vec2(f32, f32),
    Team(Team),
}

impl DynData {
    #[must_use]
    pub fn get_type(&self) -> DynType {
        match self {
            Self::Empty => DynType::Empty,
            Self::Int(..) => DynType::Int,
            Self::Long(..) => DynType::Long,
            Self::Float(..) => DynType::Float,
            Self::String(..) => DynType::String,
            Self::Content(..) => DynType::Content,
            Self::IntArray(..) => DynType::IntArray,
            Self::Point2(..) => DynType::Point2,
            Self::Point2Array(..) => DynType::Point2Array,
            Self::TechNode(..) => DynType::TechNode,
            Self::Boolean(..) => DynType::Boolean,
            Self::Double(..) => DynType::Double,
            Self::Building(..) => DynType::Building,
            Self::LogicField(..) => DynType::LogicField,
            Self::ByteArray(..) => DynType::ByteArray,
            Self::UnitCommand(..) => DynType::UnitCommand,
            Self::BoolArray(..) => DynType::BoolArray,
            Self::Unit(..) => DynType::Unit,
            Self::Vec2Array(..) => DynType::Vec2Array,
            Self::Vec2(..) => DynType::Vec2,
            Self::Team(..) => DynType::Team,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DynType {
    Empty,
    Int,
    Long,
    Float,
    String,
    Content,
    IntArray,
    Point2,
    Point2Array,
    TechNode,
    Boolean,
    Double,
    Building,
    LogicField,
    ByteArray,
    UnitCommand,
    BoolArray,
    Unit,
    Vec2Array,
    Vec2,
    Team,
}

pub struct DynSerializer;

impl Serializer<DynData> for DynSerializer {
    type ReadError = ReadError;
    type WriteError = WriteError;

    fn deserialize(&mut self, buff: &mut DataRead<'_>) -> Result<DynData, Self::ReadError> {
        match buff.read_u8()? {
            0 => Ok(DynData::Empty),
            1 => Ok(DynData::Int(buff.read_i32()?)),
            2 => Ok(DynData::Long(buff.read_i64()?)),
            3 => Ok(DynData::Float(buff.read_f32()?)),
            4 => {
                if buff.read_bool()? {
                    Ok(DynData::String(Some(String::from(buff.read_utf()?))))
                } else {
                    Ok(DynData::String(None))
                }
            }
            5 => Ok(DynData::Content(
                content::Type::try_from(buff.read_u8()?)?,
                buff.read_u16()?,
            )),
            6 => {
                let len = buff.read_i16()?;
                if len < 0 {
                    return Err(ReadError::IntArrayLen(len));
                }
                let mut result = Vec::<i32>::new();
                result.reserve(len as usize);
                for _ in 0..len {
                    result.push(buff.read_i32()?);
                }
                Ok(DynData::IntArray(result))
            }
            7 => Ok(DynData::Point2(buff.read_i32()?, buff.read_i32()?)),
            8 => {
                let len = buff.read_i8()?;
                if len < 0 {
                    return Err(ReadError::Point2ArrayLen(len));
                }
                let mut result = Vec::<(i16, i16)>::new();
                result.reserve(len as usize);
                for _ in 0..len {
                    let pt = buff.read_i32()?;
                    result.push(((pt >> 16) as i16, pt as i16));
                }
                Ok(DynData::Point2Array(result))
            }
            9 => Ok(DynData::TechNode(
                content::Type::try_from(buff.read_u8()?)?,
                buff.read_u16()?,
            )),
            10 => Ok(DynData::Boolean(buff.read_bool()?)),
            11 => Ok(DynData::Double(buff.read_f64()?)),
            12 => Ok(DynData::Building(GridPos::from(buff.read_u32()?))),
            13 => {
                let id = buff.read_u8()?;
                match LogicField::try_from(id) {
                    Ok(f) => Ok(DynData::LogicField(f)),
                    Err(..) => Err(ReadError::LogicField(id)),
                }
            }
            14 => {
                let len = buff.read_i32()?;
                if len < 0 {
                    return Err(ReadError::ByteArrayLen(len));
                }
                let mut result = Vec::<u8>::new();
                buff.read_vec(&mut result, len as usize)?;
                Ok(DynData::ByteArray(result))
            }
            15 => {
                let id = buff.read_u8()?;
                match UnitCommand::try_from(id) {
                    Ok(f) => Ok(DynData::UnitCommand(f)),
                    Err(e) => Err(ReadError::UnitCommand(e)),
                }
            }
            16 => {
                let len = buff.read_i32()?;
                if len < 0 {
                    return Err(ReadError::BoolArrayLen(len));
                }
                let mut result = Vec::<bool>::new();
                result.reserve(len as usize);
                for _ in 0..len {
                    result.push(buff.read_bool()?);
                }
                Ok(DynData::BoolArray(result))
            }
            17 => Ok(DynData::Unit(buff.read_u32()?)),
            18 => {
                let len = buff.read_i16()?;
                if len < 0 {
                    return Err(ReadError::Vec2ArrayLen(len));
                }
                let mut result = Vec::<(f32, f32)>::new();
                result.reserve(len as usize);
                for _ in 0..len {
                    result.push((buff.read_f32()?, buff.read_f32()?));
                }
                Ok(DynData::Vec2Array(result))
            }
            19 => Ok(DynData::Vec2(buff.read_f32()?, buff.read_f32()?)),
            20 => Ok(DynData::Team(Team::of(buff.read_u8()?))),
            id => Err(ReadError::Type(id)),
        }
    }

    fn serialize(
        &mut self,
        buff: &mut DataWrite<'_>,
        data: &DynData,
    ) -> Result<(), Self::WriteError> {
        match data {
            DynData::Empty => {
                buff.write_u8(0)?;
                Ok(())
            }
            DynData::Int(val) => {
                buff.write_u8(1)?;
                buff.write_i32(*val)?;
                Ok(())
            }
            DynData::Long(val) => {
                buff.write_u8(2)?;
                buff.write_i64(*val)?;
                Ok(())
            }
            DynData::Float(val) => {
                buff.write_u8(3)?;
                buff.write_f32(*val)?;
                Ok(())
            }
            DynData::String(opt) => {
                buff.write_u8(4)?;
                match opt {
                    None => buff.write_bool(false)?,
                    Some(s) => {
                        buff.write_bool(true)?;
                        buff.write_utf(s)?;
                    }
                }
                Ok(())
            }
            DynData::Content(ty, id) => {
                buff.write_u8(5)?;
                buff.write_u8((*ty).into())?;
                buff.write_u16(*id)?;
                Ok(())
            }
            DynData::IntArray(arr) => {
                if arr.len() > i16::MAX as usize {
                    return Err(WriteError::IntArrayLen(arr.len()));
                }
                buff.write_u8(6)?;
                buff.write_i16(arr.len() as i16)?;
                for &v in arr.iter() {
                    buff.write_i32(v)?;
                }
                Ok(())
            }
            DynData::Point2(x, y) => {
                buff.write_u8(7)?;
                buff.write_i32(*x)?;
                buff.write_i32(*y)?;
                Ok(())
            }
            DynData::Point2Array(arr) => {
                if arr.len() > i8::MAX as usize {
                    return Err(WriteError::Point2ArrayLen(arr.len()));
                }
                buff.write_u8(8)?;
                buff.write_i8(arr.len() as i8)?;
                for &(x, y) in arr.iter() {
                    buff.write_i32((i32::from(x) << 16) | (i32::from(y) & 0xFFFF))?;
                }
                Ok(())
            }
            DynData::TechNode(ty, id) => {
                buff.write_u8(9)?;
                buff.write_u8((*ty).into())?;
                buff.write_u16(*id)?;
                Ok(())
            }
            DynData::Boolean(val) => {
                buff.write_u8(10)?;
                buff.write_bool(*val)?;
                Ok(())
            }
            DynData::Double(val) => {
                buff.write_u8(11)?;
                buff.write_f64(*val)?;
                Ok(())
            }
            DynData::Building(pos) => {
                buff.write_u8(12)?;
                buff.write_u32(u32::from(*pos))?;
                Ok(())
            }
            DynData::LogicField(fld) => {
                buff.write_u8(13)?;
                buff.write_u8(u8::from(*fld))?;
                Ok(())
            }
            DynData::ByteArray(arr) => {
                if arr.len() > i32::MAX as usize {
                    return Err(WriteError::ByteArrayLen(arr.len()));
                }
                buff.write_u8(14)?;
                buff.write_i32(arr.len() as i32)?;
                buff.write_bytes(arr)?;
                Ok(())
            }
            DynData::UnitCommand(cmd) => {
                buff.write_u8(15)?;
                buff.write_u8(u8::from(*cmd))?;
                Ok(())
            }
            DynData::BoolArray(arr) => {
                if arr.len() > i32::MAX as usize {
                    return Err(WriteError::BoolArrayLen(arr.len()));
                }
                buff.write_u8(16)?;
                buff.write_i32(arr.len() as i32)?;
                for &b in arr.iter() {
                    buff.write_bool(b)?;
                }
                Ok(())
            }
            DynData::Unit(id) => {
                buff.write_u8(17)?;
                buff.write_u32(*id)?;
                Ok(())
            }
            DynData::Vec2Array(arr) => {
                if arr.len() > i16::MAX as usize {
                    return Err(WriteError::Vec2ArrayLen(arr.len()));
                }
                buff.write_u8(18)?;
                buff.write_i16(arr.len() as i16)?;
                for &(x, y) in arr.iter() {
                    buff.write_f32(x)?;
                    buff.write_f32(y)?;
                }
                Ok(())
            }
            DynData::Vec2(x, y) => {
                buff.write_u8(19)?;
                buff.write_f32(*x)?;
                buff.write_f32(*y)?;
                Ok(())
            }
            DynData::Team(team) => {
                buff.write_u8(20)?;
                buff.write_u8(u8::from(*team))?;
                Ok(())
            }
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ReadError {
    Underlying(data::ReadError),
    Type(u8),
    ContentType(content::TryFromU8Error),
    IntArrayLen(i16),
    Point2ArrayLen(i8),
    LogicField(u8),
    ByteArrayLen(i32),
    UnitCommand(command::TryFromU8Error),
    BoolArrayLen(i32),
    Vec2ArrayLen(i16),
}

impl From<data::ReadError> for ReadError {
    fn from(err: data::ReadError) -> Self {
        Self::Underlying(err)
    }
}

impl From<content::TryFromU8Error> for ReadError {
    fn from(err: content::TryFromU8Error) -> Self {
        Self::ContentType(err)
    }
}

impl From<command::TryFromU8Error> for ReadError {
    fn from(err: command::TryFromU8Error) -> Self {
        Self::UnitCommand(err)
    }
}

impl fmt::Display for ReadError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Underlying(..) => f.write_str("failed to read from buffer"),
            Self::Type(id) => write!(f, "invalid dynamic data type ({id})"),
            Self::ContentType(..) => f.write_str("content type not found"),
            Self::IntArrayLen(len) => write!(f, "integer array too long ({len})"),
            Self::Point2ArrayLen(len) => write!(f, "point2 array too long ({len})"),
            Self::LogicField(id) => write!(f, "invalid logic field ({id})"),
            Self::ByteArrayLen(len) => write!(f, "byte array too long ({len})"),
            Self::UnitCommand(..) => f.write_str("unit command not found"),
            Self::BoolArrayLen(len) => write!(f, "boolean array too long ({len})"),
            Self::Vec2ArrayLen(len) => write!(f, "vec2 array too long ({len})"),
        }
    }
}

impl Error for ReadError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Underlying(e) => Some(e),
            _ => None,
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum WriteError {
    Underlying(data::WriteError),
    IntArrayLen(usize),
    Point2ArrayLen(usize),
    ByteArrayLen(usize),
    BoolArrayLen(usize),
    Vec2ArrayLen(usize),
}

impl From<data::WriteError> for WriteError {
    fn from(err: data::WriteError) -> Self {
        Self::Underlying(err)
    }
}

impl fmt::Display for WriteError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Underlying(..) => f.write_str("failed to write to buffer"),
            Self::IntArrayLen(len) => write!(f, "integer array too long ({len})"),
            Self::Point2ArrayLen(len) => write!(f, "point2 array too long ({len})"),
            Self::ByteArrayLen(len) => write!(f, "byte array too long ({len})"),
            Self::BoolArrayLen(len) => write!(f, "boolean array too long ({len})"),
            Self::Vec2ArrayLen(len) => write!(f, "vec2 array too long ({len})"),
        }
    }
}

impl Error for WriteError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Underlying(e) => Some(e),
            _ => None,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::team::{CRUX, DERELICT, SHARDED};

    macro_rules! _zero {
        ($tt:tt) => {
            0usize
        };
    }

    macro_rules! make_dyn_test {
		($name:ident, $($val:expr),+) => {
			#[test]
			fn $name() {
				let input = [$($val),+];
				let mut positions = [$(_zero!($val)),+];
				let mut writer = DataWrite::default();
				for (i, d) in input.iter().enumerate()
				{
					assert_eq!(DynSerializer.serialize(&mut writer, d), Ok(()));
					positions[i] = writer.get_written().len();
				}
				let written = writer.get_written();
				let end = written.len();
				let mut reader = DataRead::new(written);
				for (i, original) in input.iter().enumerate()
				{
					match DynSerializer.deserialize(&mut reader)
					{
						Ok(read) => assert_eq!(*original, read, "serialization of {original:?} became {read:?}"),
						e => assert!(false, "could not re-read {original:?} (at {i}), got {e:?}"),
					}
					let expect = end - reader.data.len();
					let before = if i > 0 {positions[i - 1]} else {0};
					assert_eq!(expect, positions[i], "uneven deserialization of {original:?} ({} vs {})", expect - before, positions[i] - before);
				}
			}
		};
	}

    make_dyn_test!(
        reparse_empty,
        DynData::Empty,
        DynData::Empty,
        DynData::Empty
    );
    make_dyn_test!(
        reparse_int,
        DynData::Int(581_923),
        DynData::Int(2_147_483_647),
        DynData::Int(-1_047_563_850)
    );
    make_dyn_test!(
        reparse_long,
        DynData::Long(11_295_882_949_812),
        DynData::Long(-5_222_358_074_010_407_789)
    );
    make_dyn_test!(
        reparse_float,
        DynData::Float(std::f32::consts::PI),
        DynData::Float(f32::INFINITY),
        DynData::Float(f32::EPSILON)
    );
    make_dyn_test!(
        reparse_string,
        DynData::String(None),
        DynData::String(Some("hello \u{10FE03}".to_string())),
        DynData::String(Some(String::new()))
    );
    make_dyn_test!(
        reparse_content,
        DynData::Content(content::Type::Item, 12345),
        DynData::Content(content::Type::Planet, 25431)
    );
    make_dyn_test!(
        reparse_int_array,
        DynData::IntArray(vec![581_923, 2_147_483_647, -1_047_563_850]),
        DynData::IntArray(vec![1_902_864_703])
    );
    make_dyn_test!(
        reparse_point2,
        DynData::Point2(17, 0),
        DynData::Point2(234, -345),
        DynData::Point2(-2_147_483_648, -1)
    );
    make_dyn_test!(
        reparse_point2_array,
        DynData::Point2Array(vec![(44, 55), (-33, 66), (-22, -77)]),
        DynData::Point2Array(vec![(22, -88)])
    );
    make_dyn_test!(
        reparse_technode,
        DynData::TechNode(content::Type::Item, 12345),
        DynData::TechNode(content::Type::Planet, 25431)
    );
    make_dyn_test!(
        reparse_boolean,
        DynData::Boolean(false),
        DynData::Boolean(true),
        DynData::Boolean(false)
    );
    make_dyn_test!(
        reparse_double,
        DynData::Double(std::f64::consts::E),
        DynData::Double(-f64::INFINITY)
    );
    make_dyn_test!(
        reparse_building,
        DynData::Building(GridPos(10, 0)),
        DynData::Building(GridPos(4444, 0xFE98))
    );
    make_dyn_test!(
        reparse_logic,
        DynData::LogicField(LogicField::Enabled),
        DynData::LogicField(LogicField::Shoot),
        DynData::LogicField(LogicField::Color)
    );
    make_dyn_test!(
        reparse_byte_array,
        DynData::ByteArray(b"c\x00nstruct \xADditio\nal pylons".to_vec()),
        DynData::ByteArray(b"\x00\x01\xFE\xFF".to_vec())
    );
    make_dyn_test!(
        reparse_unit_command,
        DynData::UnitCommand(UnitCommand::Idle),
        DynData::UnitCommand(UnitCommand::Rally)
    );
    make_dyn_test!(
        reparse_bool_array,
        DynData::BoolArray(vec![true, true, true, false, true, false, true]),
        DynData::BoolArray(vec![false, true])
    );
    make_dyn_test!(reparse_unit, DynData::Unit(0), DynData::Unit(2_147_483_647));
    make_dyn_test!(
        reparse_vec2_array,
        DynData::Vec2Array(vec![(4.4, 5.5), (-3.3, 6.6), (-2.2, -7.7)]),
        DynData::Vec2Array(vec![(2.2, -8.8)])
    );
    make_dyn_test!(
        reparse_vec2,
        DynData::Vec2(1.5, 9.1234),
        DynData::Vec2(-0.0, -17.0),
        DynData::Vec2(-10.7, 3.8)
    );
    make_dyn_test!(
        reparse_team,
        DynData::Team(SHARDED),
        DynData::Team(CRUX),
        DynData::Team(DERELICT)
    );
}