use rocie_client::{
    apis::{
        api_get_auth_recipe_api::recipe_by_id, api_set_auth_product_api::register_product,
        api_set_auth_recipe_api::add_recipe,
        api_set_auth_unit_property_api::register_unit_property,
    },
    models::{
        Content, ContentOneOf, CooklangRecipe, Ingredient, IngredientOneOf1NotRegisteredProduct,
        Item, ItemOneOf, ItemOneOf1, Metadata, NameAndUrl, ProductStub, RecipeStub, Section, Step,
        UnitPropertyStub,
    },
};

use crate::testenv::{TestEnv, init::function_name, log::request};

#[expect(clippy::unnecessary_wraps)]
fn name_and_url(name: &str, url: &str) -> Option<NameAndUrl> {
    Some(NameAndUrl {
        name: if name.is_empty() {
            None
        } else {
            Some(name.to_owned())
        },
        url: if url.is_empty() {
            None
        } else {
            Some(url.to_owned())
        },
    })
}

#[tokio::test]
async fn test_recipe_metadata() {
    let env = TestEnv::new(function_name!()).await;

    let recipe_id = request!(
        env,
        add_recipe(RecipeStub {
            content: "
---
author: James Connor
description: Meaty curry with sharp anacado source and a burning d-pad.
source: https://google.com/search?q=test
title: Curry
---
"
            .to_owned(),
            name: "Curry".to_owned(),
            parent: None,
        })
    );

    let output = request!(env, recipe_by_id(recipe_id));

    assert_eq!(output.name, "Curry".to_owned());
    assert_eq!(
        output.content,
        CooklangRecipe {
            cookware: vec![],
            ingredients: vec![],
            metadata: Metadata {
                author: name_and_url("James Connor", ""),
                description: Some(
                    "Meaty curry with sharp anacado source and a burning d-pad.".to_owned()
                ),
                source: name_and_url("", "https://google.com/search?q=test"),
                tags: None,
                title: Some("Curry".to_owned())
            },
            sections: vec![],
            timers: vec![]
        }
    );
}

#[tokio::test]
async fn test_recipe_ingredients() {
    let env = TestEnv::new(function_name!()).await;

    let up = request!(
        env,
        register_unit_property(UnitPropertyStub {
            description: None,
            name: "mass".to_owned()
        })
    );

    let rice_id = request!(
        env,
        register_product(ProductStub {
            description: None,
            name: "rice".to_owned(),
            parent: None,
            unit_property: up,
        })
    );

    let recipe_id = request!(
        env,
        add_recipe(RecipeStub {
            content: "
---
author: James Connor
title: Curry
---
Add @rice{} and @water{200%ml} to a pot.
"
            .to_owned(),
            name: "Curry".to_owned(),
            parent: None,
        })
    );

    let output = request!(env, recipe_by_id(recipe_id));

    assert_eq!(output.name, "Curry".to_owned());
    assert_eq!(
        output.content.ingredients,
        vec![
            Ingredient::IngredientOneOf(rocie_client::models::IngredientOneOf {
                registered_product: rocie_client::models::IngredientOneOfRegisteredProduct {
                    alias: None,
                    id: rice_id,
                    quantity: None,
                }
            }),
            Ingredient::IngredientOneOf1(rocie_client::models::IngredientOneOf1 {
                not_registered_product: IngredientOneOf1NotRegisteredProduct {
                    name: "water".to_owned(),
                    quantity: None,
                }
            }),
        ]
    );

    assert_eq!(
        output.content.sections,
        vec![Section {
            content: vec![Content::ContentOneOf(ContentOneOf {
                value: Step {
                    items: vec![
                        Item::ItemOneOf(ItemOneOf {
                            r#type: rocie_client::models::item_one_of::Type::Text,
                            value: "Add ".to_owned()
                        }),
                        Item::ItemOneOf1(ItemOneOf1 {
                            r#type: rocie_client::models::item_one_of_1::Type::Ingredient,
                            index: 0
                        }),
                        Item::ItemOneOf(ItemOneOf {
                            r#type: rocie_client::models::item_one_of::Type::Text,
                            value: " and ".to_owned()
                        }),
                        Item::ItemOneOf1(ItemOneOf1 {
                            r#type: rocie_client::models::item_one_of_1::Type::Ingredient,
                            index: 1
                        }),
                        Item::ItemOneOf(ItemOneOf {
                            r#type: rocie_client::models::item_one_of::Type::Text,
                            value: " to a pot.".to_owned()
                        })
                    ],
                    number: 1
                },
                r#type: rocie_client::models::content_one_of::Type::Step
            })],
            name: None
        }]
    );
}