import * as CONSTANTS from './constants';
import * as P from './params';
import * as Device from './trezor/device';
import * as Mgmnt from './trezor/management';
import * as Protobuf from './trezor/protobuf';
import * as Account from './account';

import * as Bitcoin from './networks/bitcoin';
import * as Binance from './networks/binance';
import * as Cardano from './networks/cardano';
import * as CoinInfo from './networks/coinInfo';
import * as EOS from './networks/eos';
import * as Ethereum from './networks/ethereum';
import * as Lisk from './networks/lisk';
import * as NEM from './networks/nem';
import * as Ripple from './networks/ripple';
import * as Stellar from './networks/stellar';
import * as Tezos from './networks/tezos';
import * as Conflux from './networks/conflux';
import * as Starcoin from './networks/starcoin';
import * as Solana from './networks/solana';
import * as Misc from './misc';

import * as Events from './events';
import * as Blockchain from './backend/blockchain';

export namespace OneKeyConnect {
    /**
     * Set OneKeyConnect manifest.
     */
    function manifest(params: P.Manifest): void;

    /**
     * Initializes OneKeyConnect.
     * `manifest` is required
     */
    function init(settings: { manifest: P.Manifest } & Partial<P.ConnectSettings>): Promise<void>;

    /**
     * Retrieves the settings that OneKeyConnect was initialized with.
     */
    function getSettings(): P.Response<P.ConnectSettings>;

    function dispose(): void;

    function cancel(params?: string): void;

    function renderWebUSBButton(): void;

    function disableWebUSB(): void;

    /**
     * Event listeners
     */
    function on(type: typeof CONSTANTS.DEVICE_EVENT, cb: (event: Device.DeviceEvent & { event: typeof CONSTANTS.DEVICE_EVENT }) => void): void;
    function on(type: typeof CONSTANTS.TRANSPORT_EVENT, cb: (event: Events.TransportEvent & { event: typeof CONSTANTS.TRANSPORT_EVENT }) => void): void;
    function on(type: typeof CONSTANTS.UI_EVENT, cb: (event: Events.UiEvent & { event: typeof CONSTANTS.UI_EVENT }) => void): void;
    function on(type: typeof CONSTANTS.BLOCKCHAIN_EVENT, cb: (event: Blockchain.BlockchainEvent & { event: typeof CONSTANTS.BLOCKCHAIN_EVENT }) => void): void;
    function on(type: Events.MessageWithoutPayload['type'], cb: () => void): void;
    function on(type: Events.DeviceMessage['type'], cb: (event: Events.DeviceMessage['payload']) => void): void;
    function on(type: Events.ButtonRequestMessage['type'], cb: (event: Events.ButtonRequestMessage['payload']) => void): void;
    function on(type: Events.AddressValidationMessage['type'], cb: (event: Events.AddressValidationMessage['payload']) => void): void;
    function on(type: Events.RequestPermission['type'], cb: (event: Events.RequestPermission['payload']) => void): void;
    function on(type: Events.RequestConfirmation['type'], cb: (event: Events.RequestConfirmation['payload']) => void): void;
    function on(type: Events.UnexpectedDeviceMode['type'], cb: (event: Events.UnexpectedDeviceMode['payload']) => void): void;
    function on(type: Events.FirmwareException['type'], cb: (event: Events.FirmwareException['payload']) => void): void;
    function on<R>(type: typeof CONSTANTS.UI.BUNDLE_PROGRESS, cb: (event: Events.BundleProgress<R>['payload']) => void): void;
    function on(type: Events.FirmwareProgress['type'], cb: (event: Events.FirmwareProgress['payload']) => void): void;
    function on(type: Events.CustomMessageRequest['type'], cb: (event: Events.CustomMessageRequest['payload']) => void): void;
    function off(type: string, cb: any): void;
    function removeAllListeners(): void;

    function uiResponse(response: Events.UiResponse): void;

