import { BaseBlockchain } from './base-blockchain.js';
import { type AddressCallback, type TransactionCallback } from './types.js';
import { BlockchainElectrum } from './blockchain-electrum.js';
import { BlockchainLocal } from './blockchain-local.js';

import { Transaction } from '@xocash/primitives';

/**
 * The idea here is that this will implement the IBlockchain interface.
 * But, it will allow the dev to specify multiple child IBlockchain interfaces for configuration.
 * So, if the network is not available, it can fallback to the local and sync later.
 *
 * @example
 * ```ts
 * // Actual interface will be more complex, but this is the rough idea.
 * const blockchain = new Blockchain([
 *   new BlockchainLocal(...),
 *   new BlockchainElectrum(...)
 * ])
 * ```
 */
export class Blockchain extends BaseBlockchain {
  blockchainLocal: BlockchainLocal;
  blockchainElectrum: BlockchainElectrum;

  constructor() {
    super();

    this.blockchainLocal = new BlockchainLocal();
    this.blockchainElectrum = new BlockchainElectrum();
  }

  async start() {
    await Promise.all([
      this.blockchainLocal.start(),
      this.blockchainElectrum.start(),
    ]);
  }

  async stop() {
    await Promise.all([
      this.blockchainLocal.stop(),
      this.blockchainElectrum.stop(),
    ]);
  }

  async fetchUnspents(address: string) {
    if (this.blockchainElectrum.isConnected) {
      return await this.blockchainElectrum.fetchUnspents(address);
    } else {
      return await this.blockchainLocal.fetchUnspents(address);
    }
  }

  async fetchTransaction(txHash: string) {
    if (this.blockchainElectrum.isConnected) {
      return await this.blockchainElectrum.fetchTransaction(txHash);
    } else {
      return await this.blockchainLocal.fetchTransaction(txHash);
    }
  }

  async fetchAddressHistory(address: string) {
    if (this.blockchainElectrum.isConnected) {
      return await this.blockchainElectrum.fetchAddressHistory(address);
    } else {
      return await this.blockchainLocal.fetchAddressHistory(address);
    }
  }

  async broadcastTransaction(tx: Uint8Array | Transaction | string) {
    if (this.blockchainElectrum.isConnected) {
      return await this.blockchainElectrum.broadcastTransaction(tx);
    } else {
      return await this.blockchainLocal.broadcastTransaction(tx);
    }
  }

  async subscribeAddress(_address: string, _callback: AddressCallback) {
    throw new Error('Not yet implemented');
  }

  async unsubscribeAddress(_address: string, _callback: AddressCallback) {
    throw new Error('Not yet implemented');
  }

  async subscribeTransaction(
    _transactionHash: string,
    _callback: TransactionCallback,
  ) {
    throw new Error('Not yet implemented');
  }

  async unsubscribeTransaction(
    _transactionHash: string,
    _callback: TransactionCallback,
  ) {
    throw new Error('Not yet implemented');
  }
}