mod commands;
mod data;
mod helper;

use crate::commands::command_framework;
use crate::data::{Args, BotConfig, GlobalData, MessageSource};
use crate::helper::{get_game_state, send_msg_to_player_channels};
use serenity::async_trait;
use serenity::client::bridge::gateway::GatewayIntents;
use serenity::model::prelude::{Message, Ready};
use serenity::prelude::*;
use std::sync::Arc;
use structopt::StructOpt;

struct Handler {}

#[async_trait]
impl EventHandler for Handler {
    async fn message(&self, ctx: Context, msg: Message) {
        if msg.author.bot {
            return;
        }

        if msg.content.starts_with('!') {
            return;
        }

        let data = ctx.data.read().await;

        let game_data = data.get::<GlobalData>().unwrap();

        let game_data = game_data.lock().await;

        if let Some(player_data) = game_data
            .game_state
            .get_player_from_channel(msg.channel_id.0)
        {
            let guild = msg.guild(&ctx.cache).await.unwrap();
            let user_msg = format!("{} > {}", player_data.codename, msg.content);

            send_msg_to_player_channels(
                &ctx,
                &guild,
                &game_data,
                MessageSource::Player(msg.channel_id.0),
                &user_msg,
                false,
            )
            .await;
        }
    }

    async fn ready(&self, _ctx: Context, ready: Ready) {
        println!("{} is connected!", ready.user.name);
    }
}

#[tokio::main]
async fn main() {
    let args: Args = Args::from_args();

    let bot_cfg: BotConfig = BotConfig::new(&args.cfg_path).expect("Unable to parse cfg");

    let mut global_data = GlobalData::new(bot_cfg.clone());

    if get_game_state(&mut global_data).is_ok() {
        println!("Resuming game...")
    }

    let mut client = Client::builder(&bot_cfg.token)
        .event_handler(Handler {})
        .framework(command_framework())
        .intents(GatewayIntents::all())
        .type_map_insert::<GlobalData>(Arc::new(Mutex::new(global_data)))
        .await
        .expect("Err creating client");

    if let Err(why) = client.start().await {
        println!("Client error: {:?}", why);
    }
}