import { ApiPromise } from "@polkadot/api";
import { AddressOrPair } from "@polkadot/api/submittable/types";
import { Signer } from "@polkadot/api/types";
import { KeyringPair } from "@polkadot/keyring/types";
import { ElectrsAPI, DefaultElectrsAPI } from "./external/electrs";
import { DefaultIssueAPI, IssueAPI } from "./parachain/issue";
import { DefaultOracleAPI, OracleAPI } from "./parachain/oracle";
import { DefaultRedeemAPI, RedeemAPI } from "./parachain/redeem";
import { DefaultRefundAPI, RefundAPI } from "./parachain/refund";
import { DefaultFeeAPI, FeeAPI } from "./parachain/fee";
import { DefaultStakedRelayerAPI, StakedRelayerAPI } from "./parachain/staked-relayer";
import { DefaultVaultsAPI, VaultsAPI } from "./parachain/vaults";
import { DefaultSystemAPI, SystemAPI } from "./parachain/system";
import { DefaultCollateralAPI, CollateralAPI } from "./parachain/collateral";
import { DefaultTreasuryAPI, TreasuryAPI } from "./parachain/treasury";
import { FaucetClient } from "./clients";
import { BTCRelayAPI, DefaultBTCRelayAPI } from "./parachain/btc-relay";
import { DefaultReplaceAPI, ReplaceAPI } from "./parachain/replace";
import { Network, networks } from "bitcoinjs-lib";

export * from "./factory";
export * from "./parachain/transaction";

export function getBitcoinNetwork(network: string = "mainnet"): Network {
    switch (network) {
    case "mainnet":
        return networks.bitcoin;
    case "testnet":
        return networks.testnet;
    default:
        return networks.regtest;
    }
}

export interface PolkaBTCAPI {
    readonly api: ApiPromise;
    readonly vaults: VaultsAPI;
    readonly issue: IssueAPI;
    readonly redeem: RedeemAPI;
    readonly refund: RefundAPI;
    readonly stakedRelayer: StakedRelayerAPI;
    readonly faucet: FaucetClient;
    readonly oracle: OracleAPI;
    readonly electrsAPI: ElectrsAPI;
    readonly btcRelay: BTCRelayAPI;
    readonly collateral: CollateralAPI;
    readonly treasury: TreasuryAPI;
    readonly system: SystemAPI;
    readonly replace: ReplaceAPI;
    readonly fee: FeeAPI;
    setAccount(account: AddressOrPair, signer?: Signer): void;
    readonly account: AddressOrPair | undefined;
}

/**
 * @category PolkaBTC Bridge
 * The type Big represents DOT or PolkaBTC denominations,
 * while the type BN represents Planck or Satoshi denominations.
 */
export class DefaultPolkaBTCAPI implements PolkaBTCAPI {
    public readonly vaults: VaultsAPI;
    public readonly issue: IssueAPI;
    public readonly redeem: RedeemAPI;
    public readonly refund: RefundAPI;
    public readonly stakedRelayer: StakedRelayerAPI;
    public readonly faucet: FaucetClient;
    public readonly oracle: OracleAPI;
    public readonly electrsAPI: ElectrsAPI;
    public readonly btcRelay: BTCRelayAPI;
    public readonly collateral: CollateralAPI;
    public readonly treasury: TreasuryAPI;
    public readonly system: SystemAPI;
    public readonly replace: ReplaceAPI;
    public readonly fee: FeeAPI;

    constructor(readonly api: ApiPromise, network: string = "mainnet", private _account?: AddressOrPair) {
        const btcNetwork = getBitcoinNetwork(network);
        this.vaults = new DefaultVaultsAPI(api, btcNetwork, _account);
        this.faucet = new FaucetClient("");
        this.oracle = new DefaultOracleAPI(api);
        this.electrsAPI = new DefaultElectrsAPI(network);
        this.stakedRelayer = new DefaultStakedRelayerAPI(api, btcNetwork, this.electrsAPI, _account);
        this.refund = new DefaultRefundAPI(api, btcNetwork, this.electrsAPI, _account);
        this.btcRelay = new DefaultBTCRelayAPI(api, this.electrsAPI);
        this.collateral = new DefaultCollateralAPI(api, _account);
        this.treasury = new DefaultTreasuryAPI(api, _account);
        this.system = new DefaultSystemAPI(api);
        this.replace = new DefaultReplaceAPI(api, btcNetwork, this.electrsAPI, _account);
        this.fee = new DefaultFeeAPI(api);
        this.issue = new DefaultIssueAPI(api, btcNetwork, this.electrsAPI, _account);
        this.redeem = new DefaultRedeemAPI(api, btcNetwork, this.electrsAPI, _account);
    }

    setAccount(account: AddressOrPair, signer?: Signer): void {
        if (!(account as KeyringPair).sign && !signer) {
            throw new Error("signer must be passed if account is not a Keypair");
        }
        if (signer) {
            this.api.setSigner(signer);
        }
        this._account = account;
        this.vaults.setAccount(account);
        this.stakedRelayer.setAccount(account);
        this.refund.setAccount(account);
        this.collateral.setAccount(account);
        this.treasury.setAccount(account);
        this.replace.setAccount(account);
        this.issue.setAccount(account);
        this.redeem.setAccount(account);
    }

    get account(): AddressOrPair | undefined {
        return this._account;
    }
}