use crate::error::BotError;
use geoffrey_models::models::locations::LocationType;
use geoffrey_models::models::parameters::selling_params::{ItemSort, Order};
use geoffrey_models::models::Dimension;
use serenity::builder::CreateApplicationCommandOption;
use serenity::model::prelude::application_command::{
    ApplicationCommandInteractionDataOption, ApplicationCommandInteractionDataOptionValue,
    ApplicationCommandOptionType,
};
use std::str::FromStr;

pub fn option_to_i64(
    option: Option<&ApplicationCommandInteractionDataOption>,
    field: &str,
) -> Result<i64, BotError> {
    if let Some(option) = option {
        let option = option.resolved.as_ref();

        if let Some(ApplicationCommandInteractionDataOptionValue::Integer(i)) = option {
            return Ok(*i);
        }
    }
    Err(BotError::ArgumentParse(field.to_string()))
}

pub fn option_to_string(
    option: Option<&ApplicationCommandInteractionDataOption>,
    field: &str,
) -> Result<String, BotError> {
    if let Some(option) = option {
        let option = option.resolved.as_ref();

        if let Some(ApplicationCommandInteractionDataOptionValue::String(s)) = option {
            return Ok(s.clone());
        }
    }
    Err(BotError::ArgumentParse(field.to_string()))
}

pub fn option_to_loc_type(
    option: Option<&ApplicationCommandInteractionDataOption>,
    field: &str,
) -> Result<LocationType, BotError> {
    let loc_type = option_to_string(option, field)?;

    LocationType::from_str(&loc_type).map_err(|_| BotError::ArgumentParse(field.to_string()))
}

pub fn option_to_dim(
    option: Option<&ApplicationCommandInteractionDataOption>,
    field: &str,
) -> Result<Dimension, BotError> {
    let loc_type = option_to_string(option, field)?;

    Dimension::from_str(&loc_type).map_err(|_| BotError::ArgumentParse(field.to_string()))
}

pub fn option_to_sort(
    option: Option<&ApplicationCommandInteractionDataOption>,
    field: &str,
) -> Result<ItemSort, BotError> {
    let loc_type = option_to_string(option, field)?;

    ItemSort::from_str(&loc_type).map_err(|_| BotError::ArgumentParse(field.to_string()))
}

pub fn option_to_order(
    option: Option<&ApplicationCommandInteractionDataOption>,
    field: &str,
) -> Result<Order, BotError> {
    let loc_type = option_to_string(option, field)?;

    Order::from_str(&loc_type).map_err(|_| BotError::ArgumentParse(field.to_string()))
}

pub fn add_x_position_argument(
    option: &mut CreateApplicationCommandOption,
) -> &mut CreateApplicationCommandOption {
    option
        .name("x")
        .description("X coordinate")
        .kind(ApplicationCommandOptionType::Integer)
        .max_int_value(i32::MAX)
        .min_int_value(i32::MIN)
        .required(true)
}

pub fn add_y_position_argument(
    option: &mut CreateApplicationCommandOption,
) -> &mut CreateApplicationCommandOption {
    option
        .name("y")
        .description("Y Coordinate")
        .kind(ApplicationCommandOptionType::Integer)
        .max_int_value(i32::MAX)
        .min_int_value(i32::MIN)
        .required(true)
}

pub fn add_z_position_argument(
    option: &mut CreateApplicationCommandOption,
) -> &mut CreateApplicationCommandOption {
    option
        .name("z")
        .description("Z Coordinate")
        .kind(ApplicationCommandOptionType::Integer)
        .max_int_value(i32::MAX)
        .min_int_value(i32::MIN)
        .required(true)
}

pub fn add_dimension_argument(
    option: &mut CreateApplicationCommandOption,
) -> &mut CreateApplicationCommandOption {
    option
        .name("dimension")
        .description("Dimension of the shop, default is Overworld")
        .kind(ApplicationCommandOptionType::String)
        .add_string_choice(Dimension::Overworld, Dimension::Overworld)
        .add_string_choice(Dimension::Nether, Dimension::Nether)
        .add_string_choice(Dimension::TheEnd, Dimension::TheEnd)
        .required(false)
}