use rand::Rng;
use std::env;

use serenity::{
    model::{channel::Message, gateway::Ready},
    prelude::*,
};

struct Handler;

impl EventHandler for Handler {
    // Set a handler for the `message` event - so that whenever a new message
    // is received - the closure (or function) passed will be called.
    //
    // Event handlers are dispatched through a threadpool, and so multiple
    // events can be dispatched simultaneously.
    fn message(&self, ctx: Context, msg: Message) {
        if msg.content[0..2] == *"!s" {
            // Sending a message can fail, due to a network error, an
            // authentication error, or lack of permissions to post in the
            // channel, so log to stdout when some error happens, with a
            // description of it.
            println!("{}", &msg.content[3..]);
            let arg: u32 = msg.content[3..].parse().unwrap();
            let mut rng = rand::thread_rng();
            let mut answer = String::from("```md\n");
            let mut hits = 0;
            for _ in 0..arg {
                let rn = rng.gen_range(1, 7);
                if rn >= 5 {
                    hits += 1;
                }
                answer = format!("{}[{}] ", answer.clone(), rn);
            }
            let answer = format!("{}\nhits: {}\n```", answer, hits);
            if let Err(why) = msg.channel_id.say(&ctx.http, answer) {
                println!("Error sending message: {:?}", why);
            }
        }
    }

    // Set a handler to be called on the `ready` event. This is called when a
    // shard is booted, and a READY payload is sent by Discord. This payload
    // contains data like the current user's guild Ids, current user data,
    // private channels, and more.
    //
    // In this case, just print what the current user's username is.
    fn ready(&self, _: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
    }
}

fn main() {
    // Configure the client with your Discord bot token in the environment.
    //let token = env::var("DISCORD_TOKEN")
    //    .expect("Expected a token in the environment");
    let token = "Mjk0NTU0MDU4Nzg4NzAwMTYx.XmfrfA.l8MmCKYem6IBlYOjViUeT9tMSaE";

    // Create a new instance of the Client, logging in as a bot. This will
    // automatically prepend your bot token with "Bot ", which is a requirement
    // by Discord for bot users.
    let mut client = Client::new(&token, Handler).expect("Err creating client");

    // Finally, start a single shard, and start listening to events.
    //
    // Shards will automatically attempt to reconnect, and will perform
    // exponential backoff until it reconnects.
    if let Err(why) = client.start() {
        println!("Client error: {:?}", why);
    }
}