use super::{deposit, get_asset_manager_and_ledger, withdrawal};
use crate::{AccountId, Status};

#[tokio::test]
async fn deposit_transfer_and_withdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let dest = "account2".parse::<AccountId>().expect("account");
    let fee = "fee".parse::<AccountId>().expect("account");
    let (assets, ledger) = get_asset_manager_and_ledger().await;

    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, 1000).expect("amount"),
    )
    .await;
    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, 2000).expect("amount"),
    )
    .await;

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );

    ledger
        .new_transaction(
            "Exchange one".to_owned(),
            Status::Settled,
            vec![(
                source.clone(),
                assets.amount_by_and_cents(2, 1300).expect("amount"),
            )],
            vec![
                (
                    dest.clone(),
                    assets.amount_by_and_cents(2, 1250).expect("amount"),
                ),
                (
                    fee.clone(),
                    assets.amount_by_and_cents(2, 50).expect("amount"),
                ),
            ],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );

    assert!(withdrawal(
        &ledger,
        &source,
        Status::Settled,
        assets.amount_by_and_cents(2, 1700).expect("amount")
    )
    .await
    .is_ok());

    assert!(ledger
        .get_balance(&source)
        .await
        .expect("balance")
        .is_empty());
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );
}

#[tokio::test]
async fn fail_to_overwithdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let dest = "account2".parse::<AccountId>().expect("account");
    let fee = "fee".parse::<AccountId>().expect("account");
    let (assets, ledger) = get_asset_manager_and_ledger().await;

    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, 1000).expect("amount"),
    )
    .await;
    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, 2000).expect("amount"),
    )
    .await;

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );

    ledger
        .new_transaction(
            "Exchange one".to_owned(),
            Status::Settled,
            vec![(
                source.clone(),
                assets.amount_by_and_cents(2, 1300).expect("amount"),
            )],
            vec![
                (
                    dest.clone(),
                    assets.amount_by_and_cents(2, 1250).expect("amount"),
                ),
                (
                    fee.clone(),
                    assets.amount_by_and_cents(2, 50).expect("amount"),
                ),
            ],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );

    assert!(withdrawal(
        &ledger,
        &source,
        Status::Settled,
        assets.amount_by_and_cents(2, 170000).expect("amount")
    )
    .await
    .is_err());

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );
}

#[tokio::test]
async fn cancelled_withdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let dest = "account2".parse::<AccountId>().expect("account");
    let fee = "fee".parse::<AccountId>().expect("account");
    let (assets, ledger) = get_asset_manager_and_ledger().await;

    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, 1000).expect("amount"),
    )
    .await;
    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, 2000).expect("amount"),
    )
    .await;

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 3000).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );

    ledger
        .new_transaction(
            "Exchange one".to_owned(),
            Status::Settled,
            vec![(
                source.clone(),
                assets.amount_by_and_cents(2, 1300).expect("amount"),
            )],
            vec![
                (
                    dest.clone(),
                    assets.amount_by_and_cents(2, 1250).expect("amount"),
                ),
                (
                    fee.clone(),
                    assets.amount_by_and_cents(2, 50).expect("amount"),
                ),
            ],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );

    let tx_id = withdrawal(
        &ledger,
        &source,
        Status::Pending,
        assets.amount_by_and_cents(2, 1700).expect("amount"),
    )
    .await
    .expect("valid tx");

    assert!(ledger
        .get_balance(&source)
        .await
        .expect("balance")
        .is_empty());
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );

    ledger
        .change_status(&tx_id, Status::Cancelled, "cancelled by test".to_owned())
        .await
        .expect("valid tx");

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1700).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );

    assert_eq!(
        vec![assets.amount_by_and_cents(2, 1250).expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![assets.amount_by_and_cents(2, 50).expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );
}

#[tokio::test]
async fn negative_withdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let (assets, ledger) = get_asset_manager_and_ledger().await;

    deposit(
        &ledger,
        &source,
        assets.amount_by_and_cents(2, -1000).expect("amount"),
    )
    .await;

    assert_eq!(
        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );

    assert_eq!(
        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );

    assert!(withdrawal(
        &ledger,
        &source,
        Status::Settled,
        assets.amount_by_and_cents(2, -1000).expect("amount"),
    )
    .await
    .is_err());

    assert!(withdrawal(
        &ledger,
        &source,
        Status::Settled,
        assets.amount_by_and_cents(2, -1).expect("amount"),
    )
    .await
    .is_err());

    assert!(withdrawal(
        &ledger,
        &source,
        Status::Settled,
        assets.amount_by_and_cents(2, 0).expect("amount"),
    )
    .await
    .is_err());

    assert!(withdrawal(
        &ledger,
        &source,
        Status::Settled,
        assets.amount_by_and_cents(2, 10).expect("amount"),
    )
    .await
    .is_err());

    assert_eq!(
        vec![assets.amount_by_and_cents(2, -1000).expect("amount")],
        ledger.get_balance(&source).await.expect("balance")
    );
}