use {
    super::{
        bytes_errors::{BytesReadError, BytesReadErrorValue},
        bytesio::TNetIO,
    },
    byteorder::{ByteOrder, ReadBytesExt},
    bytes::{BufMut, BytesMut},
    std::{io::Cursor, sync::Arc},
    tokio::sync::Mutex,
};

pub struct BytesReader {
    buffer: BytesMut,
}
impl BytesReader {
    pub fn new(input: BytesMut) -> Self {
        Self { buffer: input }
    }

    pub fn extend_from_slice(&mut self, extend: &[u8]) {
        let remaining_mut = self.buffer.remaining_mut();
        let extend_length = extend.len();

        if extend_length > remaining_mut {
            let additional = extend_length - remaining_mut;
            self.buffer.reserve(additional);
        }

        self.buffer.extend_from_slice(extend)
    }

    pub fn read_bytes(&mut self, bytes_num: usize) -> Result<BytesMut, BytesReadError> {
        if self.buffer.len() < bytes_num {
            return Err(BytesReadError {
                value: BytesReadErrorValue::NotEnoughBytes,
            });
        }
        Ok(self.buffer.split_to(bytes_num))
    }

    pub fn advance_bytes(&mut self, bytes_num: usize) -> Result<BytesMut, BytesReadError> {
        if self.buffer.len() < bytes_num {
            return Err(BytesReadError {
                value: BytesReadErrorValue::NotEnoughBytes,
            });
        }

        //here maybe optimised
        Ok(self.buffer.clone().split_to(bytes_num))
    }

    pub fn read_bytes_cursor(
        &mut self,
        bytes_num: usize,
    ) -> Result<Cursor<BytesMut>, BytesReadError> {
        let tmp_bytes = self.read_bytes(bytes_num)?;
        let tmp_cursor = Cursor::new(tmp_bytes);
        Ok(tmp_cursor)
    }

    pub fn advance_bytes_cursor(
        &mut self,
        bytes_num: usize,
    ) -> Result<Cursor<BytesMut>, BytesReadError> {
        let tmp_bytes = self.advance_bytes(bytes_num)?;
        let tmp_cursor = Cursor::new(tmp_bytes);
        Ok(tmp_cursor)
    }

    pub fn read_u8(&mut self) -> Result<u8, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(1)?;

        Ok(cursor.read_u8()?)
    }

    pub fn advance_u8(&mut self) -> Result<u8, BytesReadError> {
        let mut cursor = self.advance_bytes_cursor(1)?;
        Ok(cursor.read_u8()?)
    }

    pub fn read_u16<T: ByteOrder>(&mut self) -> Result<u16, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(2)?;
        let val = cursor.read_u16::<T>()?;
        Ok(val)
    }

    pub fn read_u24<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(3)?;
        let val = cursor.read_u24::<T>()?;
        Ok(val)
    }

    pub fn advance_u24<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> {
        let mut cursor = self.advance_bytes_cursor(3)?;
        Ok(cursor.read_u24::<T>()?)
    }

    pub fn read_u32<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(4)?;
        let val = cursor.read_u32::<T>()?;

        Ok(val)
    }

    pub fn read_u48<T: ByteOrder>(&mut self) -> Result<u64, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(6)?;
        let val = cursor.read_u48::<T>()?;

        Ok(val)
    }

    pub fn read_f64<T: ByteOrder>(&mut self) -> Result<f64, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(8)?;
        let val = cursor.read_f64::<T>()?;

        Ok(val)
    }

    pub fn read_u64<T: ByteOrder>(&mut self) -> Result<u64, BytesReadError> {
        let mut cursor = self.read_bytes_cursor(8)?;
        let val = cursor.read_u64::<T>()?;

        Ok(val)
    }

    pub fn get(&self, index: usize) -> Result<u8, BytesReadError> {
        if index >= self.len() {
            return Err(BytesReadError {
                value: BytesReadErrorValue::IndexOutofRange,
            });
        }

        Ok(*self.buffer.get(index).unwrap())
    }

    pub fn len(&self) -> usize {
        self.buffer.len()
    }

    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    pub fn extract_remaining_bytes(&mut self) -> BytesMut {
        self.buffer.split_to(self.buffer.len())
    }
    pub fn get_remaining_bytes(&self) -> BytesMut {
        self.buffer.clone()
    }
}
pub struct AsyncBytesReader<T1: TNetIO> {
    pub bytes_reader: BytesReader,
    pub io: Arc<Mutex<T1>>,
}