    /**
     * Backend operations
     */
    function blockchainEstimateFee(
        params: P.CommonParams & Blockchain.BlockchainEstimateFee,
    ): P.Response<Blockchain.BlockchainEstimatedFee>;
    function blockchainGetAccountBalanceHistory(
        params: Blockchain.BlockchainGetAccountBalanceHistory
    ): P.Response<Blockchain.BlockchainAccountBalanceHistory[]>;
    function blockchainGetCurrentFiatRates(
        params: Blockchain.BlockchainGetCurrentFiatRates
    ): P.Response<Blockchain.BlockchainTimestampedFiatRates>;
    function blockchainGetFiatRatesForTimestamps(
        params: Blockchain.BlockchainGetFiatRatesForTimestamps
    ): P.Response<Blockchain.BlockchainFiatRatesForTimestamps>;
    function blockchainGetTransactions(
        params: P.CommonParams & Blockchain.BlockchainGetTransactions,
    ): P.Response<Blockchain.BlockchainTransactions>;
    function blockchainSetCustomBackend(
        params: P.CommonParams & Blockchain.BlockchainSetCustomBackend,
    ): P.Response<boolean>;
    function blockchainSubscribe(
        params: P.CommonParams & Blockchain.BlockchainSubscribe,
    ): P.Response<Blockchain.BlockchainSubscribed>;
    function blockchainSubscribeFiatRates(
        params: Blockchain.BlockchainSubscribeFiatRates
    ): P.Response<Blockchain.BlockchainSubscribed>;
    function blockchainUnsubscribe(
        params: P.CommonParams & Blockchain.BlockchainSubscribe,
    ): P.Response<Blockchain.BlockchainSubscribed>;
    function blockchainUnsubscribeFiatRates(
        params: Blockchain.BlockchainSubscribeFiatRates
    ): P.Response<Blockchain.BlockchainSubscribed>;
    function blockchainDisconnect(
        params: P.CommonParams & Blockchain.BlockchainDisconnect,
    ): P.Response<Blockchain.BlockchainDisconnected>;


    /**
     * Bitcoin and Bitcoin-like
     * Display requested address derived by given BIP32 path on device and
     * returns it to caller. User is asked to confirm the export on Trezor.
     */
    function getAddress(params: P.CommonParams & Bitcoin.GetAddress): P.Response<Bitcoin.Address>;
    function getAddress(params: P.CommonParams & P.Bundle<Bitcoin.GetAddress>): P.BundledResponse<Bitcoin.Address>;

    /**
     * Bitcoin and Bitcoin-like
     * Retrieves BIP32 extended public derived by given BIP32 path.
     * User is presented with a description of the requested key and asked to
     * confirm the export.
     */
    function getPublicKey(params: P.CommonParams & Bitcoin.GetPublicKey): P.Response<Bitcoin.HDNodeResponse>;
    function getPublicKey(
        params: P.CommonParams & P.Bundle<Bitcoin.GetPublicKey>,
    ): P.BundledResponse<Bitcoin.HDNodeResponse>;

    /**
     * Bitcoin and Bitcoin-like
     * Asks device to sign given inputs and outputs of pre-composed transaction.
     * User is asked to confirm all transaction details on Trezor.
     */
    function signTransaction(params: P.CommonParams & Bitcoin.SignTransaction): P.Response<Bitcoin.SignedTransaction>;

    /**
     * Bitcoin, Bitcoin-like, Ethereum-like, Ripple
     * Broadcasts the transaction to the selected network.
     */
    function pushTransaction(params: P.CommonParams & Bitcoin.PushTransaction): P.Response<Bitcoin.PushedTransaction>;

