/* 
 * This file is part of Stack Wallet.
 * 
 * Copyright (c) 2023 Cypher Stack
 * All Rights Reserved.
 * The code is distributed under GPLv3 license, see LICENSE file for details.
 * Generated by Cypher Stack on 2023-05-26
 *
 */

import 'dart:async';
import 'dart:convert';
import 'dart:ffi';
import 'dart:io';
import 'dart:isolate';

import 'package:decimal/decimal.dart';
import 'package:flutter/foundation.dart';
import 'package:flutter_libepiccash/epic_cash.dart';
import 'package:isar/isar.dart';
import 'package:mutex/mutex.dart';
import 'package:stack_wallet_backup/generate_password.dart';
import 'package:stackwallet/db/isar/main_db.dart';
import 'package:stackwallet/models/balance.dart';
import 'package:stackwallet/models/epicbox_config_model.dart';
import 'package:stackwallet/models/isar/models/blockchain_data/epic_transaction.dart';
import 'package:stackwallet/models/isar/models/isar_models.dart' as isar_models;
import 'package:stackwallet/models/node_model.dart';
import 'package:stackwallet/models/paymint/fee_object_model.dart';
import 'package:stackwallet/pages/settings_views/global_settings_view/manage_nodes_views/add_edit_node_view.dart';
import 'package:stackwallet/services/coins/coin_service.dart';
import 'package:stackwallet/services/event_bus/events/global/blocks_remaining_event.dart';
import 'package:stackwallet/services/event_bus/events/global/node_connection_status_changed_event.dart';
import 'package:stackwallet/services/event_bus/events/global/refresh_percent_changed_event.dart';
import 'package:stackwallet/services/event_bus/events/global/updated_in_background_event.dart';
import 'package:stackwallet/services/event_bus/events/global/wallet_sync_status_changed_event.dart';
import 'package:stackwallet/services/event_bus/global_event_bus.dart';
import 'package:stackwallet/services/mixins/epic_cash_hive.dart';
import 'package:stackwallet/services/mixins/wallet_cache.dart';
import 'package:stackwallet/services/mixins/wallet_db.dart';
import 'package:stackwallet/services/node_service.dart';
import 'package:stackwallet/utilities/amount/amount.dart';
import 'package:stackwallet/utilities/constants.dart';
import 'package:stackwallet/utilities/default_epicboxes.dart';
import 'package:stackwallet/utilities/default_nodes.dart';
import 'package:stackwallet/utilities/enums/coin_enum.dart';
import 'package:stackwallet/utilities/flutter_secure_storage_interface.dart';
import 'package:stackwallet/utilities/logger.dart';
import 'package:stackwallet/utilities/prefs.dart';
import 'package:stackwallet/utilities/stack_file_system.dart';
import 'package:stackwallet/utilities/test_epic_box_connection.dart';
import 'package:stackwallet/wallets/example/libepiccash.dart' as epiccash;
import 'package:tuple/tuple.dart';
import 'package:websocket_universal/websocket_universal.dart';

const int MINIMUM_CONFIRMATIONS = 3;

const String GENESIS_HASH_MAINNET = "";
const String GENESIS_HASH_TESTNET = "";

class BadEpicHttpAddressException implements Exception {
  final String? message;

  BadEpicHttpAddressException({this.message});

  @override
  String toString() {
    return "BadEpicHttpAddressException: $message";
  }
}

abstract class ListenerManager {
  static Pointer<Void>? pointer;
}

// isolate

Map<ReceivePort, Isolate> isolates = {};

Future<ReceivePort> getIsolate(Map<String, dynamic> arguments,
    {String name = ""}) async {
  ReceivePort receivePort =
      ReceivePort(); //port for isolate to receive messages.
  arguments['sendPort'] = receivePort.sendPort;
  Logging.instance.log("starting isolate ${arguments['function']} name: $name",
      level: LogLevel.Info);
  Isolate isolate = await Isolate.spawn(executeNative, arguments);
  isolates[receivePort] = isolate;
  return receivePort;
}

Future<void> executeNative(Map<String, dynamic> arguments) async {
  await Logging.instance.initInIsolate();
  final SendPort sendPort = arguments['sendPort'] as SendPort;
  final function = arguments['function'] as String;
  try {
    if (function == "scanOutPuts") {
      final wallet = arguments['wallet'] as String?;
      final startHeight = arguments['startHeight'] as int?;
      final numberOfBlocks = arguments['numberOfBlocks'] as int?;
      Map<String, dynamic> result = {};
      if (!(wallet == null || startHeight == null || numberOfBlocks == null)) {
        var outputs = await epiccash.LibEpiccash.scanOutputs(
          wallet: wallet,
          startHeight: startHeight,
          numberOfBlocks: numberOfBlocks,
        );
        result['outputs'] = outputs;
        sendPort.send(result);
        return;
      }
    }

    Logging.instance.log(
        "Error Arguments for $function not formatted correctly",
        level: LogLevel.Fatal);
    sendPort.send("Error Arguments for $function not formatted correctly");
  } catch (e, s) {
    Logging.instance.log(
        "An error was thrown in this isolate $function: $e\n$s",
        level: LogLevel.Error);
    sendPort
        .send("Error An error was thrown in this isolate $function: $e\n$s");
  } finally {
    await Logging.instance.isar?.close();
  }
}

void stop(ReceivePort port) {
  Isolate? isolate = isolates.remove(port);
  if (isolate != null) {
    isolate.kill(priority: Isolate.immediate);
    isolate = null;
  }
}

Future<String> deleteEpicWallet({
  required String walletId,
  required SecureStorageInterface secureStore,
}) async {
  final wallet = await secureStore.read(key: '${walletId}_wallet');
  String? config = await secureStore.read(key: '${walletId}_config');
  if (Platform.isIOS) {
    Directory appDir = await StackFileSystem.applicationRootDirectory();

    final path = "${appDir.path}/epiccash";
    final String name = walletId.trim();
    final walletDir = '$path/$name';

    var editConfig = jsonDecode(config as String);

    editConfig["wallet_dir"] = walletDir;
    config = jsonEncode(editConfig);
  }

  if (wallet == null) {
    return "Tried to delete non existent epic wallet file with walletId=$walletId";
  } else {
    try {
      return epiccash.LibEpiccash.deleteWallet(
        wallet: wallet,
        config: config!,
      );
    } catch (e, s) {
      Logging.instance.log("$e\n$s", level: LogLevel.Error);
      return "deleteEpicWallet($walletId) failed...";
    }
  }
}

