use super::init::{Data, Error};
use crate::{db::user_image::User, img::config_file::KeyWordItem};
use poise::serenity_prelude as serenity;
use rand::Rng;
use serenity::all::{CreateAttachment, CreateMessage};
use tokio::fs::File;

pub async fn event_handler(
    ctx: &serenity::Context,
    event: &serenity::FullEvent,
    _framework: poise::FrameworkContext<'_, Data, Error>,
    data: &Data,
) -> Result<(), Error> {
    match event {
        serenity::FullEvent::Ready { data_about_bot, .. } => {
            println!("{} is connected !", data_about_bot.user.name);
        }
        serenity::FullEvent::Message { new_message } => {
            if new_message.author.bot
                || new_message.content.starts_with(&data.config.prefix.clone())
                || new_message.content.len() == 0
            {
                return Ok(());
            }
            let config_img = data.config_img.clone();
            let config = data.config.clone();
            let guild = match new_message.guild_id {
                Some(guild) => guild,
                None => return Ok(()),
            };
            let user_in_db =
                match User::find_by_server_id_user_id(&guild.get(), &new_message.author.id.get())
                    .await
                {
                    Ok(Some(user_in_db)) => user_in_db.clone(),
                    Ok(None) => {
                        let user_in_db =
                            User::new(guild.get(), new_message.author.id.get(), false).unwrap();
                        match user_in_db.create().await {
                            Ok(_) => user_in_db,
                            Err(e) => {
                                println!("Error saving user image: {:?}", e);
                                return Ok(());
                            }
                        }
                    }
                    Err(e) => {
                        println!("Error finding user image: {:?}", e);
                        return Ok(());
                    }
                };
            if !user_in_db.enable {
                return Ok(());
            }
            if config_img.keyword.len() == 0 || new_message.content.len() > 50 {
                return Ok(());
            }

            let folder_container = match config_img
                .keyword
                .iter()
                .find(|keyword| keyword.does_value_match(new_message.content.clone()))
            {
                Some(keyword_matching) => {
                    println!("{} match {:?}", new_message.content, keyword_matching);
                    let keyword_path = match keyword_matching.path.len() {
                        0 => keyword_matching.path[0].clone(),
                        _ => {
                            let id: usize = {
                                let mut rng = rand::thread_rng();
                                rng.gen_range(0..keyword_matching.path.len())
                            };
                            keyword_matching.path[id].clone()
                        }
                    };

                    keyword_path.clone()
                }
                None => return Ok(()),
            };

            let path = format!("{}/{}", config.image.path.clone(), folder_container);
            let file_folder = KeyWordItem::output_folder_content(path.clone());
            let id_rand: usize = {
                let mut rng = rand::thread_rng();
                rng.gen_range(0..file_folder.len())
            };
            let filename = match file_folder.get(id_rand) {
                Some(file) => file.file_name().to_str().unwrap(),
                None => return Ok(()),
            };
            let file_path = format!("{}/{}", path, filename);
            let file = match File::open(file_path).await {
                Ok(file) => file,
                Err(why) => {
                    println!("Error opening file: {:?}", why);
                    return Ok(());
                }
            };
            let attachment = match CreateAttachment::file(&file, filename).await {
                Ok(attachment) => attachment,
                Err(why) => {
                    println!("Error creating attachment: {:?}", why);
                    return Ok(());
                }
            };
            let builder = CreateMessage::new().add_file(attachment);

            if let Err(why) = new_message
                .channel_id
                .send_message(&ctx.http, builder)
                .await
            {
                println!("Error sending message: {:?}", why);
            }
        }
        _ => {}
    }
    Ok(())
}