import chai from 'chai';
import sinon from 'sinon';
import chaiAsPromised from 'chai-as-promised';
import * as Provider from '../../src/evmProvider';
import { InfuraProvider, JsonRpcProvider } from '@ethersproject/providers';
import { EthereumNetwork } from '../../src/types';

const sandbox = sinon.createSandbox();
const { expect } = chai;

chai.use(chaiAsPromised);

describe('providers', () => {
  afterEach(sandbox.restore);

  context('getProvider', () => {
    it('should use the extended infura provider for infura RPCs', async () => {
      const provider = Provider.getProvider('goerli', { projectId: '123', projectSecret: '456' });
      expect(provider instanceof Provider.ExtendedInfuraProvider).to.be.true;
    });

    it('should use the default provider for non-infura RPCs', async () => {
      const provider = Provider.getProvider('xdcMainnet');
      expect(provider instanceof InfuraProvider).to.be.false;
      expect(provider instanceof Provider.ExtendedInfuraProvider).to.be.false;
      expect(provider.getNetwork()).to.eventually.deep.equal({ name: 'xdcMainnet', chainId: 50 });
    });

    it('should use localhost provider for localhost', () => {
      const provider = Provider.getProvider('localhost') as JsonRpcProvider;
      expect(provider).to.be.instanceOf(JsonRpcProvider);
      expect(provider.connection.url).to.equal('http://localhost:8545');
    });

    it('should alias "matic" to "polygonMainnet"', () => {
      return expect(
        Provider.getProvider('matic' as EthereumNetwork, { projectId: '123', projectSecret: '456' }).network.name
      ).to.equal('polygonMainnet');
    });

    it('should alias "maticmum" to "polygonMumbai"', () => {
      return expect(
        Provider.getProvider('maticmum' as EthereumNetwork, { projectId: '123', projectSecret: '456' }).network.name
      ).to.equal('polygonMumbai');
    });

    it('should alias "homestead" to "mainnet"', () => {
      return expect(
        Provider.getProvider('homestead' as EthereumNetwork, { projectId: '123', projectSecret: '456' }).network.name
      ).to.equal('mainnet');
    });

    it('should alias "Mainnet" to "mainnet" (case-insensitive)', () => {
      return expect(
        Provider.getProvider('Mainnet' as EthereumNetwork, { projectId: '123', projectSecret: '456' }).network.name
      ).to.equal('mainnet');
    });


    it('should throw an error if network mapping is not defined', () => {
      return expect(() =>
        Provider.getProvider('invalid-network' as EthereumNetwork, {
          projectId: '123',
          projectSecret: '456',
        })
      ).to.throw(/Could not find Provider network details for network invalid-network/);
    });

    it('returns valid provider for non-infura url', () => {
      const provider = Provider.getProvider('xdcApothem'); // This network does not have an infura URL, so a different code path is used.
      expect(provider.getNetwork()).to.eventually.deep.equal({ name: 'xdcApothem', chainId: 51 });
      expect(provider.getFeeData()).to.eventually.exist;
    });
  });
});