use rand::thread_rng;

    let nb_choice = args.advance().remaining();

    let data = ctx.data.read();
    let nb_choice = args.remaining();

    let mut rng = thread_rng();

    let mut rng = data.get::<crate::Random>().unwrap().lock().unwrap();

    let page = fetch_cat_page();

    let data = ctx.data.read();
    let mut rng = data.get::<crate::Random>().unwrap().lock().unwrap();
    let page = fetch_cat_page(&mut *rng);

fn fetch_cat_page() -> Result<String, Box<dyn std::error::Error>> {
    let mut rng = rand::thread_rng();

fn fetch_cat_page(rng: &mut impl Rng) -> Result<String, Box<dyn std::error::Error>> {

use rand::thread_rng;

use rand::Rng;

use std::sync::Mutex;

    type Value = Vec<&'static str>;

    type Value = Mutex<Vec<&'static str>>;

    let mut data = ctx.data.write();

    let data = ctx.data.read();

    let insults = data.get_mut::<Tg>();
    if insults.is_none() {
        let _ = msg.reply(&ctx, "Jesus is dead");
        return Ok(());
    }
    let insults = insults.unwrap();

    let mut insults = data.get::<Tg>().unwrap().lock().unwrap();

        *insults = init_tg();

        let rng = &mut *data.get::<crate::Random>().unwrap().lock().unwrap();
        *insults = init_tg(rng);

pub fn init_tg() -> Vec<&'static str> {

pub fn init_tg(rng: &mut impl Rng) -> Vec<&'static str> {

    let mut rng = thread_rng();
    insults.shuffle(&mut rng);

    insults.shuffle(rng);

use rand::rngs::SmallRng;
use rand::SeedableRng;

use std::sync::Mutex;

}
pub struct Random;
impl TypeMapKey for Random {
    type Value = Mutex<SmallRng>;

    let mut rng = SmallRng::from_entropy();

        data.insert::<commands::Tg>(commands::init_tg());

        data.insert::<commands::Tg>(Mutex::new(commands::init_tg(&mut rng)));
        data.insert::<Random>(Mutex::new(rng));