use async_trait::async_trait;
use geoffrey_models::models::locations::Location;
use geoffrey_models::models::Portal;
use reqwest::Method;
use serenity::client::Context;
use serenity::model::interactions::application_command::{
    ApplicationCommand, ApplicationCommandInteraction, ApplicationCommandOptionType,
};

use crate::bot::arg_parse::{option_to_i64, option_to_string};
use crate::bot::commands::{BotCommand, CommandError};
use geoffrey_models::models::parameters::set_portal_params::SetPortalParams;

pub struct SetPortalCommand;

#[async_trait]
impl BotCommand for SetPortalCommand {
    type ApiParams = SetPortalParams;
    type ApiResp = Location;

    fn command_name() -> String {
        "set_portal".to_string()
    }

    fn request_type() -> Method {
        Method::POST
    }

    async fn create_app_command(ctx: &Context) -> Result<ApplicationCommand, CommandError> {
        let command = ApplicationCommand::create_global_application_command(&ctx.http, |command| {
            command
                .name(Self::command_name())
                .description("Set a portal for a location")
                .create_option(|option| {
                    option
                        .name("loc_name")
                        .description("Name of the location")
                        .kind(ApplicationCommandOptionType::String)
                        .required(true)
                })
                .create_option(|option| {
                    option
                        .name("x_portal")
                        .description("X coordinate of the portal in the nether")
                        .kind(ApplicationCommandOptionType::Integer)
                        .max_int_value(i32::MAX)
                        .min_int_value(i32::MIN)
                        .required(true)
                })
                .create_option(|option| {
                    option
                        .name("z_portal")
                        .description("Z coordinate of the portal in the nether")
                        .kind(ApplicationCommandOptionType::Integer)
                        .max_int_value(i32::MAX)
                        .min_int_value(i32::MIN)
                        .required(true)
                })
        })
            .await?;

        Ok(command)
    }

    async fn process_arguments(
        command_interaction: ApplicationCommandInteraction,
    ) -> Result<Self::ApiParams, CommandError> {
        let options = command_interaction.data.options;
        let loc_name = option_to_string(options.get(0), "name")?;
        let x_portal = option_to_i64(options.get(1), "x_portal")?;
        let z_portal = option_to_i64(options.get(2), "z_portal")?;

        let portal = Portal::new(x_portal as i32, z_portal as i32);

        Ok(Self::ApiParams::new(loc_name, portal))
    }

    fn build_response(resp: Self::ApiResp) -> String {
        format!("{} has been been updated.", resp.name)
    }
}