import 'dart:convert';
import 'dart:io';
import 'dart:math';

import 'package:decimal/decimal.dart';
import 'package:isar/isar.dart';
import 'package:socks5_proxy/socks_client.dart';
import 'package:solana/dto.dart';
import 'package:solana/solana.dart';
import 'package:tuple/tuple.dart';

import '../../../models/balance.dart';
import '../../../models/isar/models/blockchain_data/transaction.dart' as isar;
import '../../../models/isar/models/isar_models.dart';
import '../../../models/node_model.dart';
import '../../../models/paymint/fee_object_model.dart';
import '../../../services/node_service.dart';
import '../../../services/tor_service.dart';
import '../../../utilities/amount/amount.dart';
import '../../../utilities/logger.dart';
import '../../crypto_currency/crypto_currency.dart';
import '../../models/tx_data.dart';
import '../intermediate/bip39_wallet.dart';

class SolanaWallet extends Bip39Wallet<Solana> {
  SolanaWallet(CryptoCurrencyNetwork network) : super(Solana(network));

  static const String _addressDerivationPath = "m/44'/501'/0'/0'";

  NodeModel? _solNode;

  RpcClient? _rpcClient; // The Solana RpcClient.

  Future<Ed25519HDKeyPair> _getKeyPair() async {
    return Ed25519HDKeyPair.fromMnemonic(
      await getMnemonic(),
      account: 0,
      change: 0,
    );
  }

  Future<Address> _generateAddress() async {
    final addressStruct = Address(
      walletId: walletId,
      value: (await _getKeyPair()).address,
      publicKey: List<int>.empty(),
      derivationIndex: 0,
      derivationPath: DerivationPath()..value = _addressDerivationPath,
      type: cryptoCurrency.primaryAddressType,
      subType: AddressSubType.receiving,
    );
    return addressStruct;
  }

  Future<int> _getCurrentBalanceInLamports() async {
    _checkClient();
    final balance = await _rpcClient?.getBalance((await _getKeyPair()).address);
    return balance!.value;
  }

  Future<int?> _getEstimatedNetworkFee(Amount transferAmount) async {
    final latestBlockhash = await _rpcClient?.getLatestBlockhash();
    final pubKey = (await _getKeyPair()).publicKey;

    final compiledMessage = Message(
      instructions: [
        SystemInstruction.transfer(
          fundingAccount: pubKey,
          recipientAccount: pubKey,
          lamports: transferAmount.raw.toInt(),
        ),
      ],
    ).compile(
      recentBlockhash: latestBlockhash!.value.blockhash,
      feePayer: pubKey,
    );

    return await _rpcClient?.getFeeForMessage(
      base64Encode(compiledMessage.toByteArray().toList()),
    );
  }

  @override
  FilterOperation? get changeAddressFilterOperation =>
      throw UnimplementedError();

  @override
  Future<void> checkSaveInitialReceivingAddress() async {
    try {
      Address? address = await getCurrentReceivingAddress();

      if (address == null) {
        address = await _generateAddress();

        await mainDB.updateOrPutAddresses([address]);
      }
    } catch (e, s) {
      Logging.instance.log(
        "$runtimeType  checkSaveInitialReceivingAddress() failed: $e\n$s",
        level: LogLevel.Error,
      );
    }
  }

  @override
  Future<TxData> prepareSend({required TxData txData}) async {
    try {
      _checkClient();

      if (txData.recipients == null || txData.recipients!.length != 1) {
        throw Exception("$runtimeType prepareSend requires 1 recipient");
      }

      final Amount sendAmount = txData.amount!;

      if (sendAmount > info.cachedBalance.spendable) {
        throw Exception("Insufficient available balance");
      }

      final feeAmount = await _getEstimatedNetworkFee(sendAmount);
      if (feeAmount == null) {
        throw Exception(
          "Failed to get fees, please check your node connection.",
        );
      }

      final address = await getCurrentReceivingAddress();

      // Rent exemption of Solana
      final accInfo = await _rpcClient?.getAccountInfo(address!.value);
      final int minimumRent =
          await _rpcClient?.getMinimumBalanceForRentExemption(
                accInfo!.value!.data.toString().length,
              ) ??
              0; // TODO revisit null condition.
      if (minimumRent >
          ((await _getCurrentBalanceInLamports()) -
              txData.amount!.raw.toInt() -
              feeAmount)) {
        throw Exception(
          "Insufficient remaining balance for rent exemption, minimum rent: "
          "${minimumRent / pow(10, cryptoCurrency.fractionDigits)}",
        );
      }

      return txData.copyWith(
        fee: Amount(
          rawValue: BigInt.from(feeAmount),
          fractionDigits: cryptoCurrency.fractionDigits,
        ),
      );
    } catch (e, s) {
      Logging.instance.log(
        "$runtimeType Solana prepareSend failed: $e\n$s",
        level: LogLevel.Error,
      );
      rethrow;
    }
  }

