use std::net::TcpStream;
use std::io::{Read, Write};
use libpso::crypto::{PSOCipher, CipherError};
use libpso::{PSOPacket, PacketParseError};

#[derive(Debug)]
pub enum PacketNetworkError {
    CouldNotSend,
    CipherError(CipherError),
    PacketParseError(PacketParseError),
    IOError(std::io::Error),
    DataNotReady,
}

impl From<CipherError> for PacketNetworkError {
    fn from(err: CipherError) -> PacketNetworkError {
        PacketNetworkError::CipherError(err)
    }
}

impl From<std::io::Error> for PacketNetworkError {
    fn from(err: std::io::Error) -> PacketNetworkError {
        PacketNetworkError::IOError(err)
    }
}

impl From<PacketParseError> for PacketNetworkError {
    fn from(err: PacketParseError) -> PacketNetworkError {
        PacketNetworkError::PacketParseError(err)
    }
}



pub fn recv_packet<T: Read>(socket: &mut T, cipher: &mut dyn PSOCipher) -> Result<Vec<u8>, PacketNetworkError> {
    let mut size_buf = [0u8; 4];
    //socket.read_exact(&mut size_buf)?;
    /*let mut offset = 0;
    while offset < 4 {
        offset += socket.read(&mut size_buf[offset..])?;
    }*/
    let len = socket.read(&mut size_buf)?;
    if len != 4 {
        return Err(PacketNetworkError::DataNotReady)
    }

    let mut dec_size_buf = cipher.decrypt(&size_buf.to_vec())?;
    let size = u16::from_le_bytes([dec_size_buf[0], dec_size_buf[1]]);

    let mut data_buf = vec![0u8; (size - 4) as usize];
    //socket.read_exact(&mut data_buf)?;
    let mut offset = 0;
    while offset < size as usize - 4{
        offset += socket.read(&mut data_buf[offset..])?;
    }
    
    let mut dec_data_buf = cipher.decrypt(&data_buf.to_vec())?;
    
    let mut full_buf = Vec::new();
    full_buf.append(&mut dec_size_buf);
    full_buf.append(&mut dec_data_buf);

    println!("[recv]: {:X?}", full_buf);
    Ok(full_buf)
}

pub fn send_packet<T: Write>(socket: &mut T, cipher: &mut dyn PSOCipher, pkt: &dyn PSOPacket) -> Result<(), PacketNetworkError> {
    let buf = pkt.as_bytes();
    println!("[send]: {:X?}", buf);
    let cbuf = cipher.encrypt(&buf)?;
    Ok(socket.write_all(&cbuf)?)
}