final networkInfo = NetworkInfo(
  bech32Hrp: 'did:com:',
  lcdUrl: 'http://localhost:1317',
);

final wallet = await StatelessCommercioAccount().generateNewWallet(
  networkInfo: networkInfo,
);

import 'package:bip39/bip39.dart' as bip39;
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_secure_storage/flutter_secure_storage.dart';
import 'package:sacco/sacco.dart';

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Example app',
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Example'),
        ),
        body: const ExamplePage(),
      ),
    );
  }
}

// Must use a StatefulWidget to keep track of the state changes
class ExamplePage extends StatefulWidget {
  const ExamplePage({Key key}) : super(key: key);

  @override
  _ExamplePageState createState() => _ExamplePageState();
}

class _ExamplePageState extends State<ExamplePage> {
  final TextEditingController walletTextController = TextEditingController();

  final NetworkInfo networkInfo = NetworkInfo(
    bech32Hrp: 'did:com:',
    lcdUrl: 'http://localhost:1317',
  );

  // We need to manager ourself the state
  bool isGenerating = false;

  Future<Wallet> _deriveNewWallet(BuildContext context) async {
    // Must know the BIP39 strength to generate 24 words
    final mnemonicString = bip39.generateMnemonic(strength: 256);
    final mnemonic = mnemonicString.split(' ');

    // This call is sync but the computation is expensive so the
    // call should be done in a separate thread (in Dart, Isolate)
    // Keep in mind that spawn a new thread every time is also expensive
    final computeData = _ComputeWalletData(mnemonic, networkInfo);
    final wallet = await compute(computeWallet, computeData);

    // Also this computation is expensive and should be done async
    // Keep in mind that a new thread is spaw so we should use a pool
    walletTextController.text = await compute(computeAddress, wallet);

    // Store the generated mnemonic
    const secureStorage = FlutterSecureStorage();

    // SecureStorage can raise an exception that we need to intercept
    try {
      await secureStorage.write(key: 'menmonic-key', value: mnemonicString);
    } catch (e) {
      Scaffold.of(context).showSnackBar(SnackBar(
        content: Text(e.toString()),
        backgroundColor: Colors.redAccent,
      ));
    }

    setState(() {
      isGenerating = false;
    });

    return wallet;
  }

  @override
  Widget build(BuildContext context) {
    return Center(
      child: FutureBuilder<Wallet>(
          future: isGenerating ? _deriveNewWallet(context) : null,
          builder: (context, snap) {
            if (snap.connectionState == ConnectionState.waiting) {
              walletTextController.text = 'Generating...';

              return Column(
                children: [
                  const FlatButton(
                    onPressed: null,
                    disabledTextColor: Colors.brown,
                    disabledColor: Colors.orangeAccent,
                    child: Text(
                      'Generating...',
                    ),
                  ),
                  const Text('Wallet address:'),
                  TextField(
                    controller: walletTextController,
                    readOnly: true,
                    style: TextStyle(color: Colors.grey),
                  ),
                ],
              );
            }

            return Column(
              children: [
                FlatButton(
                    onPressed: () => setState(() {
                          isGenerating = true;
                        }),
                    textColor: Colors.brown,
                    color: Colors.orange,
                    child: const Text('Generate new wallet')),
                const Text('Wallet address:'),
                TextField(
                  controller: walletTextController,
                  readOnly: true,
                ),
              ],
            );
          }),
    );
  }
}

// Private class only to send data to computeWallet
class _ComputeWalletData {
  final List<String> mnemonic;
  final NetworkInfo networkInfo;
  final String lastDerivationPathSegment;

  const _ComputeWalletData(
    this.mnemonic,
    this.networkInfo, {
    this.lastDerivationPathSegment,
  });
}

// Global function only to derive the wallet in a separate thread
Wallet computeWallet(_ComputeWalletData data) {
  // Must check if the optional argument is null to call the right version
  // and do not override the argument
  if (data.lastDerivationPathSegment == null) {
    return Wallet.derive(data.mnemonic, data.networkInfo);
  }

  return Wallet.derive(data.mnemonic, data.networkInfo,
      lastDerivationPathSegment: data.lastDerivationPathSegment);
}

// Another global function only to keep things async
String computeAddress(Wallet wallet) {
  return wallet.bech32Address;
}

import 'package:commercio_ui/commercio_ui.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';
import 'package:flutter_bloc/flutter_bloc.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Example app',
      home: Scaffold(
        appBar: AppBar(
          title: const Text('Example'),
        ),
        // When providing the BLoC (on which the UI layer is built)
        // the Commercio Account can be customized
        body: BlocProvider(
          create: (_) => CommercioAccountGenerateWalletBloc(
            commercioAccount: StatefulCommercioAccount(),
          ),
          child: const ExamplePage(),
        ),
      ),
    );
  }
}

// Stateless widget, no more state to manage ourself
class ExamplePage extends StatelessWidget {
  const ExamplePage({Key key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        // Custom FlatButton that generate new mnemonic words and derive
        // the wallet.
        // The loading is automatic, all the information is stored inside the
        // CommercioAccount and the mnemonic are stored inside the secure
        // storage.
        //
        // Errors are handled automatically but the callback can be customized
        GenerateWalletFlatButton(
          event: () => const CommercioAccountGenerateWalletEvent(),
          disabledTextColor: Colors.brown,
          color: Colors.orangeAccent,
          child: (_) => const Text('Generate new wallet'),
        ),
        const Text('Wallet address:'),
        // Custom TextField that received the state with the wallet generated.
        // The callback provide all the flexibility to chose how to elaborate
        // the result.
        //
        // No problem on calling for the address, it's cached.
        GenerateWalletTextField(
          text: (_, data) => data.walletAddress,
          loading: (_) => 'Generating...',
        ),
      ],
    );
  }
}