impl<T1> AsyncBytesReader<T1>
where
    T1: TNetIO,
{
    pub fn new(io: Arc<Mutex<T1>>) -> Self {
        Self {
            bytes_reader: BytesReader::new(BytesMut::default()),
            io,
        }
    }

    pub async fn read(&mut self) -> Result<(), BytesReadError> {
        let data = self.io.lock().await.read().await?;
        self.bytes_reader.extend_from_slice(&data[..]);
        Ok(())
    }

    async fn check(&mut self, bytes_num: usize) -> Result<(), BytesReadError> {
        while self.bytes_reader.len() < bytes_num {
            self.read().await?;
        }

        Ok(())
    }

    pub async fn read_bytes(&mut self, bytes_num: usize) -> Result<BytesMut, BytesReadError> {
        self.check(bytes_num).await?;
        self.bytes_reader.read_bytes(bytes_num)
    }

    pub async fn advance_bytes(&mut self, bytes_num: usize) -> Result<BytesMut, BytesReadError> {
        self.check(bytes_num).await?;
        self.bytes_reader.advance_bytes(bytes_num)
    }

    pub async fn read_bytes_cursor(
        &mut self,
        bytes_num: usize,
    ) -> Result<Cursor<BytesMut>, BytesReadError> {
        self.check(bytes_num).await?;
        self.bytes_reader.read_bytes_cursor(bytes_num)
    }

    pub async fn advance_bytes_cursor(
        &mut self,
        bytes_num: usize,
    ) -> Result<Cursor<BytesMut>, BytesReadError> {
        self.check(bytes_num).await?;
        self.bytes_reader.advance_bytes_cursor(bytes_num)
    }

    pub async fn read_u8(&mut self) -> Result<u8, BytesReadError> {
        self.check(1).await?;
        self.bytes_reader.read_u8()
    }

    pub async fn advance_u8(&mut self) -> Result<u8, BytesReadError> {
        self.check(1).await?;
        self.bytes_reader.advance_u8()
    }

    pub async fn read_u16<T: ByteOrder>(&mut self) -> Result<u16, BytesReadError> {
        self.check(2).await?;
        self.bytes_reader.read_u16::<T>()
    }

    pub async fn read_u24<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> {
        self.check(3).await?;
        self.bytes_reader.read_u24::<T>()
    }

    pub async fn advance_u24<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> {
        self.check(3).await?;
        self.bytes_reader.advance_u24::<T>()
    }

    pub async fn read_u32<T: ByteOrder>(&mut self) -> Result<u32, BytesReadError> {
        self.check(4).await?;
        self.bytes_reader.read_u32::<T>()
    }

    pub async fn read_f64<T: ByteOrder>(&mut self) -> Result<f64, BytesReadError> {
        self.check(8).await?;
        self.bytes_reader.read_f64::<T>()
    }
}

#[cfg(test)]
mod tests {

    use super::BytesReader;
    use bytes::BytesMut;
    use std::cell::RefCell;
    use std::rc::Rc;

    #[test]
    fn test_rc_refcell() {
        let reader = Rc::new(RefCell::new(BytesReader::new(BytesMut::new())));
        let xs: [u8; 3] = [1, 2, 3];
        reader.borrow_mut().extend_from_slice(&xs[..]);

        let mut rv = reader.borrow_mut().read_u8().unwrap();
        assert_eq!(rv, 1, "Incorrect value");

        rv = reader.borrow_mut().read_u8().unwrap();
        assert_eq!(rv, 2, "Incorrect value");

        rv = reader.borrow_mut().read_u8().unwrap();
        assert_eq!(rv, 3, "Incorrect value");
    }

    struct RefStruct {
        pub reader: Rc<RefCell<BytesReader>>,
    }

    impl RefStruct {
        pub fn new(reader: Rc<RefCell<BytesReader>>) -> Self {
            Self { reader }
        }

        // pub fn read_u8(&mut self) -> u8 {
        //     return self.reader.borrow_mut().read_u8().unwrap();
        // }

        pub fn extend_from_slice(&mut self, data: &[u8]) {
            self.reader.borrow_mut().extend_from_slice(data);
        }
    }

    #[test]
    fn test_struct_rc_refcell() {
        let reader = Rc::new(RefCell::new(BytesReader::new(BytesMut::new())));

        let mut ref_struct = RefStruct::new(reader);

        let xs: [u8; 3] = [1, 2, 3];
        ref_struct.extend_from_slice(&xs);

        let mut reader = ref_struct.reader.borrow_mut();

        let mut rv = reader.read_u8().unwrap();
        assert_eq!(rv, 1, "Incorrect value");

        rv = reader.read_u8().unwrap();
        assert_eq!(rv, 2, "Incorrect value");

        rv = reader.read_u8().unwrap();
        assert_eq!(rv, 3, "Incorrect value");
    }
}