use std::str::FromStr;

use crate::config::{Config, Webhook};
use crate::routes::Token;
use crate::variant::Variant;
use crate::{check_auth, get_itemdb};
use crate::{
    db::ItemDB,
    routes::{FallibleApiResponse, api_error},
};
use based::request::api::ToAPI;
use rocket::serde::json::Json;
use rocket::{State, get, post};
use serde::Deserialize;
use serde_json::json;

use super::{item_does_not_exist_error, variant_does_not_exist_error};

#[derive(Debug, Deserialize)]
pub struct DemandForm {
    uuid: String,
    destination: String,
    price: f64,
}

#[post("/demand", data = "<f>")]
/// Consumes a Transaction with Price and Destination
pub async fn demand_route(f: Json<DemandForm>, t: Token, c: &State<Config>) -> FallibleApiResponse {
    check_auth!(t, c);

    let transaction = Variant::demand(
        &uuid::Uuid::from_str(&f.uuid).map_err(|_| api_error("Invalid UUID"))?,
        f.price,
        &f.destination,
    )
    .await
    .ok_or_else(|| api_error("Demand failed"))?;

    if let Some(hook) = &c.webhook {
        if let Some(url) = &hook.transaction_consumed {
            Webhook::send(url, &transaction.api().await).await;
        }

        if let Some(url) = &hook.item_below_minimum {
            let variant = get_itemdb!()
                .get_item(&transaction.item)
                .unwrap()
                .variant(&transaction.variant)
                .unwrap();
            let min_res = variant.is_below_min().await;
            if min_res.0 {
                Webhook::send(
                    url,
                    &json!({
                        "item": transaction.item,
                        "variant": transaction.variant,
                        "minimum": variant.min,
                        "current_amount": variant.min.unwrap() - min_res.1
                    }),
                )
                .await;
            }
        }
    }

    Ok(json!({"ok": 1}))
}

#[get("/item/<item_id>/<variant_id>/demand?<destination>")]
/// Returns all consumed transactions for Item Variant
pub async fn demand_log_route(
    item_id: &str,
    variant_id: &str,
    itemdb: &State<ItemDB>,
    t: Token,
    c: &State<Config>,
    destination: Option<&str>,
) -> FallibleApiResponse {
    check_auth!(t, c);

    let variant = itemdb
        .get_item(item_id)
        .ok_or_else(item_does_not_exist_error)?
        .variant(variant_id)
        .ok_or_else(variant_does_not_exist_error)?;

    let transactions = variant.demand_log(destination).await;

    Ok(json!(transactions))
}