  @override
  Future<TxData> confirmSend({required TxData txData}) async {
    try {
      _checkClient();

      final keyPair = await _getKeyPair();
      final recipientAccount = txData.recipients!.first;
      final recipientPubKey =
          Ed25519HDPublicKey.fromBase58(recipientAccount.address);
      final message = Message(
        instructions: [
          SystemInstruction.transfer(
            fundingAccount: keyPair.publicKey,
            recipientAccount: recipientPubKey,
            lamports: txData.amount!.raw.toInt(),
          ),
          ComputeBudgetInstruction.setComputeUnitPrice(
            microLamports: txData.fee!.raw.toInt() - 5000,
          ),
          // 5000 lamports is the base fee for a transaction. This instruction adds the necessary fee on top of base fee if it is needed.
          ComputeBudgetInstruction.setComputeUnitLimit(units: 1000000),
          // 1000000 is the multiplication number to turn the compute unit price of microLamports to lamports.
          // These instructions also help the user to not pay more than the shown fee.
          // See: https://solanacookbook.com/references/basic-transactions.html#how-to-change-compute-budget-fee-priority-for-a-transaction
        ],
      );

      final txid = await _rpcClient?.signAndSendTransaction(message, [keyPair]);
      return txData.copyWith(
        txid: txid,
      );
    } catch (e, s) {
      Logging.instance.log(
        "$runtimeType Solana confirmSend failed: $e\n$s",
        level: LogLevel.Error,
      );
      rethrow;
    }
  }

  @override
  Future<Amount> estimateFeeFor(Amount amount, int feeRate) async {
    _checkClient();

    if (info.cachedBalance.spendable.raw == BigInt.zero) {
      return Amount(
        rawValue: BigInt.zero,
        fractionDigits: cryptoCurrency.fractionDigits,
      );
    }

    final fee = await _getEstimatedNetworkFee(amount);
    if (fee == null) {
      throw Exception("Failed to get fees, please check your node connection.");
    }

    return Amount(
      rawValue: BigInt.from(fee),
      fractionDigits: cryptoCurrency.fractionDigits,
    );
  }

  @override
  Future<FeeObject> get fees async {
    _checkClient();

    final fee = await _getEstimatedNetworkFee(
      Amount.fromDecimal(
        Decimal.one, // 1 SOL
        fractionDigits: cryptoCurrency.fractionDigits,
      ),
    );
    if (fee == null) {
      throw Exception("Failed to get fees, please check your node connection.");
    }

    return FeeObject(
      numberOfBlocksFast: 1,
      numberOfBlocksAverage: 1,
      numberOfBlocksSlow: 1,
      fast: fee,
      medium: fee,
      slow: fee,
    );
  }

  @override
  Future<bool> pingCheck() {
    try {
      _checkClient();
      _rpcClient?.getHealth();
      return Future.value(true);
    } catch (e, s) {
      Logging.instance.log(
        "$runtimeType Solana pingCheck failed: $e\n$s",
        level: LogLevel.Error,
      );
      return Future.value(false);
    }
  }

  @override
  FilterOperation? get receivingAddressFilterOperation =>
      FilterGroup.and(standardReceivingAddressFilters);

  @override
  Future<void> recover({required bool isRescan}) async {
    await refreshMutex.protect(() async {
      final addressStruct = await _generateAddress();

      await mainDB.updateOrPutAddresses([addressStruct]);

      if (info.cachedReceivingAddress != addressStruct.value) {
        await info.updateReceivingAddress(
          newAddress: addressStruct.value,
          isar: mainDB.isar,
        );
      }

      await Future.wait([
        updateBalance(),
        updateChainHeight(),
        updateTransactions(),
      ]);
    });
  }

  @override
  Future<void> updateBalance() async {
    try {
      final address = await getCurrentReceivingAddress();
      _checkClient();

      final balance = await _rpcClient?.getBalance(address!.value);

      // Rent exemption of Solana
      final accInfo = await _rpcClient?.getAccountInfo(address!.value);
      // TODO [prio=low]: handle null account info.
      final int minimumRent =
          await _rpcClient?.getMinimumBalanceForRentExemption(
                accInfo!.value!.data.toString().length,
              ) ??
              0;
      // TODO [prio=low]: revisit null condition.
      final spendableBalance = balance!.value - minimumRent;

      final newBalance = Balance(
        total: Amount(
          rawValue: BigInt.from(balance.value),
          fractionDigits: cryptoCurrency.fractionDigits,
        ),
        spendable: Amount(
          rawValue: BigInt.from(spendableBalance),
          fractionDigits: cryptoCurrency.fractionDigits,
        ),
        blockedTotal: Amount(
          rawValue: BigInt.from(minimumRent),
          fractionDigits: cryptoCurrency.fractionDigits,
        ),
        pendingSpendable: Amount(
          rawValue: BigInt.zero,
          fractionDigits: cryptoCurrency.fractionDigits,
        ),
      );

      await info.updateBalance(newBalance: newBalance, isar: mainDB.isar);
    } catch (e, s) {
      Logging.instance.log(
        "Error getting balance in solana_wallet.dart: $e\n$s",
        level: LogLevel.Error,
      );
    }
  }

