use rocie_client::{
    apis::{
        api_get_auth_product_api::{products_by_product_parent_id_direct, products_by_product_parent_id_indirect},
        api_get_auth_product_parent_api::{product_parents_toplevel, product_parents_under},
        api_set_auth_product_api::register_product,
        api_set_auth_product_parent_api::register_product_parent,
        api_set_auth_unit_property_api::register_unit_property,
    },
    models::{ProductParentStub, ProductStub, UnitPropertyStub},
};

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

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

    let parent_dairy = request!(
        env,
        register_product_parent(ProductParentStub {
            description: Some("Dairy replacment products".to_owned()),
            name: "Dairy replacements".to_owned(),
            parent: None,
        })
    );
    request!(
        env,
        register_product_parent(ProductParentStub {
            description: Some("Dairy replacment products".to_owned()),
            name: "Wheat products".to_owned(),
            parent: None,
        })
    );

    request!(
        env,
        register_product_parent(ProductParentStub {
            description: Some("Milk replacment products".to_owned()),
            name: "Milk replacements".to_owned(),
            parent: Some(parent_dairy),
        })
    );

    assert_eq!(
        request!(env, product_parents_toplevel())
            .into_iter()
            .map(|parent| parent.name)
            .collect::<Vec<_>>(),
        vec!["Dairy replacements".to_owned(), "Wheat products".to_owned(),]
    );

    assert_eq!(
        request!(env, product_parents_under(parent_dairy))
            .into_iter()
            .map(|parent| parent.name)
            .collect::<Vec<_>>(),
        vec!["Milk replacements".to_owned()]
    );
}

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

    let parent_dairy = request!(
        env,
        register_product_parent(ProductParentStub {
            description: Some("Dairy replacment products".to_owned()),
            name: "Dairy replacements".to_owned(),
            parent: None,
        })
    );
    let parent_dairy_milk = request!(
        env,
        register_product_parent(ProductParentStub {
            description: Some("Dairy replacment products".to_owned()),
            name: "milk products".to_owned(),
            parent: Some(parent_dairy),
        })
    );

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

    request!(
        env,
        register_product(ProductStub {
            description: None,
            name: "Soy milk".to_owned(),
            parent: Some(parent_dairy_milk),
            unit_property,
        })
    );

    request!(
        env,
        register_product(ProductStub {
            description: None,
            name: "Cheese".to_owned(),
            parent: Some(parent_dairy),
            unit_property,
        })
    );

    assert_eq!(
        request!(env, products_by_product_parent_id_indirect(parent_dairy_milk))
            .into_iter()
            .map(|product| product.name)
            .collect::<Vec<_>>(),
        vec!["Soy milk".to_owned()],
    );

    assert_eq!(
        request!(env, products_by_product_parent_id_direct(parent_dairy_milk))
            .into_iter()
            .map(|product| product.name)
            .collect::<Vec<_>>(),
        vec!["Soy milk".to_owned()],
    );

    assert_eq!(
        request!(env, products_by_product_parent_id_indirect(parent_dairy))
            .into_iter()
            .map(|product| product.name)
            .collect::<Vec<_>>(),
        vec!["Cheese".to_owned(), "Soy milk".to_owned(),],
    );

    assert_eq!(
        request!(env, products_by_product_parent_id_direct(parent_dairy))
            .into_iter()
            .map(|product| product.name)
            .collect::<Vec<_>>(),
        vec!["Cheese".to_owned()],
    );
}