//! Integration tests for `create-transaction-logical`.

//!

//! Each test receives an isolated Postgres DB from `sqlx::test`, installs it

//! as the server-side test pool, seeds the minimum fixtures, then calls

//! `run_create_transaction_logical` directly and asserts the outcome.

use server::command::account::CreateAccount;

use server::command::commodity::CreateCommodity;

use server::command::{CmdResult, FinanceEntity};

use sqlx::PgPool;

use uuid::Uuid;

use super::run_logical::run_create_transaction_logical;

/// Install `pool` as the server-side test pool so every server command in this

/// thread uses the isolated test database.

/// Insert a minimal user row so server commands that JOIN on users succeed.

/// Create a commodity and return its UUID.

    {

    }

/// Create an account with the given name and return its UUID.

    {

    }

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let c_id = seed_commodity(user_id, "USD", "US Dollar").await?;

    let a_id = seed_account(user_id, "Assets").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    let payload = format!(

        "(:splits ((:from \"{a_id}\" :to \"{b_id}\" \

         :from-commodity \"{c_id}\" :to-commodity \"{c_id}\" :value 100)))"

    );

    let tx_id_str = run_create_transaction_logical(user_id, Some(payload))

        .await

    let tx_id = Uuid::parse_str(&tx_id_str)?;

    assert!(!tx_id.is_nil(), "returned tx uuid must not be nil");

    let split_count = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM splits WHERE tx_id = $1")

        .bind(tx_id)

        .fetch_one(&pool)

        .await?;

    assert_eq!(split_count, 2, "single logical split → 2 physical splits");

    Ok(())

}

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let usd_id = seed_commodity(user_id, "USD", "US Dollar").await?;

    let eur_id = seed_commodity(user_id, "EUR", "Euro").await?;

    let a_id = seed_account(user_id, "Assets").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    // 100 USD → 92 EUR exchange

    let payload = format!(

        "(:note \"fx test\" :splits ((:from \"{a_id}\" :to \"{b_id}\" \

         :from-commodity \"{usd_id}\" :to-commodity \"{eur_id}\" \

         :value 100 :to-amount 92)))"

    );

    let tx_id_str = run_create_transaction_logical(user_id, Some(payload))

        .await

    let tx_id = Uuid::parse_str(&tx_id_str)?;

    assert!(!tx_id.is_nil());

    let price_count = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM prices")

        .fetch_one(&pool)

        .await?;

    assert_eq!(

        price_count, 1,

        "cross-currency split must record a price row"

    );

    Ok(())

}

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let c_id = seed_commodity(user_id, "USD", "US Dollar").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    // Create two accounts with identical name "Cash"

    seed_account(user_id, "Cash").await?;

    seed_account(user_id, "Cash").await?;

    let payload = format!(

        "(:splits ((:from \"Cash\" :to \"{b_id}\" \

         :from-commodity \"{c_id}\" :to-commodity \"{c_id}\" :value 50)))"

    );

    let err = run_create_transaction_logical(user_id, Some(payload))

        .await

        .unwrap_err();

    assert!(

        err.to_string().contains("ambiguous account name"),

        "expected ambiguity error, got: {err}"

    );

    let tx_count = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM transactions")

        .fetch_one(&pool)

        .await?;

    assert_eq!(tx_count, 0, "no transaction must be created on error");

    Ok(())

}

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let c_id = seed_commodity(user_id, "USD", "US Dollar").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    let payload = format!(

        "(:splits ((:from \"NoSuchAccount\" :to \"{b_id}\" \

         :from-commodity \"{c_id}\" :to-commodity \"{c_id}\" :value 10)))"

    );

    let err = run_create_transaction_logical(user_id, Some(payload))

        .await

        .unwrap_err();

    assert!(

        err.to_string().contains("unknown account"),

        "expected unknown-account error, got: {err}"

    );

    Ok(())

}

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let a_id = seed_account(user_id, "Assets").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    let payload = format!(

        "(:splits ((:from \"{a_id}\" :to \"{b_id}\" \

         :from-commodity \"GHOST\" :to-commodity \"GHOST\" :value 1)))"

    );

    let err = run_create_transaction_logical(user_id, Some(payload))

        .await

        .unwrap_err();

    assert!(

        err.to_string().contains("unknown commodity"),

        "expected unknown-commodity error, got: {err}"

    );

    Ok(())

}

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let c_id = seed_commodity(user_id, "USD", "US Dollar").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    // A syntactically valid uuid that belongs to no account.

    let ghost = Uuid::new_v4();

    let payload = format!(

        "(:splits ((:from \"{ghost}\" :to \"{b_id}\" \

         :from-commodity \"{c_id}\" :to-commodity \"{c_id}\" :value 50)))"

    );

    let err = run_create_transaction_logical(user_id, Some(payload))

        .await

        .unwrap_err();

    assert!(

        err.to_string().contains("unknown account"),

        "expected unknown-account error for a nonexistent uuid, got: {err}"

    );

    let tx_count = sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM transactions")

        .fetch_one(&pool)

        .await?;

    assert_eq!(tx_count, 0, "no transaction must be created on error");

    Ok(())

}

#[sqlx::test(migrator = "server::db::MIGRATOR")]

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

    install_pool(&pool);

    let user_id = Uuid::new_v4();

    seed_user(&pool, user_id).await?;

    let usd_id = seed_commodity(user_id, "USD", "US Dollar").await?;

    let eur_id = seed_commodity(user_id, "EUR", "Euro").await?;

    let a_id = seed_account(user_id, "Assets").await?;

    let b_id = seed_account(user_id, "Expenses").await?;

    // No :to-amount on a cross-currency split

    let payload = format!(

        "(:splits ((:from \"{a_id}\" :to \"{b_id}\" \

         :from-commodity \"{usd_id}\" :to-commodity \"{eur_id}\" :value 100)))"

    );

    let err = run_create_transaction_logical(user_id, Some(payload))

        .await

        .unwrap_err();

    assert!(

        err.to_string().contains("to_amount") || err.to_string().contains("required"),

        "expected missing-to-amount error, got: {err}"

    );

    Ok(())

}