use std::io::prelude::*;

trait Interface {
    fn message(&mut self, message: &str);
}

struct Console {
    write: Box<dyn Write>,
}

impl Console {
    fn new(write: Box<dyn Write>) -> Self {
        Self { write }
    }
}

impl Interface for Console {
    fn message(&mut self, message: &str) {
        write!(self.write, "{}", message).expect("Welp 🤷‍♂️")
    }
}

fn main() {
    let mut console: Box<dyn Interface> = Box::new(Console::new(Box::new(std::io::stdout())));
    console.message("Hello World");
}

#[cfg(test)]
mod test {
    use std::cell::RefCell;
    use std::io::prelude::*;
    use std::rc::Rc;

    use super::{Console, Interface};

    struct MockStorage {
        written: Vec<Vec<u8>>,
    }

    struct MockWriter {
        storage: Rc<RefCell<MockStorage>>,
    }

    impl MockWriter {
        fn new() -> Self {
            Self {
                storage: Rc::new(RefCell::new(MockStorage { written: vec![] })),
            }
        }
    }

    impl Write for MockWriter {
        fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
            self.storage.borrow_mut().written.push(buf.to_vec());

            Ok(buf.len())
        }

        fn flush(&mut self) -> std::io::Result<()> {
            Ok(())
        }
    }

    fn make_test_console() -> (Console, Rc<RefCell<MockStorage>>) {
        let mock_writer = MockWriter::new();
        let storage = Rc::clone(&mock_writer.storage);

        (Console::new(Box::new(mock_writer)), storage)
    }

    #[test]
    fn test_message() {
        // Arrange
        let (mut console, storage) = make_test_console();

        // Act
        console.message("Hello World");

        // Assert
        assert_eq!(vec![b"Hello World".to_vec()], storage.borrow().written);
    }

}