use super::{deposit, get_asset_manager_and_ledger};
use crate::{AccountId, Asset, Filter, Type};

#[tokio::test]
async fn multi_account_transfers() {
    let accounts = (0..100)
        .map(|i| format!("account{}", i).parse::<AccountId>())
        .collect::<Result<Vec<AccountId>, _>>()
        .expect("valid");
    let target = "target".parse::<AccountId>().expect("target account");
    let ledger = get_asset_manager_and_ledger().await;
    let usd: Asset = "USD/2".parse().expect("asset");

    for account in &accounts {
        deposit(&ledger, account, usd.from_human("1000").expect("amount")).await;
    }

    let mut from = vec![];
    for (p, account) in accounts.iter().enumerate() {
        assert_eq!(
            vec![usd.from_human("1000").expect("amount"),],
            ledger.get_balance(account).await.expect("balance")
        );
        from.push((account.clone(), usd.new_amount(1000 * ((p + 1) as i128))));
    }

    ledger
        .new_transaction(
            "test tx".to_owned(),
            "settled".into(),
            from,
            vec![(target.clone(), usd.from_human("50500").expect("amount"))],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![usd.from_human("50500").expect("amount"),],
        ledger.get_balance(&target).await.expect("balance")
    );

    let filter = Filter {
        spends: vec![accounts[0].clone()],
        typ: vec![Type::Exchange],
        ..Default::default()
    };

    let rev_id = ledger.get_transactions(filter).await.expect("valid")[0]
        .revision_id
        .clone();

    for _ in &accounts {
        let filter = Filter {
            spends: vec![accounts[0].clone()],
            typ: vec![Type::Exchange],
            ..Default::default()
        };
        let txs = ledger.get_transactions(filter).await.expect("valid");
        assert_eq!(1, txs.len());
        assert_eq!(rev_id, txs[0].revision_id);
    }
}