export async function createWallet(addresses: string[], iteration, networkName?: string) {
  const walletName = 'Benchmark Wallet' + iteration;
  const password = 'iamsatoshi';
  const chain = 'BTC';
  const network = networkName || 'mainnet';
  const baseUrl = 'http://localhost:3000/api';
  let lockedWallet: Wallet;

  try {
    lockedWallet = await Wallet.loadWallet({ name: walletName });
  } catch (err) {
    lockedWallet = await Wallet.create({
      name: walletName,
      chain,
      network,
      baseUrl,
      password
    });
  }
  await lockedWallet.register({ baseUrl });

  if (addresses.length > 0) {
    const unlockedWallet = await lockedWallet.unlock(password);

    const keysToImport = addresses.map(a => ({ address: a }));
    await unlockedWallet.importKeys({ keys: keysToImport });
  }

  return lockedWallet;
}

async function benchMarkUtxoList(unlockedWallet: Wallet, addresses, includeSpent = false) {
  const utxoListStart = new Date();
  const utxoStream = unlockedWallet.getUtxos({ includeSpent });
  const utxoBenchmark = new Promise(resolve => {
    const utxos = new Array<string>();
    utxoStream
      .on('data', data => {
        const stringData = data.toString().replace(',\n', '');
        if (stringData.includes('{') && stringData.includes('}')) {
          utxos.push(JSON.parse(stringData));
        }
      })
      .on('complete', () => {
        const includeUnspentMsg = includeSpent ? '(+spent)' : '';
        console.log(
          `Listed ${includeUnspentMsg} `,
          (utxos || []).length,
          ' utxos for a wallet with',
          addresses.length,
          'addresses. Took ',
          new Date().getTime() - utxoListStart.getTime(),
          ' ms'
        );
        resolve(utxos);
      });
  });
  await utxoBenchmark;
}

    it('should generate addresses using rpc then import to wallet', async () => {
      address1 = await rpc.getnewaddress('');

      const importAddressJSON = {
        keys: [{ address: address1 }]
      };

      const unlockedWallet = await lockedWallet.unlock(password);

      await unlockedWallet.importKeys(importAddressJSON);

      const findWalletResult = await WalletStorage.collection.findOne({
        name: walletName,
        chain,
        network
      });

      if (findWalletResult && findWalletResult._id) {
        const findAddressResult = await WalletAddressStorage.collection
          .find({
            wallet: findWalletResult._id,
            chain,
            network,
            address: address1
          })
          .toArray();

        expect(findAddressResult[0]).to.have.deep.property('chain', chain);
        expect(findAddressResult[0]).to.have.deep.property('network', network);
        expect(findAddressResult[0]).to.have.deep.property('wallet', findWalletResult._id);
        expect(findAddressResult[0]).to.have.deep.property('address', address1);
        expect(findAddressResult[0]).to.have.deep.property('processed', true);
      }
    });