class EpicCashWallet extends CoinServiceAPI
    with WalletCache, WalletDB, EpicCashHive {
  EpicCashWallet({
    required String walletId,
    required String walletName,
    required Coin coin,
    required SecureStorageInterface secureStore,
    MainDB? mockableOverride,
  }) {
    _walletId = walletId;
    _walletName = walletName;
    _coin = coin;
    _secureStore = secureStore;
    initCache(walletId, coin);
    initEpicCashHive(walletId);
    initWalletDB(mockableOverride: mockableOverride);

    Logging.instance.log("$walletName isolate length: ${isolates.length}",
        level: LogLevel.Info);
    for (final isolate in isolates.values) {
      isolate.kill(priority: Isolate.immediate);
    }
    isolates.clear();
  }

  static const integrationTestFlag =
      bool.fromEnvironment("IS_INTEGRATION_TEST");
  final m = Mutex();
  final syncMutex = Mutex();

  final _prefs = Prefs.instance;

  NodeModel? _epicNode;

  @override
  Future<void> updateNode(bool shouldRefresh) async {
    _epicNode = NodeService(secureStorageInterface: _secureStore)
            .getPrimaryNodeFor(coin: coin) ??
        DefaultNodes.getNodeFor(coin);
    // TODO notify ui/ fire event for node changed?

    String stringConfig = await getConfig();
    await _secureStore.write(key: '${_walletId}_config', value: stringConfig);

    if (shouldRefresh) {
      unawaited(refresh());
    }
  }

  @override
  set isFavorite(bool markFavorite) {
    _isFavorite = markFavorite;
    updateCachedIsFavorite(markFavorite);
  }

  @override
  bool get isFavorite => _isFavorite ??= getCachedIsFavorite();

  bool? _isFavorite;

  late ReceivePort receivePort;

  Future<String> startSync() async {
    Logging.instance.log("request start sync", level: LogLevel.Info);
    final wallet = await _secureStore.read(key: '${_walletId}_wallet');
    const int refreshFromNode = 1;
    if (!syncMutex.isLocked) {

      await epiccash.LibEpiccash.getWalletBalances(
        wallet: wallet!,
        refreshFromNode: refreshFromNode,
        minimumConfirmations: 10,
      );
    } else {
      Logging.instance.log("request start sync denied", level: LogLevel.Info);
    }
    return "";
  }

  Future<String> scanOutPuts() async {
    final String wallet =
        (await _secureStore.read(key: '${_walletId}_wallet'))!;
    final int lastScannedBlock =
        epicGetLastScannedBlock() ?? await getRestoreHeight();
    final int scanChunkSize = 10000;

    return await epiccash.LibEpiccash.scanOutputs(
      wallet: wallet,
      startHeight: lastScannedBlock,
      numberOfBlocks: scanChunkSize,
    );
  }

  Future<
      ({
        double awaitingFinalization,
        double pending,
        double spendable,
        double total
      })> allWalletBalances() async {
    final wallet = await _secureStore.read(key: '${_walletId}_wallet');
    const refreshFromNode = 0;
    return await epiccash.LibEpiccash.getWalletBalances(
      wallet: wallet!,
      refreshFromNode: refreshFromNode,
      minimumConfirmations: MINIMUM_CONFIRMATIONS,
    );
  }

  Timer? timer;
  late final Coin _coin;

  @override
  Coin get coin => _coin;

  late SecureStorageInterface _secureStore;

  /// returns an empty String on success, error message on failure
  Future<String> cancelPendingTransactionAndPost(String txSlateId) async {
    try {
      final String wallet = (await _secureStore.read(
        key: '${_walletId}_wallet',
      ))!;

      final result = await epiccash.LibEpiccash.cancelTransaction(
        wallet: wallet,
        transactionId: txSlateId,
      );
      Logging.instance.log(
        "cancel $txSlateId result: $result",
        level: LogLevel.Info,
      );
      return result;
    } catch (e, s) {
      Logging.instance.log("$e, $s", level: LogLevel.Error);
      return e.toString();
    }
  }

  @override
  Future<String> confirmSend({required Map<String, dynamic> txData}) async {
    try {
      final wallet = await _secureStore.read(key: '${_walletId}_wallet');
      EpicBoxConfigModel epicboxConfig = await getEpicBoxConfig();

      // TODO determine whether it is worth sending change to a change address.
      String slateId;
      String receiverAddress = txData['addresss'] as String;

      if (!receiverAddress.startsWith("http://") ||
          !receiverAddress.startsWith("https://")) {
        bool isEpicboxConnected = await testEpicboxServer(
            epicboxConfig.host, epicboxConfig.port ?? 443);
        if (!isEpicboxConnected) {
          throw Exception("Failed to send TX : Unable to reach epicbox server");
        }
      }

      ({String commitId, String slateId}) transaction;

      if (receiverAddress.startsWith("http://") ||
          receiverAddress.startsWith("https://")) {
        transaction = await epiccash.LibEpiccash.txHttpSend(
            wallet: wallet!,
            selectionStrategyIsAll: 0,
            minimumConfirmations: MINIMUM_CONFIRMATIONS,
            message: txData['onChainNote'] as String,
            amount: (txData['recipientAmt'] as Amount).raw.toInt(),
            address: txData['addresss'] as String);
      } else {
        transaction = await epiccash.LibEpiccash.createTransaction(
            wallet: wallet!,
            amount: (txData['recipientAmt'] as Amount).raw.toInt(),
            address: txData['addresss'] as String,
            secretKeyIndex: 0,
            epicboxConfig: epicboxConfig.toString(),
            minimumConfirmations: MINIMUM_CONFIRMATIONS,
            note: txData['onChainNote'] as String);
      }

      Map<String, String> txAddressInfo = {};
      txAddressInfo['from'] = await currentReceivingAddress;
      txAddressInfo['to'] = txData['addresss'] as String;
      await putSendToAddresses(transaction, txAddressInfo);

      slateId = transaction.slateId;
      return slateId;
    } catch (e, s) {
      Logging.instance.log("Error sending $e - $s", level: LogLevel.Error);
      rethrow;
    }
    // return "";
  }

  Future<isar_models.Address> _getReceivingAddressForIndex(
    int index,
  ) async {
    isar_models.Address? address = await db
        .getAddresses(walletId)
        .filter()
        .subTypeEqualTo(isar_models.AddressSubType.receiving)
        .and()
        .typeEqualTo(isar_models.AddressType.mimbleWimble)
        .and()
        .derivationIndexEqualTo(index)
        .findFirst();

    if (address == null) {
      final wallet = await _secureStore.read(key: '${_walletId}_wallet');
      EpicBoxConfigModel epicboxConfig = await getEpicBoxConfig();

      String? walletAddress = await epiccash.LibEpiccash.getAddressInfo(
        wallet: wallet!,
        index: index,
        epicboxConfig: epicboxConfig.toString(),
      );

      Logging.instance
          .log("WALLET_ADDRESS_IS $walletAddress", level: LogLevel.Info);

      address = isar_models.Address(
        walletId: walletId,
        value: walletAddress!,
        derivationIndex: index,
        derivationPath: null,
        type: isar_models.AddressType.mimbleWimble,
        subType: isar_models.AddressSubType.receiving,
        publicKey: [], // ??
      );

      await db.updateOrPutAddresses([address]);
    }

    return address;
  }

  @override
  Future<String> get currentReceivingAddress async =>
      (await _currentReceivingAddress)?.value ??
      (await _getReceivingAddressForIndex(0)).value;

  Future<isar_models.Address?> get _currentReceivingAddress => db
      .getAddresses(walletId)
      .filter()
      .subTypeEqualTo(isar_models.AddressSubType.receiving)
      .and()
      .typeEqualTo(isar_models.AddressType.mimbleWimble)
      .sortByDerivationIndexDesc()
      .findFirst();

  @override
  Future<void> exit() async {
    _hasCalledExit = true;
    timer?.cancel();
    timer = null;
    stopNetworkAlivePinging();
    for (final isolate in isolates.values) {
      isolate.kill(priority: Isolate.immediate);
    }
    isolates.clear();
    Logging.instance.log("EpicCash_wallet exit finished", level: LogLevel.Info);
  }

  bool _hasCalledExit = false;

  @override
  bool get hasCalledExit => _hasCalledExit;

  Future<FeeObject> _getFees() async {
    // TODO: implement _getFees
    return FeeObject(
        numberOfBlocksFast: 10,
        numberOfBlocksAverage: 10,
        numberOfBlocksSlow: 10,
        fast: 1,
        medium: 1,
        slow: 1);
  }

  @override
  Future<FeeObject> get fees => _feeObject ??= _getFees();
  Future<FeeObject>? _feeObject;

  @override
  Future<void> fullRescan(
    int maxUnusedAddressGap,
    int maxNumberOfIndexesToCheck,
  ) async {
    refreshMutex = true;
    try {
      GlobalEventBus.instance.fire(
        WalletSyncStatusChangedEvent(
          WalletSyncStatus.syncing,
          walletId,
          coin,
        ),
      );

      // clear blockchain info
      await db.deleteWalletBlockchainData(walletId);

      await epicUpdateLastScannedBlock(await getRestoreHeight());

      await _startScans();

      GlobalEventBus.instance.fire(
        WalletSyncStatusChangedEvent(
          WalletSyncStatus.synced,
          walletId,
          coin,
        ),
      );
    } catch (e, s) {
      GlobalEventBus.instance.fire(
        WalletSyncStatusChangedEvent(
          WalletSyncStatus.unableToSync,
          walletId,
          coin,
        ),
      );

      Logging.instance.log(
        "Exception rethrown from fullRescan(): $e\n$s",
        level: LogLevel.Error,
        printFullLength: true,
      );
      rethrow;
    } finally {
      refreshMutex = false;
    }
  }

  @override
  Future<void> initializeExisting() async {
    Logging.instance.log("initializeExisting() ${coin.prettyName} wallet",
        level: LogLevel.Info);

    final config = await getRealConfig();
    final password = await _secureStore.read(key: '${_walletId}_password');

    final walletOpen = await epiccash.LibEpiccash.openWallet(
        config: config, password: password!);
    await _secureStore.write(key: '${_walletId}_wallet', value: walletOpen);

    if (getCachedId() == null) {
      //todo: check if print needed
      // debugPrint("Exception was thrown");
      throw Exception(
          "Attempted to initialize an existing wallet using an unknown wallet ID!");
    }
    await _prefs.init();
    await updateNode(false);
    await _refreshBalance();
    // TODO: is there anything else that should be set up here whenever this wallet is first loaded again?
  }

  Future<void> storeEpicboxInfo() async {
    final wallet = await _secureStore.read(key: '${_walletId}_wallet');
    int index = 0;

    Logging.instance.log("This index is $index", level: LogLevel.Info);
    EpicBoxConfigModel epicboxConfig = await getEpicBoxConfig();

    String? walletAddress = await epiccash.LibEpiccash.getAddressInfo(
      wallet: wallet!,
      index: index,
      epicboxConfig: epicboxConfig.toString(),
    );

    Logging.instance
        .log("WALLET_ADDRESS_IS $walletAddress", level: LogLevel.Info);
    await _secureStore.write(
        key: '${_walletId}_address_info', value: walletAddress);
  }

  // TODO: make more robust estimate of date maybe using https://explorer.epic.tech/api-index
  int calculateRestoreHeightFrom({required DateTime date}) {
    int secondsSinceEpoch = date.millisecondsSinceEpoch ~/ 1000;
    const int epicCashFirstBlock = 1565370278;
    const double overestimateSecondsPerBlock = 61;
    int chosenSeconds = secondsSinceEpoch - epicCashFirstBlock;
    int approximateHeight = chosenSeconds ~/ overestimateSecondsPerBlock;
    //todo: check if print needed
    // debugPrint(
    //     "approximate height: $approximateHeight chosen_seconds: $chosenSeconds");
    int height = approximateHeight;
    if (height < 0) {
      height = 0;
    }
    return height;
  }

  @override
  Future<void> initializeNew(
    ({String mnemonicPassphrase, int wordCount})? data,
  ) async {
    await _prefs.init();
    await updateNode(false);
    final mnemonic = await _getMnemonicList();
    final String mnemonicString = mnemonic.join(" ");

    final String password = generatePassword();
    String stringConfig = await getConfig();
    EpicBoxConfigModel epicboxConfig = await getEpicBoxConfig();

    await _secureStore.write(
        key: '${_walletId}_mnemonic', value: mnemonicString);
    await _secureStore.write(key: '${_walletId}_config', value: stringConfig);
    await _secureStore.write(key: '${_walletId}_password', value: password);
    await _secureStore.write(
        key: '${_walletId}_epicboxConfig', value: epicboxConfig.toString());

    String name = _walletId;

    await epiccash.LibEpiccash.initializeNewWallet(
      config: stringConfig,
      mnemonic: mnemonicString,
      password: password,
      name: name,
    );

    //Open wallet
    final walletOpen = await epiccash.LibEpiccash.openWallet(
        config: stringConfig, password: password);
    await _secureStore.write(key: '${_walletId}_wallet', value: walletOpen);

    //Store Epic box address info
    await storeEpicboxInfo();

    // subtract a couple days to ensure we have a buffer for SWB
    final bufferedCreateHeight = calculateRestoreHeightFrom(
        date: DateTime.now().subtract(const Duration(days: 2)));

    await Future.wait([
      epicUpdateRestoreHeight(bufferedCreateHeight),
      updateCachedIsFavorite(false),
      updateCachedId(walletId),
      epicUpdateReceivingIndex(0),
      epicUpdateChangeIndex(0),
    ]);

    final initialReceivingAddress = await _getReceivingAddressForIndex(0);

    await db.putAddress(initialReceivingAddress);
  }

  bool refreshMutex = false;

  @override
  bool get isRefreshing => refreshMutex;

  @override
  // unused for epic
  Future<int> get maxFee => throw UnimplementedError();

  Future<List<String>> _getMnemonicList() async {
    String? _mnemonicString = await mnemonicString;
    if (_mnemonicString != null) {
      final List<String> data = _mnemonicString.split(' ');
      return data;
    } else {
      _mnemonicString = epiccash.LibEpiccash.getMnemonic();
      await _secureStore.write(
          key: '${_walletId}_mnemonic', value: _mnemonicString);
      final List<String> data = _mnemonicString.split(' ');
      return data;
    }
  }

  @override
  Future<List<String>> get mnemonic => _getMnemonicList();

  @override
  Future<String?> get mnemonicString =>
      _secureStore.read(key: '${_walletId}_mnemonic');

  @override
  Future<String?> get mnemonicPassphrase => _secureStore.read(
        key: '${_walletId}_mnemonicPassphrase',
      );

  @override
  Future<Map<String, dynamic>> prepareSend({
    required String address,
    required Amount amount,
    Map<String, dynamic>? args,
  }) async {
    try {
      int satAmount = amount.raw.toInt();
      int realfee = await nativeFee(satAmount);

      if (balance.spendable == amount) {
        satAmount = balance.spendable.raw.toInt() - realfee;
      }

      Map<String, dynamic> txData = {
        "fee": realfee,
        "addresss": address,
        "recipientAmt": Amount(
          rawValue: BigInt.from(satAmount),
          fractionDigits: coin.decimals,
        ),
      };

      Logging.instance.log("prepare send: $txData", level: LogLevel.Info);
      return txData;
    } catch (e, s) {
      Logging.instance.log("Error getting fees $e - $s", level: LogLevel.Error);
      rethrow;
    }
  }

  Future<int> nativeFee(int satoshiAmount,
      {bool ifErrorEstimateFee = false}) async {
    final wallet = await _secureStore.read(key: '${_walletId}_wallet');
    try {
      final available = balance.spendable.raw.toInt();

      var transactionFees = await epiccash.LibEpiccash.getTransactionFees(
        wallet: wallet!,
        amount: satoshiAmount,
        minimumConfirmations: MINIMUM_CONFIRMATIONS,
        available: available,
      );

      int realfee = 0;
      try {
        realfee =
            (Decimal.parse(transactionFees.fee.toString())).toBigInt().toInt();
      } catch (e, s) {
        //todo: come back to this
        debugPrint("$e $s");
      }
      return realfee;
    } catch (e, s) {
      Logging.instance.log("Error getting fees $e - $s", level: LogLevel.Error);
      rethrow;
    }
  }

  Future<String> currentWalletDirPath() async {
    Directory appDir = await StackFileSystem.applicationRootDirectory();

    final path = "${appDir.path}/epiccash";
    final String name = _walletId.trim();
    return '$path/$name';
  }

  Future<String> getConfig() async {
    if (_epicNode == null) {
      await updateNode(false);
    }
    final NodeModel node = _epicNode!;
    final String nodeAddress = node.host;
    final int port = node.port;

    final uri = Uri.parse(nodeAddress).replace(port: port);

    final String nodeApiAddress = uri.toString();

    final walletDir = await currentWalletDirPath();

    final Map<String, dynamic> config = {};
    config["wallet_dir"] = walletDir;
    config["check_node_api_http_addr"] = nodeApiAddress;
    config["chain"] = "mainnet";
    config["account"] = "default";
    config["api_listen_port"] = port;
    config["api_listen_interface"] =
        nodeApiAddress.replaceFirst(uri.scheme, "");
    String stringConfig = json.encode(config);
    return stringConfig;
  }

  Future<bool> testEpicboxServer(String host, int port) async {
    // TODO use an EpicBoxServerModel as the only param
    final websocketConnectionUri = 'wss://$host:$port';
    const connectionOptions = SocketConnectionOptions(
      pingIntervalMs: 3000,
      timeoutConnectionMs: 4000,

      /// see ping/pong messages in [logEventStream] stream
      skipPingMessages: true,

      /// Set this attribute to `true` if do not need any ping/pong
      /// messages and ping measurement. Default is `false`
      pingRestrictionForce: true,
    );

    final IMessageProcessor<String, String> textSocketProcessor =
        SocketSimpleTextProcessor();
    final textSocketHandler = IWebSocketHandler<String, String>.createClient(
      websocketConnectionUri,
      textSocketProcessor,
      connectionOptions: connectionOptions,
    );

    // Listening to server responses:
    bool isConnected = true;
    textSocketHandler.incomingMessagesStream.listen((inMsg) {
      Logging.instance.log(
          '> webSocket  got text message from server: "$inMsg" '
          '[ping: ${textSocketHandler.pingDelayMs}]',
          level: LogLevel.Info);
    });

    // Connecting to server:
    final isTextSocketConnected = await textSocketHandler.connect();
    if (!isTextSocketConnected) {
      // ignore: avoid_print
      Logging.instance.log(
          'Connection to [$websocketConnectionUri] failed for some reason!',
          level: LogLevel.Error);
      isConnected = false;
    }
    return isConnected;
  }

  Future<EpicBoxConfigModel> getEpicBoxConfig() async {
    EpicBoxConfigModel? _epicBoxConfig;
    // read epicbox config from secure store
    String? storedConfig =
        await _secureStore.read(key: '${_walletId}_epicboxConfig');

    // we should move to storing the primary server model like we do with nodes, and build the config from that (see epic-mobile)
    // EpicBoxServerModel? _epicBox = epicBox ??
    //     DB.instance.get<EpicBoxServerModel>(
    //         boxName: DB.boxNamePrimaryEpicBox, key: 'primary');
    // Logging.instance.log(
    //     "Read primary Epic Box config: ${jsonEncode(_epicBox)}",
    //     level: LogLevel.Info);

    if (storedConfig == null) {
      // if no config stored, use the default epicbox server as config
      _epicBoxConfig =
          EpicBoxConfigModel.fromServer(DefaultEpicBoxes.defaultEpicBoxServer);
    } else {
      // if a config is stored, test it

      _epicBoxConfig = EpicBoxConfigModel.fromString(
          storedConfig); // fromString handles checking old config formats
    }

    bool isEpicboxConnected = await testEpicboxServer(
        _epicBoxConfig.host, _epicBoxConfig.port ?? 443);

    if (!isEpicboxConnected) {
      // default Epicbox is not connected, default to Europe
      _epicBoxConfig = EpicBoxConfigModel.fromServer(DefaultEpicBoxes.europe);

      // example of selecting another random server from the default list
      // alternative servers: copy list of all default EB servers but remove the default default
      // List<EpicBoxServerModel> alternativeServers = DefaultEpicBoxes.all;
      // alternativeServers.removeWhere((opt) => opt.name == DefaultEpicBoxes.defaultEpicBoxServer.name);
      // alternativeServers.shuffle(); // randomize which server is used
      // _epicBoxConfig = EpicBoxConfigModel.fromServer(alternativeServers.first);

      // TODO test this connection before returning it
    }

    return _epicBoxConfig;
  }

  Future<String> getRealConfig() async {
    String? config = await _secureStore.read(key: '${_walletId}_config');
    if (Platform.isIOS) {
      final walletDir = await currentWalletDirPath();
      var editConfig = jsonDecode(config as String);

      editConfig["wallet_dir"] = walletDir;
      config = jsonEncode(editConfig);
    }
    return config!;
  }

  Future<void> updateEpicboxConfig(String host, int port) async {
    String stringConfig = jsonEncode({
      "epicbox_domain": host,
      "epicbox_port": port,
      "epicbox_protocol_unsecure": false,
      "epicbox_address_index": 0,
    });
    await _secureStore.write(
        key: '${_walletId}_epicboxConfig', value: stringConfig);
    // TODO: refresh anything that needs to be refreshed/updated due to epicbox info changed
  }

// Future<void> _startScans() async {
//   try {
//     //First stop the current listener
//     if (ListenerManager.pointer != null) {
//       Logging.instance
//           .log("LISTENER HANDLER IS NOT NULL ....", level: LogLevel.Info);
//       Logging.instance
//           .log("STOPPING ANY WALLET LISTENER ....", level: LogLevel.Info);
//       epicboxListenerStop(ListenerManager.pointer!);
//     }
//     final wallet = await _secureStore.read(key: '${_walletId}_wallet');
//
//     // max number of blocks to scan per loop iteration
//     const scanChunkSize = 10000;
//
//     // force firing of scan progress event
//     await getSyncPercent;
//
//     // fetch current chain height and last scanned block (should be the
//     // restore height if full rescan or a wallet restore)
//     int chainHeight = await this.chainHeight;
//     int lastScannedBlock =
//         epicGetLastScannedBlock() ?? await getRestoreHeight();
//
//     // loop while scanning in chain in chunks (of blocks?)
//     while (lastScannedBlock < chainHeight) {
//       Logging.instance.log(
//         "chainHeight: $chainHeight, lastScannedBlock: $lastScannedBlock",
//         level: LogLevel.Info,
//       );
//
//       // final int nextScannedBlock = await m.protect(() async {
//       final result = await m.protect(() async {
//         return await epiccash.LibEpiccash.scanOutputs(
//           wallet: wallet!,
//           startHeight: lastScannedBlock,
//           numberOfBlocks: scanChunkSize,
//         );
//
//         // // ReceivePort? receivePort;
//         // try {
//         //   // receivePort = await getIsolate({
//         //   //   "function": "scanOutPuts",
//         //   //   "wallet": wallet!,
//         //   //   "startHeight": lastScannedBlock,
//         //   //   "numberOfBlocks": scanChunkSize,
//         //   // }, name: walletName);
//         //
//         //   // get response
//         //   final message = await receivePort.first;
//         //
//         //   // check for error message
//         //   if (message is String) {
//         //     throw Exception("scanOutPuts isolate failed: $message");
//         //   }
//         //
//         //   // attempt to grab next scanned block number
//         //   final nextScanned = int.tryParse(message['outputs'] as String);
//         //   if (nextScanned == null) {
//         //     throw Exception(
//         //       "scanOutPuts failed to parse next scanned block number from: $message",
//         //     );
//         //   }
//         //
//         //   return nextScanned;
//         // } catch (_) {
//         //   rethrow;
//         // } finally {
//         //   if (receivePort != null) {
//         //     // kill isolate
//         //     stop(receivePort);
//         //   }
//         // }
//       });
//
//       // update local cache
//       await epicUpdateLastScannedBlock(result as int);
//
//       // force firing of scan progress event
//       await getSyncPercent;
//
//       // update while loop condition variables
//       chainHeight = await this.chainHeight;
//       lastScannedBlock = nextScannedBlock;
//     }
//
//     Logging.instance.log(
//       "_startScans successfully at the tip",
//       level: LogLevel.Info,
//     );
//     //Once scanner completes restart listener
//     await listenToEpicbox();
//   } catch (e, s) {
//     Logging.instance.log(
//       "_startScans failed: $e\n$s",
//       level: LogLevel.Error,
//     );
//     rethrow;
//   }
// }

  Future<void> _startScans() async {
    try {
      //First stop the current listener
      if (ListenerManager.pointer != null) {
        Logging.instance
            .log("LISTENER HANDLER IS NOT NULL ....", level: LogLevel.Info);
        Logging.instance
            .log("STOPPING ANY WALLET LISTENER ....", level: LogLevel.Info);
        epicboxListenerStop(ListenerManager.pointer!);
      }
      final wallet = await _secureStore.read(key: '${_walletId}_wallet');

      // max number of blocks to scan per loop iteration
      const scanChunkSize = 10000;

      // force firing of scan progress event
      await getSyncPercent;

      // fetch current chain height and last scanned block (should be the
      // restore height if full rescan or a wallet restore)
      int chainHeight = await this.chainHeight;
      int lastScannedBlock =
          epicGetLastScannedBlock() ?? await getRestoreHeight();

      // loop while scanning in chain in chunks (of blocks?)
      while (lastScannedBlock < chainHeight) {
        Logging.instance.log(
          "chainHeight: $chainHeight, lastScannedBlock: $lastScannedBlock",
          level: LogLevel.Info,
        );

        final int nextScannedBlock = await m.protect(() async {
          ReceivePort? receivePort;
          try {
            receivePort = await getIsolate({
              "function": "scanOutPuts",
              "wallet": wallet!,
              "startHeight": lastScannedBlock,
              "numberOfBlocks": scanChunkSize,
            }, name: walletName);

            // get response
            final message = await receivePort.first;

            // check for error message
            if (message is String) {
              throw Exception("scanOutPuts isolate failed: $message");
            }

            // attempt to grab next scanned block number
            final nextScanned = int.tryParse(message['outputs'] as String);
            if (nextScanned == null) {
              throw Exception(
                "scanOutPuts failed to parse next scanned block number from: $message",
              );
            }

            return nextScanned;
          } catch (_) {
            rethrow;
          } finally {
            if (receivePort != null) {
              // kill isolate
              stop(receivePort);
            }
          }
        });

        // update local cache
        await epicUpdateLastScannedBlock(nextScannedBlock);

        // force firing of scan progress event
        await getSyncPercent;

        // update while loop condition variables
        chainHeight = await this.chainHeight;
        lastScannedBlock = nextScannedBlock;
      }

      Logging.instance.log(
        "_startScans successfully at the tip",
        level: LogLevel.Info,
      );
      //Once scanner completes restart listener
      await listenToEpicbox();
    } catch (e, s) {
      Logging.instance.log(
        "_startScans failed: $e\n$s",
        level: LogLevel.Error,
      );
      rethrow;
    }
  }

  Future<double> get getSyncPercent async {
    int lastScannedBlock = epicGetLastScannedBlock() ?? 0;
    final _chainHeight = await chainHeight;
    double restorePercent = lastScannedBlock / _chainHeight;
    GlobalEventBus.instance
        .fire(RefreshPercentChangedEvent(highestPercent, walletId));
    if (restorePercent > highestPercent) {
      highestPercent = restorePercent;
    }

    final int blocksRemaining = _chainHeight - lastScannedBlock;
    GlobalEventBus.instance
        .fire(BlocksRemainingEvent(blocksRemaining, walletId));

    return restorePercent < 0 ? 0.0 : restorePercent;
  }

  double highestPercent = 0;

  @override
  Future<void> recoverFromMnemonic({
    required String mnemonic,
    String? mnemonicPassphrase, // unused in epic
    required int maxUnusedAddressGap,
    required int maxNumberOfIndexesToCheck,
    required int height,
  }) async {
    try {
      await _prefs.init();
      await updateNode(false);
      final String password = generatePassword();

      String stringConfig = await getConfig();
      EpicBoxConfigModel epicboxConfig = await getEpicBoxConfig();
      final String name = _walletName.trim();

      await _secureStore.write(key: '${_walletId}_mnemonic', value: mnemonic);
      await _secureStore.write(key: '${_walletId}_config', value: stringConfig);
      await _secureStore.write(key: '${_walletId}_password', value: password);

      await _secureStore.write(
          key: '${_walletId}_epicboxConfig', value: epicboxConfig.toString());

      await epiccash.LibEpiccash.recoverWallet(
        config: stringConfig,
        password: password,
        mnemonic: mnemonic,
        name: name,
      );

      await Future.wait([
        epicUpdateRestoreHeight(height),
        updateCachedId(walletId),
        epicUpdateReceivingIndex(0),
        epicUpdateChangeIndex(0),
        updateCachedIsFavorite(false),
      ]);

      //Open Wallet
      final walletOpen = await epiccash.LibEpiccash.openWallet(
          config: stringConfig, password: password);
      await _secureStore.write(key: '${_walletId}_wallet', value: walletOpen);

      //Store Epic box address info
      await storeEpicboxInfo();
    } catch (e, s) {
      Logging.instance
          .log("Error recovering wallet $e\n$s", level: LogLevel.Error);
      rethrow;
    }
  }

  Future<void> listenToEpicbox() async {
    Logging.instance.log("STARTING WALLET LISTENER ....", level: LogLevel.Info);
    final wallet = await _secureStore.read(key: '${_walletId}_wallet');
    EpicBoxConfigModel epicboxConfig = await getEpicBoxConfig();

    ListenerManager.pointer =
        epicboxListenerStart(wallet!, epicboxConfig.toString());
  }

  Future<int> getRestoreHeight() async {
    return epicGetRestoreHeight() ?? epicGetCreationHeight()!;
  }

  Future<int> get chainHeight async {
    try {
      final config = await getRealConfig();
      int? latestHeight =
      await epiccash.LibEpiccash.getChainHeight(config: config);

      await updateCachedChainHeight(latestHeight);
      if (latestHeight > storedChainHeight) {
        GlobalEventBus.instance.fire(
          UpdatedInBackgroundEvent(
            "Updated current chain height in $walletId $walletName!",
            walletId,
          ),
        );
      }
      return latestHeight;
    } catch (e, s) {
      Logging.instance.log("Exception caught in chainHeight: $e\n$s",
          level: LogLevel.Error);
      return storedChainHeight;
    }
  }

  @override
  int get storedChainHeight => getCachedChainHeight();

  bool _shouldAutoSync = true;

  @override
  bool get shouldAutoSync => _shouldAutoSync;

  @override
  set shouldAutoSync(bool shouldAutoSync) {
    if (_shouldAutoSync != shouldAutoSync) {
      _shouldAutoSync = shouldAutoSync;
      if (!shouldAutoSync) {
        Logging.instance.log("Should autosync", level: LogLevel.Info);
        timer?.cancel();
        timer = null;
        stopNetworkAlivePinging();
      } else {
        startNetworkAlivePinging();
        refresh();
      }
    }
  }

  Future<int> setCurrentIndex() async {
    try {
      final int receivingIndex = epicGetReceivingIndex()!;
      // TODO: go through pendingarray and processed array and choose the index
      //  of the last one that has not been processed, or the index after the one most recently processed;
      return receivingIndex;
    } catch (e, s) {
      Logging.instance.log("$e $s", level: LogLevel.Error);
      return 0;
    }
  }

  Future<Map<dynamic, dynamic>> removeBadAndRepeats(
      Map<dynamic, dynamic> pendingAndProcessedSlates) async {
    var clone = <dynamic, Map<dynamic, dynamic>>{};
    for (var indexPair in pendingAndProcessedSlates.entries) {
      clone[indexPair.key] = <dynamic, dynamic>{};
      for (var pendingProcessed
          in (indexPair.value as Map<dynamic, dynamic>).entries) {
        if (pendingProcessed.value is String &&
                (pendingProcessed.value as String)
                    .contains("has already been received") ||
            (pendingProcessed.value as String)
                .contains("Error Wallet store error: DB Not Found Error")) {
        } else if (pendingProcessed.value is String &&
            pendingProcessed.value as String == "[]") {
        } else {
          clone[indexPair.key]?[pendingProcessed.key] = pendingProcessed.value;
        }
      }
    }
    return clone;
  }

  Future<Map<dynamic, dynamic>> getSlatesToCommits() async {
    try {
      var slatesToCommits = epicGetSlatesToCommits();
      if (slatesToCommits == null) {
        slatesToCommits = <dynamic, dynamic>{};
      } else {
        slatesToCommits = slatesToCommits;
      }
      return slatesToCommits;
    } catch (e, s) {
      Logging.instance.log("$e $s", level: LogLevel.Error);
      return {};
    }
  }

  Future<bool> putSendToAddresses(({String slateId, String commitId}) slateData,
      Map<String, String> txAddressInfo) async {
    try {
      var slatesToCommits = await getSlatesToCommits();
      final from = txAddressInfo['from'];
      final to = txAddressInfo['to'];
      slatesToCommits[slateData.slateId] = {
        "commitId": slateData.commitId,
        "from": from,
        "to": to,
      };

      await epicUpdateSlatesToCommits(slatesToCommits);
      return true;
    } catch (e, s) {
      Logging.instance
          .log("ERROR STORING ADDRESS $e $s", level: LogLevel.Error);
      return false;
    }
  }

  Future<bool> putSlatesToCommits(String slateMessage, String encoded) async {
    try {
      var slatesToCommits = await getSlatesToCommits();
      final slate = jsonDecode(slateMessage);
      final part1 = jsonDecode(slate[0] as String);
      final part2 = jsonDecode(slate[1] as String);
      final slateId = part1[0]['tx_slate_id'];
      if (slatesToCommits[slateId] != null &&
          (slatesToCommits[slateId] as Map).isNotEmpty) {
        // This happens when the sender receives the response.
        return true;
      }
      final commitId = part2['tx']['body']['outputs'][0]['commit'];

      final toFromInfoString = jsonDecode(encoded);
      final toFromInfo = jsonDecode(toFromInfoString[0] as String);
      final from = toFromInfo['from'];
      final to = toFromInfo['to'];
      slatesToCommits[slateId] = {
        "commitId": commitId,
        "from": from,
        "to": to,
      };
      await epicUpdateSlatesToCommits(slatesToCommits);
      return true;
    } catch (e, s) {
      Logging.instance.log("$e $s", level: LogLevel.Error);
      return false;
    }
  }

  /// Refreshes display data for the wallet
  @override
  Future<void> refresh() async {
    Logging.instance
        .log("$walletId $walletName Calling refresh", level: LogLevel.Info);
    if (refreshMutex) {
      Logging.instance.log("$walletId $walletName refreshMutex denied",
          level: LogLevel.Info);
      return;
    } else {
      refreshMutex = true;
    }

    try {
      GlobalEventBus.instance.fire(
        WalletSyncStatusChangedEvent(
          WalletSyncStatus.syncing,
          walletId,
          coin,
        ),
      );

      if (epicGetCreationHeight() == null) {
        await epicUpdateCreationHeight(await chainHeight);
      }

      final int curAdd = await setCurrentIndex();
      await _getReceivingAddressForIndex(curAdd);

      await _startScans();

      unawaited(startSync());

      GlobalEventBus.instance.fire(RefreshPercentChangedEvent(0.0, walletId));

      GlobalEventBus.instance.fire(RefreshPercentChangedEvent(0.1, walletId));

      final currentHeight = await chainHeight;
      const storedHeight = 1; //await storedChainHeight;

      Logging.instance.log("chain height in refresh function: $currentHeight",
          level: LogLevel.Info);
      Logging.instance.log("cached height in refresh function: $storedHeight",
          level: LogLevel.Info);

      // TODO: implement refresh
      // TODO: check if it needs a refresh and if so get all of the most recent data.
      if (currentHeight != storedHeight) {
        await _refreshTransactions();
        GlobalEventBus.instance
            .fire(RefreshPercentChangedEvent(0.50, walletId));

        GlobalEventBus.instance.fire(UpdatedInBackgroundEvent(
            "New data found in $walletName in background!", walletId));
      }

      await _refreshBalance();

      GlobalEventBus.instance.fire(RefreshPercentChangedEvent(1.0, walletId));
      GlobalEventBus.instance.fire(
        WalletSyncStatusChangedEvent(
          WalletSyncStatus.synced,
          walletId,
          coin,
        ),
      );
      refreshMutex = false;
      if (shouldAutoSync) {
        timer ??= Timer.periodic(const Duration(seconds: 60), (timer) async {
          Logging.instance.log(
              "Periodic refresh check for $walletId $walletName in object instance: $hashCode",
              level: LogLevel.Info);
          // chain height check currently broken
          // if ((await chainHeight) != (await storedChainHeight)) {
          if (await refreshIfThereIsNewData()) {
            await refresh();
            GlobalEventBus.instance.fire(UpdatedInBackgroundEvent(
                "New data found in $walletId $walletName in background!",
                walletId));
          }
          // }
        });
      }
    } catch (error, strace) {
      refreshMutex = false;
      GlobalEventBus.instance.fire(
        NodeConnectionStatusChangedEvent(
          NodeConnectionStatus.disconnected,
          walletId,
          coin,
        ),
      );
      GlobalEventBus.instance.fire(
        WalletSyncStatusChangedEvent(
          WalletSyncStatus.unableToSync,
          walletId,
          coin,
        ),
      );
      Logging.instance.log(
          "Caught exception in refreshWalletData(): $error\n$strace",
          level: LogLevel.Warning);
    }
  }

  Future<bool> refreshIfThereIsNewData() async {
    if (_hasCalledExit) return false;
    // TODO returning true here signals this class to call refresh() after which it will fire an event that notifies the UI that new data has been fetched/found for this wallet
    return true;
    // TODO: do a quick check to see if there is any new data that would require a refresh
  }

  @override
  Future<bool> testNetworkConnection() async {
    try {
      // force unwrap optional as we want connection test to fail if wallet
      // wasn't initialized or epicbox node was set to null
      return await testEpicNodeConnection(
            NodeFormData()
              ..host = _epicNode!.host
              ..useSSL = _epicNode!.useSSL
              ..port = _epicNode!.port,
          ) !=
          null;
    } catch (e, s) {
      Logging.instance.log("$e\n$s", level: LogLevel.Warning);
      return false;
    }
  }

  Timer? _networkAliveTimer;

  void startNetworkAlivePinging() {
    // call once on start right away
    _periodicPingCheck();

    // then periodically check
    _networkAliveTimer = Timer.periodic(
      Constants.networkAliveTimerDuration,
      (_) async {
        _periodicPingCheck();
      },
    );
  }

  void _periodicPingCheck() async {
    bool hasNetwork = await testNetworkConnection();

    if (_isConnected != hasNetwork) {
      NodeConnectionStatus status = hasNetwork
          ? NodeConnectionStatus.connected
          : NodeConnectionStatus.disconnected;
      GlobalEventBus.instance
          .fire(NodeConnectionStatusChangedEvent(status, walletId, coin));

      _isConnected = hasNetwork;
      if (hasNetwork) {
        unawaited(refresh());
      }
    }
  }

  void stopNetworkAlivePinging() {
    _networkAliveTimer?.cancel();
    _networkAliveTimer = null;
  }

  bool _isConnected = false;

  @override
  bool get isConnected => _isConnected;

  Future<void> _refreshTransactions() async {

    final wallet = await _secureStore.read(key: '${_walletId}_wallet');
    const refreshFromNode = 1;

    var transactions = await epiccash.LibEpiccash.getTransactions(wallet: wallet!, refreshFromNode: refreshFromNode);

    final List<Tuple2<isar_models.Transaction, isar_models.Address?>> txnsData =
        [];

    final slatesToCommits = await getSlatesToCommits();

    for (var tx in transactions) {
      Logging.instance.log("tx: $tx", level: LogLevel.Info);
      // // TODO: does "confirmed" mean finalized? If so please remove this todo
      final isConfirmed = tx.confirmed;

      int amt = 0;
      if (tx.txType == EpicTransactionType.TxReceived ||
          tx.txType == EpicTransactionType.TxReceivedCancelled) {
        amt = int.parse(tx.amountCredited);
      } else {
        int debit = int.parse(tx.amountDebited);
        int credit = int.parse(tx.amountCredited);
        int fee = int.parse((tx.fee ?? "0")); //TODO -double check this
        amt = debit - credit - fee;
      }

      DateTime dt = DateTime.parse(tx.creationTs);

      String? slateId = tx.txSlateId;
      String address = slatesToCommits[slateId]
              ?[tx.txType == EpicTransactionType.TxReceived ? "from" : "to"] as String? ??
          "";
      String? commitId = slatesToCommits[slateId]?['commitId'] as String?;
      int? numberOfMessages = tx.messages?.messages.length;
      String? onChainNote = tx.messages?.messages[0].message;

      int? height;

      if (isConfirmed) {
        height = tx.kernelLookupMinHeight ?? 1;
      } else {
        height = null;
      }

      final isIncoming = (tx.txType == EpicTransactionType.TxReceived ||
          tx.txType == EpicTransactionType.TxReceivedCancelled);
      final txn = isar_models.Transaction(
        walletId: walletId,
        txid: commitId ?? tx.id.toString(),
        timestamp: (dt.millisecondsSinceEpoch ~/ 1000),
        type: isIncoming
            ? isar_models.TransactionType.incoming
            : isar_models.TransactionType.outgoing,
        subType: isar_models.TransactionSubType.none,
        amount: amt,
        amountString: Amount(
          rawValue: BigInt.from(amt),
          fractionDigits: coin.decimals,
        ).toJsonString(),
        fee: (tx.fee == "null") ? 0 : int.parse(tx.fee!),
        height: height,
        isCancelled: tx.txType == EpicTransactionType.TxSentCancelled ||
            tx.txType == EpicTransactionType.TxReceivedCancelled,
        isLelantus: false,
        slateId: slateId,
        nonce: null,
        otherData: onChainNote,
        inputs: [],
        outputs: [],
        numberOfMessages: numberOfMessages,
      );

      // txn.address =
      //     ""; // for this when you send a transaction you will just need to save in a hashmap in hive with the key being the txid, and the value being the address it was sent to. then you can look this value up right here in your hashmap.
      isar_models.Address? transactionAddress = await db
          .getAddresses(walletId)
          .filter()
          .valueEqualTo(address)
          .findFirst();

      if (transactionAddress == null) {
        if (isIncoming) {
          transactionAddress = isar_models.Address(
            walletId: walletId,
            value: address,
            publicKey: [],
            derivationIndex: 0,
            derivationPath: null,
            type: isar_models.AddressType.mimbleWimble,
            subType: isar_models.AddressSubType.receiving,
          );
        } else {
          final myRcvAddr = await currentReceivingAddress;
          final isSentToSelf = myRcvAddr == address;

          transactionAddress = isar_models.Address(
            walletId: walletId,
            value: address,
            publicKey: [],
            derivationIndex: isSentToSelf ? 0 : -1,
            derivationPath: null,
            type: isSentToSelf
                ? isar_models.AddressType.mimbleWimble
                : isar_models.AddressType.nonWallet,
            subType: isSentToSelf
                ? isar_models.AddressSubType.receiving
                : isar_models.AddressSubType.nonWallet,
          );
        }
      }

      txnsData.add(Tuple2(txn, transactionAddress));
    }

    await db.addNewTransactionData(txnsData, walletId);

    // quick hack to notify manager to call notifyListeners if
    // transactions changed
    if (txnsData.isNotEmpty) {
      GlobalEventBus.instance.fire(
        UpdatedInBackgroundEvent(
          "Transactions updated/added for: $walletId $walletName  ",
          walletId,
        ),
      );
    }
  }

  @override
  Future<void> updateSentCachedTxData(Map<String, dynamic> txData) async {
    // not used in epic
  }

  @override
  bool validateAddress(String address) {
    // Invalid address that contains HTTP and epicbox domain
    if ((address.startsWith("http://") || address.startsWith("https://")) &&
        address.contains("@")) {
      return false;
    }
    if (address.startsWith("http://") || address.startsWith("https://")) {
      if (Uri.tryParse(address) != null) {
        return true;
      }
    }
    return epiccash.LibEpiccash.validateSendAddress(address: address);
  }

  @override
  String get walletId => _walletId;
  late final String _walletId;

  @override
  String get walletName => _walletName;
  late String _walletName;

  @override
  set walletName(String newName) => _walletName = newName;

  @override
  void Function(bool)? get onIsActiveWalletChanged => (isActive) async {
        timer?.cancel();
        timer = null;
        if (isActive) {
          unawaited(startSync());
        } else {
          for (final isolate in isolates.values) {
            isolate.kill(priority: Isolate.immediate);
          }
          isolates.clear();
        }
        this.isActive = isActive;
      };

  bool isActive = false;

  @override
  Future<Amount> estimateFeeFor(Amount amount, int feeRate) async {
    int currentFee =
        await nativeFee(amount.raw.toInt(), ifErrorEstimateFee: true);
    return Amount(
      rawValue: BigInt.from(currentFee),
      fractionDigits: coin.decimals,
    );
  }

  // not used in epic currently
  @override
  Future<bool> generateNewAddress() async {
    try {
      return true;
    } catch (e, s) {
      Logging.instance.log(
          "Exception rethrown from generateNewAddress(): $e\n$s",
          level: LogLevel.Error);
      return false;
    }
  }

  Future<void> _refreshBalance() async {
    var balances = await allWalletBalances();
    _balance = Balance(
      total: Amount.fromDecimal(
        Decimal.parse(balances.total.toString()) +
            Decimal.parse(balances.awaitingFinalization.toString()),
        fractionDigits: coin.decimals,
      ),
      spendable: Amount.fromDecimal(
        Decimal.parse(balances.spendable.toString()),
        fractionDigits: coin.decimals,
      ),
      blockedTotal: Amount(
        rawValue: BigInt.zero,
        fractionDigits: coin.decimals,
      ),
      pendingSpendable: Amount.fromDecimal(
        Decimal.parse(balances.pending.toString()),
        fractionDigits: coin.decimals,
      ),
    );
    await updateCachedBalance(_balance!);
  }

  @override
  Balance get balance => _balance ??= getCachedBalance();
  Balance? _balance;

  @override
  Future<List<isar_models.UTXO>> get utxos => throw UnimplementedError();

  @override
  Future<List<isar_models.Transaction>> get transactions =>
      db.getTransactions(walletId).findAll();
}