    /**
     * Bitcoin and Bitcoin-like
     * Requests a payment from the users wallet to a set of given outputs.
     * Internally a BIP-0044 account discovery is performed and user is presented
     * with a list of accounts. After account selection user is presented with
     * list of fee selection. After selecting a fee transaction is signed and
     * returned in hexadecimal format. Change output is added automatically, if
     * needed.
     */
    function composeTransaction(params: P.CommonParams & Account.ComposeParams): P.Response<Bitcoin.SignedTransaction>;
    function composeTransaction(
        params: P.CommonParams & Account.PrecomposeParams,
    ): P.Response<Account.PrecomposedTransaction[]>;

    /**
     * Bitcoin, Bitcoin-like, Ethereum-like, Ripple
     * Gets an info of specified account.
     */
    function getAccountInfo(params: P.CommonParams & Account.GetAccountInfo): P.Response<Account.AccountInfo>;
    function getAccountInfo(
        params: P.CommonParams & P.Bundle<Account.GetAccountInfo>,
    ): P.BundledResponse<Account.AccountInfo>;

    /**
     * Bitcoin and Bitcoin-like
     * Asks device to sign a message using the private key derived by given BIP32
     * path.
     */
    function signMessage(params: P.CommonParams & Bitcoin.SignMessage): P.Response<Protobuf.MessageSignature>;

    /**
     * Bitcoin and Bitcoin-like
     * Asks device to verify a message using the signer address and signature.
     */
    function verifyMessage(params: P.CommonParams & Bitcoin.VerifyMessage): P.Response<P.DefaultMessage>;

    // Binance
    function binanceGetAddress(params: P.CommonParams & Binance.BinanceGetAddress): P.Response<Binance.BinanceAddress>;
    function binanceGetAddress(
        params: P.CommonParams & P.Bundle<Binance.BinanceGetAddress>,
    ): P.BundledResponse<Binance.BinanceAddress>;
    function binanceGetPublicKey(
        params: P.CommonParams & Binance.BinanceGetPublicKey,
    ): P.Response<Binance.BinancePublicKey>;
    function binanceGetPublicKey(
        params: P.CommonParams & P.Bundle<Binance.BinanceGetPublicKey>,
    ): P.BundledResponse<Binance.BinancePublicKey>;
    function binanceSignTransaction(
        params: P.CommonParams & Binance.BinanceSignTransaction,
    ): P.Response<Protobuf.BinanceSignedTx>;

    // Cardano (ADA)
    function cardanoGetAddress(params: P.CommonParams & Cardano.CardanoGetAddress): P.Response<Cardano.CardanoAddress>;
    function cardanoGetAddress(
        params: P.CommonParams & P.Bundle<Cardano.CardanoGetAddress>,
    ): P.BundledResponse<Cardano.CardanoAddress>;
    function cardanoGetPublicKey(
        params: P.CommonParams & Cardano.CardanoGetPublicKey,
    ): P.Response<Cardano.CardanoPublicKey>;
    function cardanoGetPublicKey(
        params: P.CommonParams & P.Bundle<Cardano.CardanoGetPublicKey>,
    ): P.BundledResponse<Cardano.CardanoPublicKey>;
    function cardanoSignTransaction(
        params: P.CommonParams & Cardano.CardanoSignTransaction,
    ): P.Response<Cardano.CardanoSignedTx>;

    // EOS
    function eosGetPublicKey(params: P.CommonParams & EOS.EosGetPublicKey): P.Response<EOS.EosPublicKey>;
    function eosGetPublicKey(
        params: P.CommonParams & P.Bundle<EOS.EosGetPublicKey>,
    ): P.BundledResponse<EOS.EosPublicKey>;
    function eosSignTransaction(params: P.CommonParams & EOS.EosSignTransaction): P.Response<Protobuf.EosSignedTx>;

