// use crate::core::colours;
use crate::core::consts::*;
use crate::core::model::*;
use serenity::framework::standard::{
    Args,
    Command,
    CommandError,
    CommandOptions
};
use serenity::model::channel::Message;
use serenity::prelude::Context;
use std::sync::Arc;

// pub struct Bunny;
// impl Command for Bunny {
//     fn options(&self) -> Arc<CommandOptions> {
//         let default = CommandOptions::default();
//         let options = CommandOptions {
//             desc: Some("One bouncy animal for you.".to_string()),
//             ..default
//         };
//         Arc::new(options)
//     }

//     fn execute(&self, ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
//         let data = ctx.data.lock();
//         if let Some(api) = data.get::<ApiClient>() {
//             let res = api.bunny()?;
//             message.channel_id.send_message(|m| m
//                 .embed(|e| e
//                     .image(&res.media[0])
//             ))?;
//         } else { failed!(API_FAIL); }

//         Ok(())
//     }
// }

pub struct Cat;
impl Command for Cat {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            desc: Some("Enjoy a random cat.".to_string()),
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
        let data = ctx.data.lock();
        if let Some(api) = data.get::<ApiClient>() {
            let res = api.cat()?;
            message.channel_id.send_message(|m| m
                .embed(|e| e
                    .image(res.file)
            ))?;
        } else { failed!(API_FAIL); }

        Ok(())
    }
}

pub struct Dog;
impl Command for Dog {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            desc: Some("Cats aren't enough for you? Have a dog!".to_string()),
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
        let data = ctx.data.lock();
        if let Some(api) = data.get::<ApiClient>() {
            let res = api.dog()?;
            message.channel_id.send_message(|m| m
                .embed(|e| e
                    .image(res.message)
            ))?;
        } else { failed!(API_FAIL); }

        Ok(())
    }
}

pub struct Duck;
impl Command for Duck {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            desc: Some("Have a duck, pog.".to_string()),
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
        let data = ctx.data.lock();
        if let Some(api) = data.get::<ApiClient>() {
            let res = api.duck()?;
            message.channel_id.send_message(|m| m
                .embed(|e| e
                    .image(res.url)
            ))?;
        } else { failed!(API_FAIL); }

        Ok(())
    }
}

pub struct Fox;
impl Command for Fox {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            desc: Some("A fox, thats it.".to_string()),
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
        let data = ctx.data.lock();
        if let Some(api) = data.get::<ApiClient>() {
            let res = api.fox()?;
            message.channel_id.send_message(|m| m
                .embed(|e| e
                    .image(res.image)
            ))?;
        } else { failed!(API_FAIL); }

        Ok(())
    }
}

pub struct Owl;
impl Command for Owl {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            desc: Some("Why an owl?".to_string()),
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
        let data = ctx.data.lock();
        if let Some(api) = data.get::<ApiClient>() {
            let res = api.owl()?;
            message.channel_id.send_message(|m| m
                .embed(|e| e
                    .image(res.image)
            ))?;
        } else { failed!(API_FAIL); }

        Ok(())
    }
}

pub struct UglyCat;
impl Command for UglyCat {
    fn options(&self) -> Arc<CommandOptions> {
        let default = CommandOptions::default();
        let options = CommandOptions {
            desc: Some("UGLY CAT!".to_string()),
            ..default
        };
        Arc::new(options)
    }

    fn execute(&self, _ctx: &mut Context, message: &Message, _: Args) -> Result<(), CommandError> {
        message.channel_id.send_message(|m| m
            .embed(|e| e
                .image("https://i.pinimg.com/originals/4d/19/0f/4d190f1307b35e7155bb4b898e19d545.jpg")
        ))?;

        Ok(())
    }
}