import {evmRevert, evmSnapshot, BRE} from "../../helpers/misc-utils";
import {Signer} from "ethers";
import {
  getEthersSigners,
  getLendingPool,
  getLendingPoolAddressesProvider,
  getAaveProtocolTestHelpers,
  getAToken,
  getMintableErc20,
  getLendingPoolConfiguratorProxy, getPriceOracle,
} from '../../helpers/contracts-helpers';
import {tEthereumAddress} from "../../helpers/types";
import {LendingPool} from "../../types/LendingPool";
import {AaveProtocolTestHelpers} from "../../types/AaveProtocolTestHelpers";
import {MintableErc20} from "../../types/MintableErc20";
import {AToken} from "../../types/AToken";
import {LendingPoolConfigurator} from "../../types/LendingPoolConfigurator";

import chai from "chai";
// @ts-ignore
import bignumberChai from "chai-bignumber";
import { PriceOracle } from '../../types/PriceOracle';
import { LendingPoolAddressesProvider } from "../../types/LendingPoolAddressesProvider";
chai.use(bignumberChai());

export interface SignerWithAddress {
  signer: Signer;
  address: tEthereumAddress;
}
export interface TestEnv {
  deployer: SignerWithAddress;
  users: SignerWithAddress[];
  pool: LendingPool;
  configurator: LendingPoolConfigurator;
  oracle: PriceOracle;
  helpersContract: AaveProtocolTestHelpers;
  dai: MintableErc20;
  aDai: AToken;
  usdc: MintableErc20;
  addressesProvider: LendingPoolAddressesProvider
}

let buidlerevmSnapshotId: string = "0x1";
const setBuidlerevmSnapshotId = (id: string) => {
  if (BRE.network.name === "buidlerevm") {
    buidlerevmSnapshotId = id;
  }
};

const testEnv: TestEnv = {
  deployer: {} as SignerWithAddress,
  users: [] as SignerWithAddress[],
  pool: {} as LendingPool,
  configurator: {} as LendingPoolConfigurator,
  helpersContract: {} as AaveProtocolTestHelpers,
  oracle: {} as PriceOracle,
  dai: {} as MintableErc20,
  aDai: {} as AToken,
  usdc: {} as MintableErc20,
  addressesProvider: {} as LendingPoolAddressesProvider
} as TestEnv;

export async function initializeMakeSuite() {
  const [_deployer, ...restSigners] = await getEthersSigners();
  const deployer: SignerWithAddress = {
    address: await _deployer.getAddress(),
    signer: _deployer,
  };

  for (const signer of restSigners) {
    testEnv.users.push({
      signer,
      address: await signer.getAddress(),
    });
  }
  testEnv.deployer = deployer;
  testEnv.pool = await getLendingPool();
  console.log("Pool loaded");

  testEnv.configurator = await getLendingPoolConfiguratorProxy();
  console.log("Configurator loaded");
  
  testEnv.oracle = await getPriceOracle();
  console.log("oracle loaded");
  testEnv.addressesProvider = await getLendingPoolAddressesProvider();
  console.log("addresses provider loaded");
 
  testEnv.helpersContract = await getAaveProtocolTestHelpers();
 
  console.log("helpers loaded");
 
  const aDaiAddress = (await testEnv.helpersContract.getAllATokens()).find(
    (aToken) => aToken.symbol === "aDAI"
  )?.tokenAddress;

  console.log("getting reserves");
  
  const reservesTokens = await testEnv.helpersContract.getAllReservesTokens();

  console.log("reserve tokens loaded");
 
  const daiAddress = reservesTokens.find(token => token.symbol === "DAI")?.tokenAddress;
  const usdcAddress = reservesTokens.find(token => token.symbol === "USDC")?.tokenAddress;
  if (!aDaiAddress) {
    console.log(`atoken-modifiers.spec: aDAI not correctly initialized`);
    process.exit(1);
  }
  if (!daiAddress || !usdcAddress) {
    console.log(`atoken-modifiers.spec: USDC or DAI not correctly initialized`);
    process.exit(1);
  }

  testEnv.aDai = await getAToken(aDaiAddress);
  testEnv.dai = await getMintableErc20(daiAddress);
  testEnv.usdc = await getMintableErc20(usdcAddress);
}

export function makeSuite(name: string, tests: (testEnv: TestEnv) => void) {
  describe(name, () => {
    before(async () => {
      setBuidlerevmSnapshotId(await evmSnapshot());
    });
    tests(testEnv);
    after(async () => {
      await evmRevert(buidlerevmSnapshotId);
    });
  });
}