use std::env;
use std::future::Future;

use serenity::async_trait;
use serenity::model::channel::Message;
use serenity::model::gateway::{GatewayIntents, Presence, Ready};
use serenity::model::id::GuildId;
use serenity::prelude::*;
use serenity::model::prelude::RoleId;

struct Handler;
// eoghanconlon73
#[async_trait]
impl EventHandler for Handler {
    // This event will be dispatched for guilds, but not for direct messages.
    async fn message(&self, _ctx: Context, msg: Message) {
        println!("Received message: {}", msg.content);
        
        
    }

    // As the intents set in this example, this event shall never be dispatched.
    // Try it by changing your status.
    async fn presence_update(&self, _ctx: Context, _new_data: Presence) {
        println!("Presence Update");
    }

    async fn ready(&self, ctx: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
        
        let config = Config {
            members: vec![String::from("silver_golden"), String::from("eoghanconlon73")],
            server: GuildId(957961810147938334),
            member_role_current: RoleId::from(1144760670995370094),
            member_role_past: RoleId::from(1144760548072886353),
        };
        
        bulk_check(&ctx, &config).await;
    }
}

struct Config {
    members: Vec<String>,
    server: GuildId,
    member_role_current: RoleId,
    member_role_past: RoleId,
}

async fn bulk_check(ctx: &Context, config: &Config){
    let mut roles_set = [0,0,0];
    if let Ok(x) = config.server.members(ctx, None, None).await {
        for mut member in x {
            if config.members.contains(&member.user.name) {
                let mut roles = vec![];

                if !member.roles.contains(&config.member_role_past){
                    roles_set[0] += 1;
                    roles.push(config.member_role_past);
                }
                if !member.roles.contains(&config.member_role_current){
                    roles_set[1] += 1;
                    roles.push(config.member_role_current);
                }
                
                if let Err(e) =  member.add_roles(&ctx, &roles).await {
                    println!("{:?}", e);
                }
            } else if member.roles.contains(&config.member_role_current) {
                roles_set[2] += 1;
                // if theya re not a current member and have the role then remove it
                if let Err(e) = member.remove_role(&ctx, &config.member_role_current).await {
                    println!("{:?}", e);
                }
            }
        }
    }
    // small bit of logging to note changes over time
    println!("Changes: New: +{}, Current: +{}/-{}", roles_set[0], roles_set[1], roles_set[2]);
}

#[tokio::main]
async 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 = String::from("");

    // Intents are a bitflag, bitwise operations can be used to dictate which intents to use
    let intents = GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MEMBERS;
    // Build our client.
    let mut client = Client::builder(token, intents)
      .event_handler(Handler)
      .await
      .expect("Error 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().await {
        println!("Client error: {:?}", why);
    }
}