use crate::error::{FinanceError, TagError};

use sqlx::{Connection, types::Uuid};

use supp_macro::Builder;

#[derive(Debug, sqlx::FromRow, Builder)]

#[builder(error_kind = "TagError")]

pub struct Tag {

    pub id: Uuid,

    pub tag_name: String,

    pub tag_value: String,

    pub description: Option<String>,

}

impl Tag {

    /// Upsert this tag and return the canonical row id.

    ///

    /// Tag identity is `(tag_name, tag_value)`. When a row with the same pair

    /// already exists, its id is returned and the description is refreshed

    /// only if a non-NULL one was supplied. The returned id may differ from

    /// `self.id`; callers linking the tag to an entity must use the returned

    /// canonical id.

            &self.id,

            &self.tag_name,

            &self.tag_value,

            self.description

        )

}

#[cfg(test)]

mod tag_tests {

    use super::*;

    #[cfg(feature = "testlog")]

    use env_logger;

    #[cfg(feature = "testlog")]

    use log;

    use sqlx::PgPool;

    use tokio::sync::OnceCell;

    /// Context for keeping environment intact

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

                #[cfg(feature = "testlog")]

    #[sqlx::test(migrations = "../migrations")]

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

        setup().await;

        let mut conn = pool.acquire().await?;

        let tag = Tag {

            id: Uuid::new_v4(),

            tag_name: "Category".to_string(),

            tag_value: "test".to_string(),

            description: None,

        };

        sqlx::query!(

            "INSERT INTO tags (id, tag_name, tag_value, description) \

		      VALUES ($1, $2, $3, $4)",

            &tag.id,

            &tag.tag_name,

            &tag.tag_value,

            tag.description

        )

        .execute(&mut *conn)

        .await?;

        let result = sqlx::query!("SELECT id, tag_value FROM tags WHERE tag_name = 'Category'")

            .fetch_one(&mut *conn)

            .await?;

        assert_eq!(tag.id, result.id);

        assert_eq!(tag.tag_value, "test".to_string());

        let tag2 = Tag {

            id: Uuid::new_v4(),

            tag_name: "Cat2".to_string(),

            ..tag

        };

        let mut conn = pool.acquire().await?;

        tag2.commit(&mut *conn).await?;

        let mut conn = pool.acquire().await?;

        let result = sqlx::query!("SELECT id, tag_value FROM tags WHERE tag_name = 'Cat2'")

            .fetch_one(&mut *conn)

            .await?;

        assert_eq!(tag2.id, result.id);

        assert_eq!(tag2.tag_value, "test".to_string());

        Ok(())

    }

    #[tokio::test]

}