use std::{
    io::{BufReader, Read},
    net::TcpStream,
};

const KEYLENGTH: u8 = 32;

pub enum PayloadType {
    //0-31 system messages (plaintext)
    Ping = 1,
    Pong = 2,
    Error = 3,
    //32 - 63 Serverside messages (currently plaintext)
    Init = 32,
    Join = 33,
    Exit = 34,
    //64 -95 initial setup messages(plaintext)
    DhSetup = 64,
    DhReturn = 65,
    //96 - 127 client-client setup messages(DH or old KEY encrypted)
    AUTHORIZE = 96,
    KeyCurrent = 97,
    KeyNew = 98,
    //128-159 main messages (shared KEY encrypted)
    Msg = 128,
    //160-255 reserved
}

pub struct Message {
    // Eigenschaften der Klasse
    src_id: u32,
    dest_id: u32,
    size: u16,
    payload: Vec<u8>,
}

impl Message {
    pub fn new(src_id: u32, dest_id: u32, size: u16, msg_type: PayloadType) -> Message {
        let mut msg = Message {
            src_id: src_id,
            dest_id: dest_id,
            size: size,
            payload: Vec::with_capacity(size.into()),
        };
        msg.payload[0] = msg_type as u8;
        msg
    }
    fn creat_vec(&mut self) -> Vec<u8> {
        let mut vec: Vec<u8> = vec![0; (10 + self.size).into()];

        vec[0] = ((self.src_id >> 24) & 0xff) as u8;
        vec[1] = ((self.src_id >> 16) & 0xff) as u8;
        vec[2] = ((self.src_id >> 8) & 0xff) as u8;
        vec[3] = (self.src_id & 0xff) as u8;
        vec[4] = ((self.dest_id >> 24) & 0xff) as u8;
        vec[5] = ((self.dest_id >> 16) & 0xff) as u8;
        vec[6] = ((self.dest_id >> 8) & 0xff) as u8;
        vec[7] = (self.dest_id & 0xff) as u8;
        vec[8] = ((self.size >> 8) & 0xff) as u8;
        vec[9] = (self.size & 0xff) as u8;


        for i in 10..(10 + self.size).into(){
            vec[i] = self.payload[i - 10];
        }
        vec
    }

    fn receive(stream: TcpStream) -> Message {
        let buffreader = BufReader::new(stream);
        let mut byte_iterator = buffreader.bytes();
        let byte1 = byte_iterator.next().unwrap().unwrap();
        let byte2 = byte_iterator.next().unwrap().unwrap();
        let byte3 = byte_iterator.next().unwrap().unwrap();
        let byte4 = byte_iterator.next().unwrap().unwrap();

        let src_id: u32 =
            (byte1 << 24) as u32 | (byte2 << 16) as u32 | (byte3 << 8) as u32 | (byte4 << 0) as u32;

        let byte5 = byte_iterator.next().unwrap().unwrap();
        let byte6 = byte_iterator.next().unwrap().unwrap();
        let byte7 = byte_iterator.next().unwrap().unwrap();
        let byte8 = byte_iterator.next().unwrap().unwrap();

        let dest_id: u32 =
            (byte5 << 24) as u32 | (byte6 << 16) as u32 | (byte7 << 8) as u32 | (byte8 << 0) as u32;

        let byte9 = byte_iterator.next().unwrap().unwrap();
        let byte10 = byte_iterator.next().unwrap().unwrap();

        let size = (byte9 << 8) as u16 | (byte10 << 0) as u16;
        assert!(size > 0, "Ungültige size größe size = {}", size);

        let mut payload = Vec::<u8>::new();
        for i in 0..size {
            payload.push(byte_iterator.next().unwrap().unwrap());
        }

        Message {
            src_id: src_id,
            dest_id: dest_id,
            size: size,
            payload: payload,
        }
    }
    // Methoden der Klasse
}