    // Ethereum and Ethereum-like
    function ethereumGetAddress(
        params: P.CommonParams & Ethereum.EthereumGetAddress,
    ): P.Response<Ethereum.EthereumAddress>;
    function ethereumGetAddress(
        params: P.CommonParams & P.Bundle<Ethereum.EthereumGetAddress>,
    ): P.BundledResponse<Ethereum.EthereumAddress>;
    function ethereumGetPublicKey(
        params: P.CommonParams & Ethereum.EthereumGetPublicKey,
    ): P.Response<Bitcoin.HDNodeResponse>;
    function ethereumGetPublicKey(
        params: P.CommonParams & P.Bundle<Ethereum.EthereumGetPublicKey>,
    ): P.BundledResponse<Bitcoin.HDNodeResponse>;
    function ethereumSignTransaction(
        params: P.CommonParams & Ethereum.EthereumSignTransaction,
    ): P.Response<Ethereum.EthereumSignedTx>;
    function ethereumSignTransaction(
        params: P.CommonParams & P.Bundle<Ethereum.EthereumSignTransaction>,
    ): P.BundledResponse<Ethereum.EthereumSignedTx>;
    function ethereumSignMessage(
        params: P.CommonParams & Ethereum.EthereumSignMessage,
    ): P.Response<Protobuf.MessageSignature>;
    function ethereumSignMessageEIP712(params: P.CommonParams & Ethereum.EthereumSignMessageEIP712): P.Response<Protobuf.MessageSignature>;
    function ethereumVerifyMessage(
        params: P.CommonParams & Ethereum.EthereumVerifyMessage,
    ): P.Response<P.DefaultMessage>;
    function ethereumSignTypedData<T extends Ethereum.EthereumSignTypedDataTypes>(
        params: P.CommonParams & Ethereum.EthereumSignTypedData<T>,
    ): P.Response<Protobuf.EthereumTypedDataSignature>;

    // Lisk
    function liskGetAddress(params: P.CommonParams & Lisk.LiskGetAddress): P.Response<Lisk.LiskAddress>;
    function liskGetAddress(
        params: P.CommonParams & P.Bundle<Lisk.LiskGetAddress>,
    ): P.BundledResponse<Lisk.LiskAddress>;
    function liskGetPublicKey(params: P.CommonParams & Lisk.LiskGetPublicKey): P.Response<Lisk.LiskPublicKey>;
    function liskGetPublicKey(
        params: P.CommonParams & P.Bundle<Lisk.LiskGetPublicKey>,
    ): P.BundledResponse<Lisk.LiskPublicKey>;
    function liskSignTransaction(params: P.CommonParams & Lisk.LiskSignTransaction): P.Response<Protobuf.LiskSignedTx>;
    function liskSignMessage(params: P.CommonParams & Lisk.LiskSignMessage): P.Response<Lisk.LiskMessageSignature>;
    function liskVerifyMessage(params: P.CommonParams & Lisk.LiskVerifyMessage): P.Response<P.DefaultMessage>;

    // NEM
    function nemGetAddress(params: P.CommonParams & NEM.NEMGetAddress): P.Response<NEM.NEMAddress>;
    function nemGetAddress(params: P.CommonParams & P.Bundle<NEM.NEMGetAddress>): P.BundledResponse<NEM.NEMAddress>;
    function nemSignTransaction(params: P.CommonParams & NEM.NEMSignTransaction): P.Response<Protobuf.NEMSignedTx>;

    // Ripple
    function rippleGetAddress(params: P.CommonParams & Ripple.RippleGetAddress): P.Response<Ripple.RippleAddress>;
    function rippleGetAddress(
        params: P.CommonParams & P.Bundle<Ripple.RippleGetAddress>,
    ): P.BundledResponse<Ripple.RippleAddress>;
    function rippleSignTransaction(
        params: P.CommonParams & Ripple.RippleSignTransaction,
    ): P.Response<Ripple.RippleSignedTx>;

    // Stellar
    function stellarGetAddress(params: P.CommonParams & Stellar.StellarGetAddress): P.Response<Stellar.StellarAddress>;
    function stellarGetAddress(
        params: P.CommonParams & P.Bundle<Stellar.StellarGetAddress>,
    ): P.BundledResponse<Stellar.StellarAddress>;
    function stellarSignTransaction(
        params: P.CommonParams & Stellar.StellarSignTransaction,
    ): P.Response<Stellar.StellarSignedTx>;

