use rand::Rng;
use std::error::Error;

use crate::{
    model::{self, SampleModel},
    publish, selection,
};

pub struct IzzilisBot<T: SampleModel, U: publish::Publisher, V: selection::Selector> {
    model: T,
    publisher: U,
    selector: V,
    loaded_samples: Vec<String>,
}

impl<T, U, V> IzzilisBot<T, U, V>
where
    T: model::SampleModel,
    U: publish::Publisher,
    V: selection::Selector,
{
    pub fn new(model: T, publisher: U, selector: V) -> IzzilisBot<T, U, V> {
        Self {
            model,
            publisher,
            loaded_samples: Vec::new(),
            selector: selector,
        }
    }

    pub fn generate_samples(&mut self) -> Result<(), Box<dyn Error>> {
        // let lines = self.model.generate_sample_lines()?;
        // for line in lines {
        //     self.selector.send_for_review(line)?;
        // }

        // self.loaded_samples = self.selector.collect_selected_samples(); // wtf happens to the original self.loaded_samples???????

        // Ok(())
        todo!()
    }

    pub fn publish(&mut self) -> Result<(), U::Error> {
        if self.loaded_samples.len() < 5 {
            // Refresh samples. Either none have been generated so far,
            // or generated ones are stale.
            //
            // This is a shit solution, but I'm going with it for v1
            // purely because I don't know the language well enough to be
            // confident in doing this via threads. Yet.
            // TODO handle errors here
            let _ = self.generate_samples();
        }
        let sample_index = rand::thread_rng().gen_range(0..self.loaded_samples.len() - 1);
        let content = self.loaded_samples[sample_index].clone();
        self.loaded_samples.remove(sample_index);

        self.publisher.publish(content)
    }
}

#[cfg(tests)]
mod tests {
    use std::io::{self, ErrorKind};

    use crate::{generator, model, publish};

    struct fake_sampler {
        should_ok: bool,
        ok_str: String,
    }

    struct fake_publisher {
        should_ok: bool,
    }

    impl model::SampleModel for fake_sampler {
        fn get_sample(&self) -> Result<String, io::Error> {
            if self.should_ok {
                return Ok(self.ok_str.clone());
            }
            Err(io::Error::new(ErrorKind::NotFound, "error"))
        }
    }

    impl publish::Publisher for fake_publisher {
        fn publish(&self, content: String) -> Option<Box<dyn std::error::Error>> {
            if self.should_ok {
                return None;
            }
            Some(Box::new(io::Error::new(ErrorKind::NotFound, "error")))
        }
    }

    #[test]
    fn generate_samples_populates() {
        let model_ok_string = String::from("model_ok");
        let model = fake_sampler {
            should_ok: true,
            ok_str: model_ok_string,
        };
        let gen = generator::Generator::new(model);
        let publish = fake_publisher { should_ok: true };
        let mut bot = super::IzzilisBot::new(gen, publish);

        match bot.publish() {
            Some(_) => panic!("publish failed"),
            None => (),
        }
    }
}