use std::io::Write;
use std::rc::Rc;
use std::cell::RefCell;
use std::result::Result;
use std::io::Error;

pub struct TestWriter {
    /// Каквито полета ви трябват, но вероятно нещо, което обвива Vec<u8>
    buffer: Rc<RefCell<Vec<u8>>>
}

pub struct ThingThatWeAreTesting<W: Write> {
    out: Rc<RefCell<W>>
}

impl<W: Write> ThingThatWeAreTesting<W> {
    pub fn new(out: W) -> Self {
        return ThingThatWeAreTesting { out: Rc::new(RefCell::new(out)) };
    }

    pub fn wake_up_neo(&mut self) {
        self.out.borrow_mut().write(b"Knock, ").unwrap();
    }

    pub fn the_matrix_has_you(&mut self) {
        self.out.borrow_mut().write(b"knock, ").unwrap();
    }

    pub fn follow_the_white_rabbit(&mut self) {
        self.out.borrow_mut().write(b"Neo").unwrap();
    }
}

impl TestWriter {
    /// Конструира нов TestWriter с празен контейнер за байтове.
    ///
    pub fn new() -> Self {
        return TestWriter { buffer: Rc::new(RefCell::new(Vec::new()))}
    }

    /// Консумира структурата и връща Vec с байтове, в който се съдържа каквото е било писано
    /// чрез методите на `Write` trait-а.
    ///
    pub fn into_inner(self) -> Vec<u8> {
        return self.buffer.borrow_mut().clone();
    }

    /// Този метод съществува по-скоро за демонстрация как бихте могли удобно да използвате този
    /// тип, без да жонглирате байтове. Няма да се тества, ако решите да го махнете или пренапишете
    /// някак.
    ///
    pub fn into_string(self) -> String {
        String::from_utf8(self.into_inner()).unwrap()
    }
}

impl Write for TestWriter {
    fn write(&mut self, text: &[u8]) -> Result<usize, Error> {
        for &byte in text {
            self.buffer.borrow_mut().push(byte);
        }

        return Ok(self.buffer.borrow_mut().len());
    }

    fn flush(&mut self) -> Result<(), Error> {
        return Ok(());
    }
}

impl Clone for TestWriter {
    fn clone(&self) -> Self {
        return TestWriter { buffer: Rc::clone(&self.buffer)}
    }
}

fn main() {
    let out = TestWriter::new();
    {
        let mut thing = ThingThatWeAreTesting::new(out.clone());
        thing.wake_up_neo();
        thing.the_matrix_has_you();
        thing.follow_the_white_rabbit();
    }

    assert_eq!(out.into_string(), "Knock, knock, Neo");
}