    // // Tezos
    function tezosGetAddress(params: P.CommonParams & Tezos.TezosGetAddress): P.Response<Tezos.TezosAddress>;
    function tezosGetAddress(
        params: P.CommonParams & P.Bundle<Tezos.TezosGetAddress>,
    ): P.BundledResponse<Tezos.TezosAddress>;
    function tezosGetPublicKey(params: P.CommonParams & Tezos.TezosGetPublicKey): P.Response<Tezos.TezosPublicKey>;
    function tezosGetPublicKey(
        params: P.CommonParams & P.Bundle<Tezos.TezosGetPublicKey>,
    ): P.BundledResponse<Tezos.TezosPublicKey>;
    function tezosSignTransaction(
        params: P.CommonParams & Tezos.TezosSignTransaction,
    ): P.Response<Protobuf.TezosSignedTx>;

    // Conflux
    function confluxGetAddress(params: P.CommonParams & Conflux.ConfluxGetAddress): P.Response<Ethereum.EthereumAddress>;
    function confluxGetAddress(params: P.CommonParams & P.Bundle<Conflux.ConfluxGetAddress>): P.BundledResponse<
    Ethereum.EthereumAddress
    >;
    function confluxGetPublicKey(params: P.CommonParams & Ethereum.EthereumGetPublicKey): P.Response<
    Bitcoin.HDNodeResponse
    >;
    function confluxGetPublicKey(
        params: P.CommonParams & P.Bundle<Ethereum.EthereumGetPublicKey>,
    ): P.BundledResponse<Bitcoin.HDNodeResponse>;
    function confluxSignTransaction(
        params: P.CommonParams & Conflux.ConfluxSignTransaction,
    ): P.Response<Ethereum.EthereumSignedTx>;
    function confluxSignTransaction(
        params: P.CommonParams & P.Bundle<Conflux.ConfluxSignTransaction>,
    ): P.BundledResponse<Ethereum.EthereumSignedTx>;
    function confluxSignMessage(
        params: P.CommonParams & Ethereum.EthereumSignMessage,
    ): P.Response<Protobuf.ConfluxMessageSignature>;
    function ConfluxSignMessageCIP23<T extends Conflux.MessageTypes>(params: P.CommonParams & Conflux.ConfluxSignMessageEIP712<T>): P.Response<Protobuf.ConfluxMessageSignature>;
    function confluxVerifyMessage(
        params: P.CommonParams & Ethereum.EthereumVerifyMessage,
    ): P.Response<P.DefaultMessage>;

    // Solana
    function solanaGetAddress(params: P.CommonParams & Solana.SolanaGetAddress): P.Response<Solana.SolanaAddress>;
    function solanaGetAddress(params: P.CommonParams & P.Bundle<Solana.SolanaGetAddress>): P.BundledResponse<Solana.SolanaAddress>;
    function solanaSignTransaction(params: P.CommonParams & Solana.SolanaSignTx): P.Response<Solana.SolanaSignedTx>;
    function solanaSignTransaction(params: P.CommonParams & P.Bundle<Solana.SolanaSignTx>): P.BundledResponse<Solana.SolanaSignedTx>;

