import { ProviderWrapper } from "hardhat/internal/core/providers/wrapper"
import { EthereumProvider, EIP1193Provider, RequestArguments } from "hardhat/types";

/**
 * Wrapped provider which collects tx data
 */
export class EGRDataCollectionProvider extends ProviderWrapper {
  private mochaConfig: any;

  constructor(provider: EIP1193Provider, mochaConfig) {
    super(provider);
    this.mochaConfig = mochaConfig
  }

  public async request(args: RequestArguments): Promise<unknown> {
    // Truffle
    if (args.method === "eth_getTransactionReceipt") {
      const receipt: any = await this._wrappedProvider.request(args);
      if (receipt?.status && receipt?.transactionHash){
        const tx = await this._wrappedProvider.request({
          method: "eth_getTransactionByHash",
          params: [receipt.transactionHash]
        });
        await this.mochaConfig.attachments.recordTransaction(receipt, tx);
      }
      return receipt;

    // Ethers: will get run twice for deployments (e.g both receipt and txhash are fetched)
    } else if (args.method === 'eth_getTransactionByHash'){
      const receipt: any = await this._wrappedProvider.request({
        method: "eth_getTransactionReceipt",
        params: args.params
      })
      const tx = await this._wrappedProvider.request(args)
      if (receipt?.status){
        await this.mochaConfig.attachments.recordTransaction(receipt, tx)
      }
      return tx;

    // Waffle: This is necessary when using Waffle wallets. eth_sendTransaction fetches the
    // transactionHash as part of its flow, eth_sendRawTransaction *does not*.
    } else if (args.method === 'eth_sendRawTransaction') {
      const txHash = await this._wrappedProvider.request(args);

      if (typeof txHash === 'string'){
        const tx = await this._wrappedProvider.request({
          method: "eth_getTransactionByHash",
          params: [txHash]
        });
        const receipt : any = await this._wrappedProvider.request({
            method: "eth_getTransactionReceipt",
            params: [txHash]
        });

        if (receipt?.status){
          await this.mochaConfig.attachments.recordTransaction(receipt, tx)
        }
      }
      return txHash;
    }
    return this._wrappedProvider.request(args);
  }
}

/**
 * A set of async RPC calls which substitute the sync calls made by the core reporter
 * These allow us to use HardhatEVM or another in-process provider.
 */
export class EGRAsyncApiProvider {
  public provider: EthereumProvider;

  constructor(provider: EthereumProvider) {
    this.provider = provider;
  }

  async getNetworkId() {
    return this.provider.send("net_version", []);
  }

  async getCode(address: string) {
    return this.provider.send("eth_getCode", [address, "latest"]);
  }

  async getLatestBlock() {
    return this.provider.send("eth_getBlockByNumber", ["latest", false]);
  }

  async getBlockByNumber(num: number) {
    const hexNumber = `0x${num.toString(16)}`;
    return this.provider.send("eth_getBlockByNumber", [hexNumber, true]);
  }

  async blockNumber() {
    const block = await this.getLatestBlock();
    return parseInt(block.number, 16);
  }

  async getTransactionByHash(tx) {
    return this.provider.send("eth_getTransactionByHash", [tx]);
  }

  async call(payload, blockNumber) {
    return this.provider.send("eth_call", [payload, blockNumber]);
  }
}