use crate::bot::commands::CommandError;
use geoffrey_models::models::locations::LocationType;
use geoffrey_models::models::parameters::selling_params::{ItemSort, Order};
use geoffrey_models::models::Dimension;
use serenity::model::prelude::application_command::{
    ApplicationCommandInteractionDataOption, ApplicationCommandInteractionDataOptionValue,
};
use std::str::FromStr;

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

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

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

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

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

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

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

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

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

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

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

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