    // Starcoin
    function starcoinGetAddress(params: P.CommonParams & Starcoin.StarcoinGetAddress): P.Response<Starcoin.StarcoinAddress>;
    function starcoinGetAddress(params: P.CommonParams & P.Bundle<Starcoin.StarcoinGetAddress>): P.BundledResponse<Starcoin.StarcoinAddress>;
    function starcoinGetPublicKey(params: P.CommonParams & Starcoin.StarcoinGetPublicKey): P.Response<Starcoin.StarcoinPublicKey>;
    function starcoinGetPublicKey(params: P.CommonParams & P.Bundle<Starcoin.StarcoinGetPublicKey>): P.BundledResponse<Starcoin.StarcoinPublicKey>;
    function starcoinSignTransaction(params: P.CommonParams & Starcoin.StarcoinSignTx): P.Response<Starcoin.StarcoinSignedTx>;
    function starcoinSignTransaction(params: P.CommonParams & P.Bundle<Starcoin.StarcoinSignTx>): P.BundledResponse<Starcoin.StarcoinSignedTx>;
    function starcoinSignMessage(params: P.CommonParams & Starcoin.StarcoinSignMessage): P.Response<Starcoin.StarcoinMessageSignature>;
    function starcoinVerifyMessage(params: P.CommonParams & Starcoin.StarcoinVerifyMessage): P.Response<P.DefaultMessage>;

    /**
     * Challenge-response authentication via Trezor.
     * To protect against replay attacks you should use a server-side generated
     * and randomized challengeHidden for every attempt. You can also provide a
     * visual challenge that will be shown on the device.
     */
    function requestLogin(
        params: P.CommonParams & (Misc.RequestLoginAsync | Misc.LoginChallenge),
    ): P.Response<Misc.Login>;

    /**
     * Asks device to encrypt value using the private key derived by given BIP32
     * path and the given key. IV is always computed automatically.
     */
    function cipherKeyValue(params: P.CommonParams & Misc.CipherKeyValue): P.Response<Misc.CipheredValue>;
    function cipherKeyValue(
        params: P.CommonParams & P.Bundle<Misc.CipherKeyValue>,
    ): P.BundledResponse<Misc.CipheredValue>;

    /**
     * Retrieves the set of features associated with the device.
     */
    function getFeatures(params?: P.CommonParams): P.Response<Device.Features>;

    /**
     * Retrieves device state associated with passphrase.
     */
    function getDeviceState(params?: P.CommonParams): P.Response<Device.DeviceStateResponse>;

    /**
     * Resets device to factory defaults and removes all private data.
     */
    function wipeDevice(params?: P.CommonParams): P.Response<P.DefaultMessage>;

    /**
     * Performs device setup and generates a new seed.
     */
    function resetDevice(params: P.CommonParams & Mgmnt.ResetDevice): P.Response<P.DefaultMessage>;

    /**
     * Applies device setup
     */
    function applySettings(params: P.CommonParams & Mgmnt.ApplySettings): P.Response<P.DefaultMessage>;

    /**
     * Increment saved flag on device
     */
    function applyFlags(params: P.CommonParams & Mgmnt.ApplyFlags): P.Response<P.DefaultMessage>;

    /**
     * Change pin
     */
    function changePin(params: P.CommonParams & Mgmnt.ChangePin): P.Response<P.DefaultMessage>;

    /**
     * Sends FirmwareErase message followed by FirmwareUpdate message
     */
    function firmwareUpdate(
        params: P.CommonParams & (Mgmnt.FirmwareUpdate | Mgmnt.FirmwareUpdateBinary),
    ): P.Response<P.DefaultMessage>;

    /**
     * Asks device to initiate seed backup procedure
     */
    function backupDevice(params?: P.CommonParams): P.Response<P.DefaultMessage>;

    /**
     * reboot to bootloader
     */
    function bixinReboot(params?: P.CommonParams): P.Response<P.DefaultMessage>;

    /**
     * Ask device to initiate recovery procedure
     */
    function recoveryDevice(params: P.CommonParams & Mgmnt.RecoveryDevice): P.Response<P.DefaultMessage>;

    /**
     * Get static coin info
     */
    function getCoinInfo(params: CoinInfo.GetCoinInfo): P.Response<CoinInfo.CoinInfo>;

    // // Developer mode
    function customMessage(params: P.CommonParams & Misc.CustomMessage): P.Response<any>;
    function debugLinkDecision(params?: P.CommonParams): P.Response<{ debugLink: true }>;
    function debugLinkGetState(params?: P.CommonParams): P.Response<{ debugLink: true }>;
}