/*
    wearechat - generic multiplayer game with voip
    Copyright (C) 2025 metamuffin

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, version 3 of the License only.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/
use crate::packets::{Data, Object, Resource};
use anyhow::Result;
use glam::{Affine3A, Vec2, Vec3, Vec3A};
use std::{
    borrow::Cow,
    io::{Read, Write},
    marker::PhantomData,
};

pub trait ReadWrite: Sized {
    fn write(&self, w: &mut dyn Write) -> Result<()>;
    fn read(r: &mut dyn Read) -> Result<Self>;

    fn write_alloc<'a>(&'a self) -> Cow<'a, [u8]> {
        let mut buf = Vec::new();
        self.write(&mut buf).unwrap();
        Cow::Owned(buf)
    }
}

impl ReadWrite for f32 {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&self.to_be_bytes())?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = [0; { size_of::<f32>() }];
        r.read_exact(&mut buf)?;
        Ok(f32::from_be_bytes(buf))
    }
}
impl ReadWrite for u32 {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&self.to_be_bytes())?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = [0; { size_of::<u32>() }];
        r.read_exact(&mut buf)?;
        Ok(u32::from_be_bytes(buf))
    }
}
impl ReadWrite for Vec<u8> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&self)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(buf)
    }
}
impl<'a> ReadWrite for Cow<'a, [u8]> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&self)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(Cow::Owned(buf))
    }
    fn write_alloc<'b>(&'b self) -> Cow<'b, [u8]> {
        match self {
            Cow::Borrowed(x) => Cow::Borrowed(x),
            Cow::Owned(x) => Cow::Borrowed(&x),
        }
    }
}
impl ReadWrite for Vec<Vec3A> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for e in self {
            e.write(w)?;
        }
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(buf
            .into_iter()
            .array_chunks::<{ size_of::<f32>() }>()
            .map(f32::from_be_bytes)
            .array_chunks::<3>()
            .map(Vec3A::from_array)
            .collect())
    }
}
impl ReadWrite for Vec<Vec3> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for e in self {
            e.write(w)?;
        }
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(buf
            .into_iter()
            .array_chunks::<{ size_of::<f32>() }>()
            .map(f32::from_be_bytes)
            .array_chunks::<3>()
            .map(Vec3::from_array)
            .collect())
    }
}
impl ReadWrite for Vec<Vec2> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for e in self {
            e.write(w)?;
        }
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(buf
            .into_iter()
            .array_chunks::<{ size_of::<f32>() }>()
            .map(f32::from_be_bytes)
            .array_chunks::<2>()
            .map(Vec2::from_array)
            .collect())
    }
}
impl ReadWrite for Vec<[u32; 3]> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for e in self {
            w.write_all(&e[0].to_be_bytes())?;
            w.write_all(&e[1].to_be_bytes())?;
            w.write_all(&e[2].to_be_bytes())?;
        }
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(buf
            .into_iter()
            .array_chunks::<{ size_of::<u32>() }>()
            .map(u32::from_be_bytes)
            .array_chunks::<3>()
            .collect())
    }
}
impl ReadWrite for Vec<f32> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for e in self {
            e.write(w)?;
        }
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(buf
            .into_iter()
            .array_chunks::<{ size_of::<f32>() }>()
            .map(f32::from_be_bytes)
            .collect())
    }
}
impl ReadWrite for String {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(self.as_bytes())?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = Vec::new();
        r.read_to_end(&mut buf)?;
        Ok(String::from_utf8(buf)?)
    }
}

impl ReadWrite for Data {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&(self.0.len() as u32).to_be_bytes())?;
        w.write_all(&self.0)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut size = [0; { size_of::<u32>() }];
        r.read_exact(&mut size)?;
        let size = u32::from_be_bytes(size);
        let mut buf = vec![0; size as usize];
        r.read_exact(&mut buf)?;
        Ok(Self(buf))
    }
}
impl<T> ReadWrite for Resource<T> {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&self.0)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut s = Self([0; 32], PhantomData);
        r.read_exact(&mut s.0)?;
        Ok(s)
    }
}
impl ReadWrite for Object {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&self.0.to_be_bytes())?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut s = [0; 16];
        r.read_exact(&mut s)?;
        Ok(Object(u128::from_be_bytes(s)))
    }
}
impl<T: ReadWrite, const N: usize> ReadWrite for [T; N] {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for e in self {
            e.write(w)?;
        }
        Ok(())
    }

    fn read(r: &mut dyn Read) -> Result<Self> {
        [(); N].try_map(|()| T::read(r))
    }
}
impl ReadWrite for () {
    fn write(&self, _w: &mut dyn Write) -> Result<()> {
        Ok(())
    }
    fn read(_r: &mut dyn Read) -> Result<Self> {
        Ok(())
    }
}
impl ReadWrite for Vec2 {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        self.x.write(w)?;
        self.y.write(w)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        Ok(Self::new(f32::read(r)?, f32::read(r)?))
    }
}
impl ReadWrite for Vec3A {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        self.x.write(w)?;
        self.y.write(w)?;
        self.z.write(w)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        Ok(Self::new(f32::read(r)?, f32::read(r)?, f32::read(r)?))
    }
}
impl ReadWrite for Vec3 {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        self.x.write(w)?;
        self.y.write(w)?;
        self.z.write(w)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        Ok(Self::new(f32::read(r)?, f32::read(r)?, f32::read(r)?))
    }
}
impl ReadWrite for Affine3A {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        for v in self.to_cols_array() {
            v.write(w)?
        }
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        Ok(Self::from_cols_array(&[(); 12].try_map(|()| f32::read(r))?))
    }
}
impl<A: ReadWrite, B: ReadWrite> ReadWrite for (A, B) {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        self.0.write(w)?;
        self.1.write(w)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        Ok((A::read(r)?, B::read(r)?))
    }
}
impl<A: ReadWrite, B: ReadWrite, C: ReadWrite> ReadWrite for (A, B, C) {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        self.0.write(w)?;
        self.1.write(w)?;
        self.2.write(w)?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        Ok((A::read(r)?, B::read(r)?, C::read(r)?))
    }
}
impl ReadWrite for u8 {
    fn write(&self, w: &mut dyn Write) -> Result<()> {
        w.write_all(&[*self])?;
        Ok(())
    }
    fn read(r: &mut dyn Read) -> Result<Self> {
        let mut buf = [0u8; 1];
        r.read_exact(&mut buf)?;
        Ok(buf[0])
    }
}