package com.tangem.wallet.bch;

import android.net.Uri;
import android.text.InputFilter;
import android.util.Log;

import com.tangem.App;
import com.tangem.data.network.ElectrumRequest;
import com.tangem.data.network.ServerApiElectrum;
import com.tangem.tangem_card.data.TangemCard;
import com.tangem.tangem_card.reader.CardProtocol;
import com.tangem.tangem_card.tasks.SignTask;
import com.tangem.tangem_card.util.Util;
import com.tangem.util.CryptoUtil;
import com.tangem.util.DecimalDigitsInputFilter;
import com.tangem.util.DerEncodingUtil;
import com.tangem.wallet.BCHUtils;
import com.tangem.wallet.BTCUtils;
import com.tangem.wallet.BalanceValidator;
import com.tangem.wallet.CoinData;
import com.tangem.wallet.CoinEngine;
import com.tangem.wallet.R;
import com.tangem.wallet.TangemContext;
import com.tangem.wallet.Transaction;
import com.tangem.wallet.UnspentOutputInfo;
import com.tangem.wallet.btc.BtcData;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.nio.ByteBuffer;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class BtcCashEngine extends CoinEngine {

    private static final String TAG = BtcCashEngine.class.getSimpleName();
    public BtcData coinData = null;

    public BtcCashEngine(TangemContext context) throws Exception {
        super(context);
        if (context.getCoinData() == null) {
            coinData = new BtcData();
            context.setCoinData(coinData);
        } else if (context.getCoinData() instanceof BtcData) {
            coinData = (BtcData) context.getCoinData();
        } else {
            throw new Exception("Invalid type of Blockchain data for BtcEngine");
        }
    }

    public BtcCashEngine() {

    }

    private static int getDecimals() {
        return 8;
    }

    private void checkBlockchainDataExists() throws Exception {
        if (coinData == null) throw new Exception("No blockchain data");
    }

    @Override
    public boolean awaitingConfirmation() {
        if (coinData == null) return false;
        return coinData.getBalanceUnconfirmed() != 0 || App.pendingTransactionsStorage.hasTransactions(ctx.getCard());
    }

    @Override
    public String getBalanceHTML() {
        Amount balance = getBalance();
        if (balance != null) {
            return balance.toDescriptionString(getDecimals());
        } else {
            return "";
        }
    }

    @Override
    public String getBalanceCurrency() {
        return "BCH";
    }

    @Override
    public boolean isBalanceNotZero() {
        if (coinData == null) return false;
        if (coinData.getBalanceInInternalUnits() == null) return false;
        return coinData.getBalanceInInternalUnits().notZero();
    }

    @Override
    public boolean hasBalanceInfo() {
        if (coinData == null) return false;
        return coinData.hasBalanceInfo();
    }

    @Override
    public boolean isExtractPossible() {
        if (!hasBalanceInfo()) {
            ctx.setMessage(R.string.loaded_wallet_error_obtaining_blockchain_data);
        } else if (!isBalanceNotZero()) {
            ctx.setMessage(R.string.general_wallet_empty);
        } else if (awaitingConfirmation()) {
            ctx.setMessage(R.string.loaded_wallet_message_wait);
        } else if (coinData.getUnspentTransactions().size() == 0) {
            ctx.setMessage(R.string.loaded_wallet_message_refresh);
        } else {
            return true;
        }
        return false;
    }

    @Override
    public String getFeeCurrency() {
        return "BCH";
    }

    @Override
    public boolean validateAddress(String address) {
//        if (address == null || address.isEmpty()) {
//            return false;
//        }
//
//        if (address.length() < 25) {
//            return false;
//        }
//
//        if (address.length() > 35) {
//            return false;
//        }
//
//        if (!address.startsWith("1") && !address.startsWith("2") && !address.startsWith("3") && !address.startsWith("n") && !address.startsWith("m")) {
//            return false;
//        }
//
//        byte[] decAddress = Base58.decodeBase58(address);
//
//        if (decAddress == null || decAddress.length == 0) {
//            return false;
//        }
//
//        byte[] rip = new byte[21];
//        for (int i = 0; i < 21; ++i) {
//            rip[i] = decAddress[i];
//        }
//
//        byte[] kcv = CryptoUtil.doubleSha256(rip);
//
//        for (int i = 0; i < 4; ++i) {
//            if (kcv[i] != decAddress[21 + i])
//                return false;
//        }
//
//        if (ctx.getBlockchain() != Blockchain.BitcoinTestNet && ctx.getBlockchain() != Blockchain.Bitcoin) {
//            return false;
//        }
//
//        if (ctx.getBlockchain() == Blockchain.BitcoinTestNet && (address.startsWith("1") || address.startsWith("3"))) {
//            return false;
//        }
//
//        return true;

        return CashAddr.isValidCashAddress(address);
    }

    @Override
    public boolean isNeedCheckNode() {
        return true;
    }

    @Override
    public Uri getWalletExplorerUri() {
        return Uri.parse("https://bch.btc.com/" + ctx.getCoinData().getWallet());
    }

    @Override
    public Uri getShareWalletUri() {
        return Uri.parse(ctx.getCoinData().getWallet());
    }

    @Override
    public InputFilter[] getAmountInputFilters() {
        return new InputFilter[]{new DecimalDigitsInputFilter(getDecimals())};
    }

    @Override
    public boolean checkNewTransactionAmount(Amount amount) {
        if (coinData == null) return false;
        if (amount.compareTo(convertToAmount(coinData.getBalanceInInternalUnits())) > 0) {
            return false;
        }
        return true;
    }

    @Override
    public boolean checkNewTransactionAmountAndFee(Amount amountValue, Amount feeValue, Boolean isIncludeFee) {
        InternalAmount fee;
        InternalAmount amount;

        try {
            checkBlockchainDataExists();
            amount = convertToInternalAmount(amountValue);
            fee = convertToInternalAmount(feeValue);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

        if (fee == null || amount == null)
            return false;

        if (fee.isZero() || amount.isZero())
            return false;

        if (isIncludeFee && (amount.compareTo(coinData.getBalanceInInternalUnits()) > 0 || amount.compareTo(fee) < 0))
            return false;

        if (!isIncludeFee && amount.add(fee).compareTo(coinData.getBalanceInInternalUnits()) > 0)
            return false;

        return true;
    }

    @Override
    public boolean validateBalance(BalanceValidator balanceValidator) {
        if (((ctx.getCard().getOfflineBalance() == null) && !ctx.getCoinData().isBalanceReceived()) || (!ctx.getCoinData().isBalanceReceived() && (ctx.getCard().getRemainingSignatures() != ctx.getCard().getMaxSignatures()))) {
            balanceValidator.setScore(0);
            balanceValidator.setFirstLine(R.string.balance_validator_first_line_unknown_balance);
            balanceValidator.setSecondLine(R.string.balance_validator_second_line_unverified_balance);
            return false;
        }

        // Workaround before new back-end
//        if (card.getRemainingSignatures() == card.getMaxSignatures()) {
//            firstLine = "Verified balance";
//            secondLine = "Balance confirmed in blockchain. ";
//            secondLine += "Verified note identity. ";
//            return;
//        }

        if (coinData.getBalanceUnconfirmed() != 0) {
            balanceValidator.setScore(0);
            balanceValidator.setFirstLine(R.string.balance_validator_first_line_transaction_in_progress);
            balanceValidator.setSecondLine(R.string.balance_validator_second_line_wait_for_confirmation);
            return false;
        }

        if (coinData.isBalanceReceived() && coinData.isBalanceEqual()) {
            balanceValidator.setScore(100);
            balanceValidator.setFirstLine(R.string.balance_validator_first_line_verified_balance);
            balanceValidator.setSecondLine(R.string.balance_validator_second_line_confirmed_in_blockchain);
            if (coinData.getBalanceInInternalUnits().isZero()) {
                balanceValidator.setFirstLine(R.string.balance_validator_first_line_empty_wallet);
                balanceValidator.setSecondLine(R.string.empty_string);
            }
        }

        // rule 4 TODO: need to check SignedHashed against number of outputs in blockchain
//        if((card.getRemainingSignatures() != card.getMaxSignatures()) && card.getBalance() != 0)
//        {
//            score = 80;
//            firstLine = "Unguaranteed balance";
//            secondLine = "Potential unsent transaction. Redeem immediately if accept. ";
//            return;
//        }

        if ((ctx.getCard().getOfflineBalance() != null) && !coinData.isBalanceReceived() && (ctx.getCard().getRemainingSignatures() == ctx.getCard().getMaxSignatures()) && coinData.getBalanceInInternalUnits().notZero()) {
            balanceValidator.setScore(80);
            balanceValidator.setFirstLine(R.string.balance_validator_first_line_verified_offline);
            balanceValidator.setSecondLine(R.string.balance_validator_second_line_internet_to_get_balance);
        }

//            if(card.getFailedBalanceRequestCounter()!=0) {
//                score -= 5 * card.getFailedBalanceRequestCounter();
//                secondLine += "Not all nodes have returned balance. Swipe down or tap again. ";
//                if(score <= 0)
//                    return;
//            }

        //
//            if(card.isBalanceReceived() && !card.isBalanceEqual()) {
//                score = 0;
//                firstLine = "Disputed balance";
//                secondLine += " Cannot obtain trusted balance at the moment. Try to tap and check this banknote later.";
//                return;
//            }

        return true;
    }

    @Override
    public Amount getBalance() {
        return convertToAmount(coinData.getBalanceInInternalUnits());
    }

    @Override
    public String evaluateFeeEquivalent(String fee) {
        if (!coinData.getAmountEquivalentDescriptionAvailable()) return "";
        try {
            Amount feeAmount = new Amount(fee, getFeeCurrency());
            return feeAmount.toEquivalentString(coinData.getRate());
        } catch (Exception e) {
            return "";
        }
    }

    @Override
    public String getBalanceEquivalent() {
        if (coinData == null || !coinData.getAmountEquivalentDescriptionAvailable()) return "";
        Amount balance = getBalance();
        if (balance == null) return "";
        return balance.toEquivalentString(coinData.getRate());
    }

    @Override
    public String calculateAddress(byte[] pubKey) throws NoSuchProviderException, NoSuchAlgorithmException {

        // CashAddr format
        byte hash1[] = Util.calculateSHA256(pubKey);
        byte hash2[] = Util.calculateRIPEMD160(hash1);
        return CashAddr.toCashAddress(BitcoinCashAddressType.P2PKH, hash2);

    }

    public String calculateLegacyAddress(byte[] pkUncompressed) throws NoSuchProviderException, NoSuchAlgorithmException {

        // Legacy format (BTC)
        byte netSelectionByte = (byte) 0x00;

        byte hash1[] = Util.calculateSHA256(pkUncompressed);
        byte hash2[] = Util.calculateRIPEMD160(hash1);

        ByteBuffer BB = ByteBuffer.allocate(hash2.length + 1);

        BB.put(netSelectionByte);
        BB.put(hash2);

        byte hash3[] = Util.calculateSHA256(BB.array());
        byte hash4[] = Util.calculateSHA256(hash3);

        BB = ByteBuffer.allocate(hash2.length + 5);
        BB.put(netSelectionByte);
        BB.put(hash2);
        BB.put(hash4[0]);
        BB.put(hash4[1]);
        BB.put(hash4[2]);
        BB.put(hash4[3]);

        return org.bitcoinj.core.Base58.encode(BB.array());
    }

    public String convertToLegacyAddress(String cashAddr) throws NoSuchProviderException, NoSuchAlgorithmException {

        BitcoinCashAddressDecodedParts bcadp = CashAddr.decodeCashAddress(cashAddr);
        byte netSelectionByte = (byte) 0x00;
        byte hash2[] = bcadp.hash;

        ByteBuffer BB = ByteBuffer.allocate(hash2.length + 1);

        BB.put(netSelectionByte);
        BB.put(hash2);

        byte hash3[] = Util.calculateSHA256(BB.array());
        byte hash4[] = Util.calculateSHA256(hash3);

        BB = ByteBuffer.allocate(hash2.length + 5);
        BB.put(netSelectionByte);
        BB.put(hash2);
        BB.put(hash4[0]);
        BB.put(hash4[1]);
        BB.put(hash4[2]);
        BB.put(hash4[3]);

        return org.bitcoinj.core.Base58.encode(BB.array());
    }

    @Override
    public Amount convertToAmount(InternalAmount internalAmount) {
        BigDecimal d = internalAmount.divide(new BigDecimal("100000000"));
        return new Amount(d, getBalanceCurrency());
    }

    @Override
    public Amount convertToAmount(String strAmount, String currency) {
        return new Amount(strAmount, currency);
    }

    @Override
    public InternalAmount convertToInternalAmount(Amount amount) throws Exception {
        BigDecimal d = amount.multiply(new BigDecimal("100000000"));
        return new InternalAmount(d, getBalanceCurrency());
    }

    @Override
    public InternalAmount convertToInternalAmount(byte[] bytes) {
        if (bytes == null) return null;
        byte[] reversed = new byte[bytes.length];
        for (int i = 0; i < bytes.length; i++) reversed[i] = bytes[bytes.length - i - 1];
        return new InternalAmount(Util.byteArrayToLong(reversed), "Satoshi");
    }

    @Override
    public byte[] convertToByteArray(InternalAmount internalAmount) throws Exception {
        byte[] bytes = Util.longToByteArray(internalAmount.longValueExact());
        byte[] reversed = new byte[bytes.length];
        for (int i = 0; i < bytes.length; i++) reversed[i] = bytes[bytes.length - i - 1];
        return reversed;
    }

    @Override
    public CoinData createCoinData() {
        return new BtcData();
    }

    @Override
    public String getUnspentInputsDescription() {
        return coinData.getUnspentInputsDescription();
    }

    @Override
    public void defineWallet() throws CardProtocol.TangemException {
        try {
            String wallet = calculateAddress(ctx.getCard().getWalletPublicKeyRar());
            ctx.getCoinData().setWallet(wallet);
        }
        catch (Exception e)
        {
            ctx.getCoinData().setWallet("ERROR");
            throw new CardProtocol.TangemException("Can't define wallet address");
        }

    }

//    @Override
//    public String getAmountDescription(TangemCard mCard, String amount) throws Exception {
//        return mCard.getAmountDescription(Double.parseDouble(amount));
//    }


    @Override
    public SignTask.TransactionToSign constructTransaction(Amount amountValue, Amount feeValue, boolean IncFee, String targetAddress) throws Exception {
        checkBlockchainDataExists();

        String srcLegacyAddress = convertToLegacyAddress(ctx.getCoinData().getWallet());
        String destLegacyAddress = convertToLegacyAddress(targetAddress);
        byte[] pbKey = ctx.getCard().getWalletPublicKeyRar(); //ALWAYS USING COMPRESS KEY

        // Build script for our address
        List<BtcData.UnspentTransaction> rawTxList = coinData.getUnspentTransactions();
        byte[] outputScriptWeAreAbleToSpend = Transaction.Script.buildOutput(srcLegacyAddress).bytes;

        // Collect unspent
        ArrayList<UnspentOutputInfo> unspentOutputs = BCHUtils.getOutputs(rawTxList, outputScriptWeAreAbleToSpend);

        long fullAmount = 0;
        for (int i = 0; i < unspentOutputs.size(); ++i) {
            fullAmount += unspentOutputs.get(i).value;
        }


        long fees = convertToInternalAmount(feeValue).longValueExact();
        long amount = convertToInternalAmount(amountValue).longValueExact();
        long change = fullAmount - amount;
        if (IncFee) {
            amount = amount - fees;
        } else {
            change = change - fees;
        }

        if (amount + fees > fullAmount) {
            throw new CardProtocol.TangemException_WrongAmount(String.format("Balance (%d) < change (%d) + amount (%d)", fullAmount, change, amount));
        }

        final long amountFinal = amount;
        final long changeFinal = change;

        byte[][] txForSign = new byte[unspentOutputs.size()][];
        byte[][] bodyHash = new byte[unspentOutputs.size()][];
        byte[][] bodyDoubleHash = new byte[unspentOutputs.size()][];

        for (int i = 0; i < unspentOutputs.size(); ++i) {
            txForSign[i] = BCHUtils.buildTXForSign(srcLegacyAddress, destLegacyAddress, srcLegacyAddress, unspentOutputs, i, amount, change);
            bodyHash[i] = Util.calculateSHA256(txForSign[i]);
            bodyDoubleHash[i] = Util.calculateSHA256(bodyHash[i]);
        }

        return new SignTask.TransactionToSign() {

            @Override
            public boolean isSigningMethodSupported(TangemCard.SigningMethod signingMethod) {
                return signingMethod == TangemCard.SigningMethod.Sign_Hash || signingMethod == TangemCard.SigningMethod.Sign_Raw;
            }

            @Override
            public byte[][] getHashesToSign() throws Exception {
                byte[][] dataForSign = new byte[unspentOutputs.size()][];
                if (txForSign.length > 10) throw new Exception("To much hashes in one transaction!");
                for (int i = 0; i < unspentOutputs.size(); ++i) {
                    dataForSign[i] = bodyDoubleHash[i];
                }
                return dataForSign;
            }

            @Override
            public byte[] getRawDataToSign() throws Exception {
                ByteArrayOutputStream bs = new ByteArrayOutputStream();
                for (int i = 0; i < txForSign.length; i++) {
                    if (i != 0 && txForSign[0].length != txForSign[i].length)
                        throw new Exception("Hashes length must be identical!");
                    bs.write(txForSign[i]);
                }

                return bs.toByteArray();
            }

            @Override
            public String getHashAlgToSign() {
                return "sha-256x2";
            }

            @Override
            public byte[] getIssuerTransactionSignature(byte[] dataToSignByIssuer) throws Exception {
                throw new Exception("Transaction validation by issuer not supported in this version!");
            }

            @Override
            public byte[] onSignCompleted(byte[] signFromCard) throws Exception {
                for (int i = 0; i < unspentOutputs.size(); ++i) {
                    BigInteger r = new BigInteger(1, Arrays.copyOfRange(signFromCard, i * 64, 32 + i * 64));
                    BigInteger s = new BigInteger(1, Arrays.copyOfRange(signFromCard, 32 + i * 64, 64 + i * 64));
                    s = CryptoUtil.toCanonicalised(s);

                    unspentOutputs.get(i).scriptForBuild = DerEncodingUtil.packSignDerBitcoinCash(r, s, pbKey);
                }

                byte[] txForSend = BCHUtils.buildTXForSend(destLegacyAddress, srcLegacyAddress, unspentOutputs, amountFinal, changeFinal);

                notifyOnNeedSendTransaction(txForSend);
                return txForSend;
            }
        };
    }

    @Override
    public void requestBalanceAndUnspentTransactions(BlockchainRequestsCallbacks blockchainRequestsCallbacks) throws Exception {
        final ServerApiElectrum serverApiElectrum = new ServerApiElectrum();

        ServerApiElectrum.ResponseListener electrumBodyListener = new ServerApiElectrum.ResponseListener() {
            @Override
            public void onSuccess(ElectrumRequest electrumRequest) {
                if (electrumRequest.isMethod(ElectrumRequest.METHOD_GetBalance)) {
                    try {
                        Long confBalance = electrumRequest.getResult().getLong("confirmed");
                        Long unconfirmedBalance = electrumRequest.getResult().getLong("unconfirmed");
                        coinData.setBalanceReceived(true);
                        coinData.setBalanceConfirmed(confBalance);
                        coinData.setBalanceUnconfirmed(unconfirmedBalance);
                        coinData.setValidationNodeDescription(serverApiElectrum.getValidationNodeDescription());
                    } catch (JSONException e) {
                        e.printStackTrace();
                        Log.e(TAG, "FAIL METHOD_GetBalance JSONException");
                    } catch (Exception e) {
                        e.printStackTrace();
                        Log.e(TAG, "FAIL METHOD_GetBalance Exception");
                    }
                }

                if (electrumRequest.isMethod(ElectrumRequest.METHOD_ListUnspent)) {
                    try {
                        String walletAddress = electrumRequest.getParams().getString(0);
                        JSONArray jsUnspentArray = electrumRequest.getResultArray();
                        try {
                            coinData.getUnspentTransactions().clear();
                            for (int i = 0; i < jsUnspentArray.length(); i++) {
                                JSONObject jsUnspent = jsUnspentArray.getJSONObject(i);
                                BtcData.UnspentTransaction trUnspent = new BtcData.UnspentTransaction();
                                trUnspent.txID = jsUnspent.getString("tx_hash");
                                trUnspent.amount = jsUnspent.getLong("value");
                                trUnspent.outputN = jsUnspent.getInt("height");
                                coinData.getUnspentTransactions().add(trUnspent);
                            }
                        } catch (JSONException e) {
                            e.printStackTrace();
                            Log.e(TAG, "FAIL METHOD_ListUnspent JSONException");
                        }

                        for (int i = 0; i < jsUnspentArray.length(); i++) {
                            JSONObject jsUnspent = jsUnspentArray.getJSONObject(i);
                            Integer height = jsUnspent.getInt("height");
                            String hash = jsUnspent.getString("tx_hash");
                            if (height != -1) {
                                if (blockchainRequestsCallbacks.allowAdvance()) {
                                    serverApiElectrum.requestData(ctx, ElectrumRequest.getTransaction(walletAddress, hash));
                                } else {
                                    ctx.setError("Terminated by user");
                                }
                            }
                        }
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }

                if (electrumRequest.isMethod(ElectrumRequest.METHOD_GetTransaction)) {
                    try {
                        String txHash = electrumRequest.txHash;
                        String raw = electrumRequest.getResultString();
                        for (BtcData.UnspentTransaction tx : coinData.getUnspentTransactions()) {
                            if (tx.txID.equals(txHash))
                                tx.script = raw;
                        }
                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }

                if (serverApiElectrum.isRequestsSequenceCompleted()) {
                    blockchainRequestsCallbacks.onComplete(!ctx.hasError());
                }else{
                    blockchainRequestsCallbacks.onProgress();
                }
            }

            @Override
            public void onFail(ElectrumRequest electrumRequest) {
                Log.i(TAG, "onFail: "+electrumRequest.getMethod()+" "+electrumRequest.getError());
                ctx.setError(electrumRequest.getError());
                if (serverApiElectrum.isRequestsSequenceCompleted()) {
                    blockchainRequestsCallbacks.onComplete(false);//serverApiElectrum.isErrorOccurred(), serverApiElectrum.getError());
                }else{
                    blockchainRequestsCallbacks.onProgress();
                }
            }
        };

        serverApiElectrum.setResponseListener(electrumBodyListener);

        serverApiElectrum.requestData(ctx, ElectrumRequest.checkBalance(convertToLegacyAddress(coinData.getWallet())));
        serverApiElectrum.requestData(ctx, ElectrumRequest.listUnspent(convertToLegacyAddress(coinData.getWallet())));
    }

    private Integer calculateEstimatedTransactionSize(String outputAddress, String outAmount) {
        try {
            SignTask.TransactionToSign ps= constructTransaction(new Amount(outAmount, getBalanceCurrency()),new Amount("0.00",getFeeCurrency()), true, outputAddress );
            OnNeedSendTransaction onNeedSendTransactionBackup = onNeedSendTransaction;
            onNeedSendTransaction =(tx)->{}; // empty function to bypass exception

            byte[][] hashesToSign=ps.getHashesToSign();
            byte[] signFromCard = new byte[64 * hashesToSign.length];
            Arrays.fill(signFromCard, (byte) 0x01);
            byte[] txForSend=ps.onSignCompleted(signFromCard);
            onNeedSendTransaction = onNeedSendTransactionBackup;
            Log.e(TAG,"txForSend.length="+String.valueOf(txForSend.length));
            return txForSend.length +1;
        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, "Can't calculate transaction size -> use default!");
            return 256;
        }
    }

    private final static BigDecimal relayFee = new BigDecimal(0.00001);

    @Override
    public void requestFee(BlockchainRequestsCallbacks blockchainRequestsCallbacks, String targetAddress, Amount amount) throws Exception {
        final int calcSize = calculateEstimatedTransactionSize(targetAddress, amount.toValueString());
        Log.e(TAG, String.format("Estimated tx size %d", calcSize));
        coinData.minFee=null;
        coinData.maxFee=null;
        coinData.normalFee=null;

        final ServerApiElectrum serverApiElectrum = new ServerApiElectrum();

        final ServerApiElectrum.ResponseListener electrumListener  = new ServerApiElectrum.ResponseListener() {
            @Override
            public void onSuccess(ElectrumRequest electrumRequest) {
                BigDecimal fee;
                if (electrumRequest.isMethod(ElectrumRequest.METHOD_GetFee)) {
                    try {
                        fee = new BigDecimal(electrumRequest.getResultString()); //fee per KB

                        if (fee.equals(BigDecimal.ZERO)) {
                            serverApiElectrum.requestData(ctx, ElectrumRequest.getFee());
                        }

//                        if (calcSize != 0) {
                            fee = fee.multiply(new BigDecimal(calcSize)).divide(new BigDecimal(1024)); // (per KB -> per byte)*size
//                        } else {
//                            serverApiElectrum.requestData(ctx, ElectrumRequest.getFee());
//                        }

                        //compare fee to usual relay fee
                        if (fee.compareTo(relayFee) < 0) {
                            fee = relayFee;
                        }
                        fee = fee.setScale(8, RoundingMode.DOWN);

                        CoinEngine.Amount feeAmount = new CoinEngine.Amount(fee,  ctx.getBlockchain().getCurrency());
                        coinData.minFee = feeAmount;
                        coinData.normalFee = feeAmount;
                        coinData.maxFee = feeAmount;
//                        if (coinData.minFee != null && coinData.normalFee != null && coinData.maxFee != null) {
                            blockchainRequestsCallbacks.onComplete(true);
//                        } else {
//                            blockchainRequestsCallbacks.onProgress();
//                        }

                    } catch (JSONException e) {
                        e.printStackTrace();
                    }
                }
            }

            @Override
            public void onFail(ElectrumRequest electrumRequest) {
                ctx.setError(electrumRequest.getError());
                blockchainRequestsCallbacks.onComplete(false);
            }
        };
        serverApiElectrum.setResponseListener(electrumListener);

        serverApiElectrum.requestData(ctx, ElectrumRequest.getFee());
    }

    @Override
    public void requestSendTransaction(BlockchainRequestsCallbacks blockchainRequestsCallbacks, byte[] txForSend) throws Exception {
        final ServerApiElectrum serverApiElectrum = new ServerApiElectrum();
        final String txStr = BTCUtils.toHex(txForSend);

        ServerApiElectrum.ResponseListener electrumBodyListener = new ServerApiElectrum.ResponseListener() {
            @Override
            public void onSuccess(ElectrumRequest electrumRequest) {
                if (electrumRequest.isMethod(ElectrumRequest.METHOD_SendTransaction)) {
                    try {
                        String resultString = electrumRequest.getResultString();
                        if (resultString == null || resultString.isEmpty()) {
                            ctx.setError("Rejected by node: " + electrumRequest.getError());
                            blockchainRequestsCallbacks.onComplete(false);
                        }else {
                            ctx.setError(null);
                            blockchainRequestsCallbacks.onComplete(true);
                        }
                    } catch (Exception e) {
                        if (e.getMessage() != null) {
                            ctx.setError(e.getMessage());
                            blockchainRequestsCallbacks.onComplete(false);
                        } else {
                            ctx.setError(e.getClass().getName());
                            blockchainRequestsCallbacks.onComplete(false);
                        }
                    }
                }
            }

            @Override
            public void onFail(ElectrumRequest electrumRequest) {
                ctx.setError(electrumRequest.getError());
                blockchainRequestsCallbacks.onComplete(false);
            }
        };
        serverApiElectrum.setResponseListener(electrumBodyListener);


        serverApiElectrum.requestData(ctx, ElectrumRequest.broadcast(ctx.getCoinData().getWallet(), txStr));

    }

    @Override
    public boolean allowSelectFeeLevel() {
        return false;
    }
}