use crate::{gdev, Client, GdevConfig};

use anyhow::{anyhow, Result};
use sp_core::{crypto::AccountId32, sr25519::Pair, DeriveJunction, Pair as _};
use subxt::ext::sp_runtime::MultiAddress;
use subxt::tx::{BaseExtrinsicParamsBuilder, PairSigner};

pub async fn repart(
    pair: Pair,
    client: Client,
    target: u32,
    actual_repart: Option<u32>,
) -> Result<()> {
    let mut pairs = Vec::new();
    for i in actual_repart.unwrap_or_default()..target {
        let pair_i = pair
            .derive(std::iter::once(DeriveJunction::hard::<u32>(i)), None)
            .map_err(|_| anyhow!("Fail to derive //{}", i))?
            .0;
        pairs.push((i, pair_i));
    }

    for (i, pair_i) in &pairs {
        /*let _ = api
            .tx()
            .balances()
            .transfer(MultiAddress::Id(pair_i.public().into()), 501)?
            .sign_and_submit_then_watch(&signer, BaseExtrinsicParamsBuilder::new())
            .await?
            .wait_for_in_block()
            .await?;
        signer.increment_nonce();*/

        if let Some(pair_i_account) = client
            .storage()
            .fetch(
                &gdev::storage().system().account(&pair_i.public().into()),
                None,
            )
            .await?
        {
            logs::info!("account //{} balance: {}", i, pair_i_account.data.free);
        }
    }

    Ok(())
}

pub async fn spam_roll(pair: Pair, client: Client, actual_repart: usize) -> Result<()> {
    let mut pairs =
        Vec::<(PairSigner<GdevConfig, Pair>, AccountId32)>::with_capacity(actual_repart);
    for i in 0..actual_repart {
        let pair_i = pair
            .derive(std::iter::once(DeriveJunction::hard::<u32>(i as u32)), None)
            .map_err(|_| anyhow!("Fail to derive //{}", i))?
            .0;
        let account_id_i = pair_i.public().into();
        pairs.push((PairSigner::new(pair_i), account_id_i));
    }

    loop {
        let mut watchers = Vec::with_capacity(actual_repart);
        for i in 0..(actual_repart - 1) {
            let dest: AccountId32 = pairs[i + 1].1.clone();
            let watcher = client
                .tx()
                .sign_and_submit_then_watch(
                    &gdev::tx().balances().transfer(MultiAddress::Id(dest), 1),
                    &pairs[i].0,
                    BaseExtrinsicParamsBuilder::new(),
                )
                .await?;
            pairs[i].0.increment_nonce();
            logs::info!("send 1 cent from //{} to //{}", i, i + 1);
            watchers.push(watcher);
        }
        let dest: AccountId32 = pairs[0].1.clone();
        let watcher = client
            .tx()
            .sign_and_submit_then_watch(
                &gdev::tx().balances().transfer(MultiAddress::Id(dest), 1),
                &pairs[actual_repart - 1].0,
                BaseExtrinsicParamsBuilder::new(),
            )
            .await?;
        pairs[actual_repart - 1].0.increment_nonce();
        logs::info!("send 1 cent from //{} to //0", actual_repart - 1);
        watchers.push(watcher);

        // Wait all transactions
        for watcher in watchers {
            watcher.wait_for_in_block().await?;
        }
    }
}