  @override
  Future<void> updateChainHeight() async {
    try {
      _checkClient();

      final int blockHeight = await _rpcClient?.getSlot() ?? 0;
      // TODO [prio=low]: Revisit null condition.

      await info.updateCachedChainHeight(
        newHeight: blockHeight,
        isar: mainDB.isar,
      );
    } catch (e, s) {
      Logging.instance.log(
        "Error occurred in solana_wallet.dart while getting"
        " chain height for solana: $e\n$s",
        level: LogLevel.Error,
      );
    }
  }

  @override
  Future<void> updateNode() async {
    _solNode = getCurrentNode();
    await refresh();
  }

  @override
  NodeModel getCurrentNode() {
    return _solNode ??
        NodeService(secureStorageInterface: secureStorageInterface)
            .getPrimaryNodeFor(currency: info.coin) ??
        info.coin.defaultNode;
  }

  @override
  Future<void> updateTransactions() async {
    try {
      _checkClient();

      final transactionsList = await _rpcClient?.getTransactionsList(
        (await _getKeyPair()).publicKey,
        encoding: Encoding.jsonParsed,
      );
      final txsList =
          List<Tuple2<isar.Transaction, Address>>.empty(growable: true);

      final myAddress = (await getCurrentReceivingAddress())!;

      // TODO [prio=low]: Revisit null assertion below.

      for (final tx in transactionsList!) {
        final senderAddress =
            (tx.transaction as ParsedTransaction).message.accountKeys[0].pubkey;
        var receiverAddress =
            (tx.transaction as ParsedTransaction).message.accountKeys[1].pubkey;
        var txType = isar.TransactionType.unknown;
        final txAmount = Amount(
          rawValue:
              BigInt.from(tx.meta!.postBalances[1] - tx.meta!.preBalances[1]),
          fractionDigits: cryptoCurrency.fractionDigits,
        );

        if ((senderAddress == myAddress.value) &&
            (receiverAddress == "11111111111111111111111111111111")) {
          // The account that is only 1's are System Program accounts which
          // means there is no receiver except the sender,
          // see: https://explorer.solana.com/address/11111111111111111111111111111111
          txType = isar.TransactionType.sentToSelf;
          receiverAddress = senderAddress;
        } else if (senderAddress == myAddress.value) {
          txType = isar.TransactionType.outgoing;
        } else if (receiverAddress == myAddress.value) {
          txType = isar.TransactionType.incoming;
        }

        final transaction = isar.Transaction(
          walletId: walletId,
          txid: (tx.transaction as ParsedTransaction).signatures[0],
          timestamp: tx.blockTime!,
          type: txType,
          subType: isar.TransactionSubType.none,
          amount: tx.meta!.postBalances[1] - tx.meta!.preBalances[1],
          amountString: txAmount.toJsonString(),
          fee: tx.meta!.fee,
          height: tx.slot,
          isCancelled: false,
          isLelantus: false,
          slateId: null,
          otherData: null,
          inputs: [],
          outputs: [],
          nonce: null,
          numberOfMessages: 0,
        );

        final txAddress = Address(
          walletId: walletId,
          value: receiverAddress,
          publicKey: List<int>.empty(),
          derivationIndex: 0,
          derivationPath: DerivationPath()..value = _addressDerivationPath,
          type: AddressType.solana,
          subType: txType == isar.TransactionType.outgoing
              ? AddressSubType.unknown
              : AddressSubType.receiving,
        );

        txsList.add(Tuple2(transaction, txAddress));
      }
      await mainDB.addNewTransactionData(txsList, walletId);
    } catch (e, s) {
      Logging.instance.log(
        "Error occurred in solana_wallet.dart while getting"
        " transactions for solana: $e\n$s",
        level: LogLevel.Error,
      );
    }
  }

  @override
  Future<bool> updateUTXOs() {
    // No UTXOs in Solana
    return Future.value(false);
  }

  /// Make sure the Solana RpcClient uses Tor if it's enabled.
  ///
  void _checkClient() async {
    HttpClient? httpClient;

    if (prefs.useTor) {
      // Make proxied HttpClient.
      final ({InternetAddress host, int port}) proxyInfo =
          TorService.sharedInstance.getProxyInfo();

      final proxySettings = ProxySettings(proxyInfo.host, proxyInfo.port);
      httpClient = HttpClient();
      SocksTCPClient.assignToHttpClient(httpClient, [proxySettings]);
    }

    _rpcClient = RpcClient(
      "${getCurrentNode().host}:${getCurrentNode().port}",
      timeout: const Duration(seconds: 30),
      customHeaders: {},
      httpClient: httpClient,
    );
    return;
  }
}