use bevy_math::{Quat, Vec3};

#[derive(Clone)]
pub struct Buffer{
  dat: Vec<u8>,
  pointer: usize
}

impl Buffer{
  pub fn empty() -> Self{
    Self { dat: vec![], pointer: 0 }
  }

  pub fn left(&self) -> usize{
    self.dat.len() - self.pointer
  }

  pub fn pointer(&mut self, val: usize){
    self.pointer = val;
  }

  pub fn set_u8(&mut self, value: u8){
    self.dat.push(value);
  }

  pub fn set_u8s(&mut self, value: &[u8]){
    self.dat.append(&mut value.to_vec());
  }

  pub fn set_i16(&mut self, value: i16){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_i32(&mut self, value: i32){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_i64(&mut self, value: i64){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_u16(&mut self, value: u16){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_u32(&mut self, value: u32){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_u64(&mut self, value: u64){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_str(&mut self, value: String){
    let b = value.as_bytes();

    self.set_u32(b.len() as u32);
    self.set_u8s(b);
  }


  pub fn set_vec3(&mut self, value: Vec3){
    self.set_f32(value.x);
    self.set_f32(value.y);
    self.set_f32(value.z);
  }

  pub fn set_quat(&mut self, value: Quat){
    self.set_f32(value.x);
    self.set_f32(value.y);
    self.set_f32(value.z);
    self.set_f32(value.w);
  }


  pub fn set_f32(&mut self, value: f32){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }

  pub fn set_f64(&mut self, value: f64){
    let b = value.to_le_bytes();
    self.set_u8s(&b);
  }


  pub fn get_u8(&mut self) -> u8{
    let b = self.dat[self.pointer];
    self.pointer += 1;

    b
  }

  pub fn get_u8s(&mut self, count: usize) -> &[u8]{
    let b = &self.dat[self.pointer..self.pointer + count];
    self.pointer += count;

    b
  }

  pub fn get_i16(&mut self) -> i16{
    let b = self.get_u8s(2);
    i16::from_le_bytes([ b[0], b[1] ])
  }

  pub fn get_i32(&mut self) -> i32{
    let b = self.get_u8s(4);
    i32::from_le_bytes([ b[0], b[1], b[2], b[3] ])
  }

  pub fn get_i64(&mut self) -> i64{
    let b = self.get_u8s(8);
    i64::from_le_bytes([ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] ])
  }

  pub fn get_u16(&mut self) -> u16{
    let b = self.get_u8s(2);
    u16::from_le_bytes([ b[0], b[1] ])
  }

  pub fn get_u32(&mut self) -> u32{
    let b = self.get_u8s(4);
    u32::from_le_bytes([ b[0], b[1], b[2], b[3] ])
  }

  pub fn get_u64(&mut self) -> u64{
    let b = self.get_u8s(8);
    u64::from_le_bytes([ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] ])
  }

  pub fn get_str(&mut self) -> String{
    let length = self.get_u32();
    let b = self.get_u8s(length as usize);

    let string = str::from_utf8(b).unwrap();
    string.to_owned()
  }


  pub fn get_vec3(&mut self) -> Vec3{
    Vec3 { x: self.get_f32(), y: self.get_f32(), z: self.get_f32() }
  }

  pub fn get_quat(&mut self) -> Quat{
    Quat::from_xyzw(self.get_f32(), self.get_f32(), self.get_f32(), self.get_f32())
  }


  pub fn get_f32(&mut self) -> f32{
    let b = self.get_u8s(4);
    f32::from_le_bytes([ b[0], b[1], b[2], b[3] ])
  }

  pub fn get_f64(&mut self) -> f64{
    let b = self.get_u8s(8);
    f64::from_le_bytes([ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] ])
  }
}

impl From<Vec<u8>> for Buffer{
  fn from(value: Vec<u8>) -> Self {
    Self { dat: value, pointer: 0 }
  }
}

impl From<&[u8]> for Buffer{
  fn from(value: &[u8]) -> Self {
    Self { dat: value.to_vec(), pointer: 0 }
  }
}

impl Into<Vec<u8>> for Buffer{
  fn into(self) -> Vec<u8> {
    self.dat
  }
}