use crate::layers::Layer;
use crate::medium::WriteMedium;
use crate::tun_worker::TunWorker;
use std::io::Read;

pub struct TunTxWorker {
    layers: Vec<Box<dyn Layer>>,
    tun_reader: tun::Reader,
    tx_medium: Box<dyn WriteMedium>,
    bytes_read: usize,
    bytes_written: usize,
}

impl TunTxWorker {
    pub fn new(tun_reader: tun::Reader, medium: Box<dyn WriteMedium>) -> Self {
        Self {
            layers: vec![],
            tun_reader,
            tx_medium: medium,
            bytes_read: 0,
            bytes_written: 0,
        }
    }
}

impl TunWorker for TunTxWorker {
    fn worker_thread(mut self) {
        let mut buffer = vec![0; 4096];
        loop {
            buffer.resize(4096, 0);
            buffer.fill(0);
            let data_read = self.tun_reader.read(&mut buffer).unwrap();

            buffer.resize(data_read, 0);

            if data_read == 0 {
                log::info!("TUN device closed exiting...");
                return;
            }

            self.bytes_read += data_read;

            if let Err(e) = self.frame_message(&mut buffer) {
                log::error!("Failed to frame message: {}", e);
                continue;
            }

            if let Err(e) = self.tx_medium.write_all(&buffer) {
                log::error!("Failed to write message to medium: {}", e)
            }

            self.bytes_written += buffer.len();
        }
    }

    fn add_layer(&mut self, layer: Box<dyn Layer>) {
        self.layers.push(layer)
    }

    fn get_layers(&mut self) -> &mut Vec<Box<dyn Layer>> {
        &mut self.layers
    }
}