cake_wallet/lib/view_model/dashboard/balance_view_model.dart

import 'package:cake_wallet/bitcoin/bitcoin_balance.dart';
import 'package:cake_wallet/bitcoin/bitcoin_wallet.dart';
import 'package:cake_wallet/core/wallet_base.dart';
import 'package:cake_wallet/entities/balance.dart';
import 'package:cake_wallet/entities/crypto_currency.dart';
import 'package:cake_wallet/monero/monero_balance.dart';
import 'package:cake_wallet/monero/monero_wallet.dart';
import 'package:cake_wallet/entities/balance_display_mode.dart';
import 'package:cake_wallet/entities/calculate_fiat_amount.dart';
import 'package:cake_wallet/store/app_store.dart';
import 'package:cake_wallet/view_model/dashboard/wallet_balance.dart';
import 'package:cake_wallet/store/settings_store.dart';
import 'package:cake_wallet/store/dashboard/fiat_conversion_store.dart';
import 'package:flutter/cupertino.dart';
import 'package:mobx/mobx.dart';

part 'balance_view_model.g.dart';

class BalanceViewModel = BalanceViewModelBase with _$BalanceViewModel;

abstract class BalanceViewModelBase with Store {
  BalanceViewModelBase(
      {@required this.appStore,
      @required this.settingsStore,
      @required this.fiatConvertationStore
  }){
    isReversing = false;

    wallet ??= appStore.wallet;

    _reaction = reaction((_) => appStore.wallet, _onWalletChange);

    final _wallet = wallet;

    if (_wallet is MoneroWallet) {
      balance = _wallet.balance;

      _onMoneroBalanceChangeReaction = reaction((_) => _wallet.balance,
              (MoneroBalance moneroBalance) => balance = moneroBalance);
    }

    if (_wallet is BitcoinWallet) {
      balance = _wallet.balance;

      _onBitcoinBalanceChangeReaction = reaction((_) => _wallet.balance,
              (BitcoinBalance bitcoinBalance) => balance = bitcoinBalance);
    }
  }

  final AppStore appStore;
  final SettingsStore settingsStore;
  final FiatConversionStore fiatConvertationStore;

  bool get canReverse =>
      (appStore.wallet.balance.availableModes as List).length > 1;

  @observable
  bool isReversing;

  @observable
  Balance balance;

  @observable
  WalletBase wallet;

  @computed
  double get price => fiatConvertationStore.prices[appStore.wallet.currency];

  @computed
  BalanceDisplayMode get savedDisplayMode => settingsStore.balanceDisplayMode;

  @computed
  BalanceDisplayMode get displayMode => isReversing
      ? (savedDisplayMode == BalanceDisplayMode.availableBalance
          ? BalanceDisplayMode.fullBalance
          : BalanceDisplayMode.availableBalance)
      : savedDisplayMode;

  @computed
  String get cryptoBalance {
    final walletBalance = _walletBalance;
    var _balance = '---';

    if (displayMode == BalanceDisplayMode.availableBalance) {
      _balance = walletBalance.unlockedBalance ?? '0.0';
    }

    if (displayMode == BalanceDisplayMode.fullBalance) {
      _balance = walletBalance.totalBalance ?? '0.0';
    }

    return _balance;
  }

  @computed
  String get fiatBalance {
    final walletBalance = _walletBalance;
    final fiatCurrency = settingsStore.fiatCurrency;
    var _balance = '---';

    final totalBalance =
        _getFiatBalance(price: price, cryptoAmount: walletBalance.totalBalance);

    final unlockedBalance = _getFiatBalance(
        price: price, cryptoAmount: walletBalance.unlockedBalance);

    if (displayMode == BalanceDisplayMode.availableBalance) {
      _balance = fiatCurrency.toString() + ' ' + unlockedBalance ?? '0.00';
    }

    if (displayMode == BalanceDisplayMode.fullBalance) {
      _balance = fiatCurrency.toString() + ' ' + totalBalance ?? '0.00';
    }

    return _balance;
  }

  @computed
  WalletBalance get _walletBalance {
    final _balance = balance;

    if (_balance is MoneroBalance) {
      return  WalletBalance(
          unlockedBalance: _balance.formattedUnlockedBalance,
          totalBalance: _balance.formattedFullBalance);
    }

    if (_balance is BitcoinBalance) {
      return WalletBalance(
          unlockedBalance: _balance.availableBalanceFormatted,
          totalBalance: _balance.totalFormatted);
    }

    return null;
  }

  @computed
  CryptoCurrency get currency => appStore.wallet.currency;

  @action
  void _onWalletChange(WalletBase wallet) {
    this.wallet = wallet;

    if (wallet is MoneroWallet) {
      balance = wallet.balance;

      _onMoneroBalanceChangeReaction?.reaction?.dispose();

      _onMoneroBalanceChangeReaction = reaction((_) => wallet.balance,
              (MoneroBalance moneroBalance) => balance = moneroBalance);
    }

    if (wallet is BitcoinWallet) {
      balance = wallet.balance;

      _onBitcoinBalanceChangeReaction?.reaction?.dispose();

      _onBitcoinBalanceChangeReaction = reaction((_) => wallet.balance,
              (BitcoinBalance bitcoinBalance) => balance = bitcoinBalance);
    }
  }

  ReactionDisposer _onMoneroBalanceChangeReaction;
  ReactionDisposer _onBitcoinBalanceChangeReaction;
  ReactionDisposer _reaction;

  String _getFiatBalance({double price, String cryptoAmount}) {
    if (cryptoAmount == null) {
      return '0.00';
    }

    return calculateFiatAmount(price: price, cryptoAmount: cryptoAmount);
  }
}