use finance::{commodity::Commodity, tag::Tag};

use num_rational::Rational64;

use sqlx::types::Uuid;

use std::{collections::HashMap, fmt::Debug};

use supp_macro::command;

use super::{CmdError, CmdResult};

use crate::{command::FinanceEntity, config::ConfigError, user::User};

command! {

    GetCommodity {

        #[required]

        user_id: Uuid,

        #[required]

        commodity_id: Uuid,

    } => {

        let user = User { id: user_id };

        let comm = sqlx::query_file_as!(Commodity, "sql/select/commodities/by_id.sql", &commodity_id)

            .fetch_one(&mut *conn)

            .await?;

        // For each commodity, get its tags

        let mut tagged_entities = Vec::new();

        let tags: HashMap<String, FinanceEntity> =

            sqlx::query_file!("sql/select/tags/by_commodity.sql", &commodity_id)

                .fetch_all(&mut *conn)

                .await?

                .into_iter()

                .collect();

        tagged_entities.push((FinanceEntity::Commodity(comm), tags));

        Ok(Some(CmdResult::TaggedEntities(tagged_entities)))

    }

command! {

    CreateCommodity {

        #[required]

        fraction: Rational64,

        #[required]

        symbol: String,

        #[required]

        name: String,

        #[required]

        user_id: Uuid,

    } => {

        let user = User { id: user_id };

        Ok(Some(

            user.create_commodity(fraction.to_integer(), symbol, name)

                .await?

                .id

                .to_string()

                .into(),

        ))

    }

command! {

    ListCommodities {

        #[required]

        user_id: Uuid,

    } => {

        let user = User { id: user_id };

        // Get all commodities

        let commodities: Vec<Commodity> = sqlx::query_file!("sql/select/commodities/all.sql")

            .fetch_all(&mut *conn)

            .await?

            .into_iter()

            .map(|row| Commodity {

            .collect();

        // For each commodity, get its tags

        let mut tagged_entities = Vec::new();

        for commodity in commodities {

            let tags: HashMap<String, FinanceEntity> =

                sqlx::query_file!("sql/select/tags/by_commodity.sql", &commodity.id)

                    .fetch_all(&mut *conn)

                    .await?

                    .into_iter()

                    .collect();

            tagged_entities.push((FinanceEntity::Commodity(commodity), tags));

        }

        Ok(Some(CmdResult::TaggedEntities(tagged_entities)))

    }

#[cfg(test)]

mod command_tests {

    use super::*;

    use crate::db::DB_POOL;

    use sqlx::PgPool;

    use supp_macro::local_db_sqlx_test;

    use tokio::sync::OnceCell;

    /// Context for keeping environment intact

    static CONTEXT: OnceCell<()> = OnceCell::const_new();

    static USER: OnceCell<User> = OnceCell::const_new();

                #[cfg(feature = "testlog")]

    #[local_db_sqlx_test]

    async fn test_list_commodities_empty(pool: PgPool) -> anyhow::Result<()> {

        let user = USER.get().unwrap();

        user.commit()

            .await

            .expect("Failed to commit user to database");

        if let Some(CmdResult::TaggedEntities(entities)) =

            ListCommodities::new().user_id(user.id).run().await?

        {

            assert!(

                entities.is_empty(),

                "Expected no commodities in empty database"

            );

        } else {

            panic!("Expected TaggedEntities result");

        }

    }

    #[local_db_sqlx_test]

    async fn test_list_commodities_with_data(pool: PgPool) -> anyhow::Result<()> {

        let user = USER.get().unwrap();

        user.commit()

            .await

            .expect("Failed to commit user to database");

        // Create a test commodity with tags

        CreateCommodity::new()

            .fraction(1.into())

            .symbol("TST".to_string())

            .name("Test Commodity".to_string())

            .user_id(user.id)

            .run()

            .await?;

        // List commodities

        if let Some(CmdResult::TaggedEntities(entities)) =

            ListCommodities::new().user_id(user.id).run().await?

        {

            assert_eq!(entities.len(), 1, "Expected one commodity");

            let (entity, tags) = &entities[0];

            if let FinanceEntity::Commodity(c) = entity {

                assert_eq!(c.fraction, 1);

                // Check tags

                assert_eq!(tags.len(), 2); // symbol and name tags

                for tag in tags.values() {

                    if let FinanceEntity::Tag(t) = tag {

                        match t.tag_name.as_str() {

                            "symbol" => assert_eq!(t.tag_value, "TST"),

                            "name" => assert_eq!(t.tag_value, "Test Commodity"),

                            _ => panic!("Unexpected tag: {}", t.tag_name),

                        }

                    }

                }

            } else {

                panic!("Expected Commodity entity");

            }

        } else {

            panic!("Expected TaggedEntities result");

        }

    }

    #[local_db_sqlx_test]

    async fn test_get_commodity(pool: PgPool) -> anyhow::Result<()> {

        let user = USER.get().unwrap();

        user.commit()

            .await

            .expect("Failed to commit user to database");

        // First create a commodity

        let commodity_result = CreateCommodity::new()

            .fraction(1.into())

            .symbol("TST".to_string())

            .name("Test Commodity".to_string())

            .user_id(user.id)

            .run()

            .await?;

        // Get the commodity ID

        let commodity_id = if let Some(CmdResult::String(id)) = commodity_result {

            uuid::Uuid::parse_str(&id)?

        } else {

            panic!("Expected commodity ID string result");

        };

        // Test GetCommodity command

        if let Some(CmdResult::TaggedEntities(entities)) = GetCommodity::new()

            .user_id(user.id)

            .commodity_id(commodity_id)

            .run()

            .await?

        {

            assert_eq!(entities.len(), 1, "Expected one commodity");

            let (entity, tags) = &entities[0];

            if let FinanceEntity::Commodity(c) = entity {

                assert_eq!(c.id, commodity_id);

                assert_eq!(c.fraction, 1);

                // Check tags

                assert_eq!(tags.len(), 2); // symbol and name tags

                for tag in tags.values() {

                    if let FinanceEntity::Tag(t) = tag {

                        match t.tag_name.as_str() {

                            "symbol" => assert_eq!(t.tag_value, "TST"),

                            "name" => assert_eq!(t.tag_value, "Test Commodity"),

                            _ => panic!("Unexpected tag: {}", t.tag_name),

                        }

                    }

                }

            } else {

                panic!("Expected Commodity entity");

            }

        } else {

            panic!("Expected TaggedEntities result");

        }

        // Test with non-existent commodity ID

        let result = GetCommodity::new()

            .user_id(user.id)

            .commodity_id(Uuid::new_v4())

            .run()

            .await;

        assert!(result.is_err(), "Expected error for non-existent commodity");

    }

}