// import { task } from 'hardhat/config';
// import {
//   deployATokensAndRatesHelper,
//   deployStableAndVariableTokensHelper,
//   deployAaveProtocolDataProvider,
//   deployLendingPoolAddressesProvider, //Test
// } from '../../helpers/contracts-deployments';
// import {
//   deployUniswapLendingPoolAddressesProvider,
//   deployUniswapLendingPool,
//   deployUniswapLendingPoolConfigurator,
//   deployUniswapPriceOracle,
//   deployUniswapAaveOracle,
//   deployUniswapLendingRateOracle,
//   deployUniswapLendingPoolCollateralManager,
//   deployUniswapMockFlashLoanReceiver,
//   deployUniswapWETHGateway,
//   deployUniswapWalletBalancerProvider,
// } from '../../helpers/uniswap-contracts-deployments';
// import { tEthereumAddress, 
//   eContractid,
//   AavePools,
//   ICommonConfiguration,
//   iAssetBase,
//   TokenContractId,
//   IMarketRates,
// } from '../../helpers/types';
// import { 
//   getLendingPoolAddressesProviderRegistry,
//   getLendingPoolAddressesProvider, //Test
//   getLendingPool,
//   getLendingPoolConfiguratorProxy,
//   getAllMockedTokens,
//   getPairsTokenAggregator,
// } from '../../helpers/contracts-getters';
// import { waitForTx, filterMapBy } from '../../helpers/misc-utils';
// import { UniswapConfig } from '../../markets/uniswap';
// import { insertContractAddressInDb } from '../../helpers/contracts-helpers';
// import {
//   setInitialAssetPricesInOracle,
//   deployAllMockAggregators,
//   setInitialMarketRatesInRatesOracleByHelper,
// } from '../../helpers/oracles-helpers';
// import {getAllAggregatorsAddresses, getAllTokenAddresses} from '../../helpers/mock-helpers';
// import {
//   ConfigNames,
//   getReservesConfigByPool,
//   getTreasuryAddress,
//   loadPoolConfig,
//   getWethAddress,
// } from '../../helpers/configuration';
// import {
//   configureReservesByHelper,
//   initReservesByHelper,
// } from '../../helpers/init-helpers';
// import { ZERO_ADDRESS } from '../../helpers/constants';


// const pool = ConfigNames.Uniswap;
// /**
//  * @dev addressesProvider is actually created here, so we don't need to use getAddressesProvider
//  */
// task(
//   'dev:deploy-uniswap-market',
//   'Deploy uniswap market'
// )
//   .addFlag('verify', 'Verify contracts at Etherscan')
//   .setAction(async ({ verify }, localBRE) => {
//     await localBRE.run('set-DRE');

//     const admin = await (await localBRE.ethers.getSigners())[0].getAddress();

//     const testProvider = await getLendingPoolAddressesProvider();
//     console.log("Addresses provider from function (pre re-deploy):", testProvider.address);
//     const addressesProvider = await deployLendingPoolAddressesProvider(UniswapConfig.MarketId, verify);
//     console.log("Addresses provider in execution::", addressesProvider.address)

//     const testProviderPost = await getLendingPoolAddressesProvider();
//     console.log("Addresses provider from function (pre re-deploy):", testProviderPost.address);
//     console.log("Addresses provider from function (post re-deploy) should be different:")
//     await waitForTx(await addressesProvider.setPoolAdmin(admin));
    
    
//     const addressesProviderRegistry = await getLendingPoolAddressesProviderRegistry();
//     await waitForTx(
//       await addressesProviderRegistry.registerAddressesProvider(addressesProvider.address, 1)
//     );
//     console.log(addressesProvider.address);


//     /**
//      * LENDING POOL DEPLOYMENT
//      */
//     const lendingPoolImpl = await deployUniswapLendingPool(verify);

//     await waitForTx(await addressesProvider.setLendingPoolImpl(lendingPoolImpl.address));

//     const address = await addressesProvider.getLendingPool();
//     console.log("UNISWAP MARKET LENDING POOL:", address);
//     const lendingPoolProxy = await getLendingPool(address);
//     await insertContractAddressInDb(eContractid.UniswapLendingPool, lendingPoolProxy.address);

//     const lendingPoolConfiguratorImpl = await deployUniswapLendingPoolConfigurator(verify);

//     // Set lending pool conf impl to Address Provider
//     await waitForTx(
//       await addressesProvider.setLendingPoolConfiguratorImpl(lendingPoolConfiguratorImpl.address)
//     );

//     const lendingPoolConfiguratorProxy = await getLendingPoolConfiguratorProxy(
//       await addressesProvider.getLendingPoolConfigurator()
//     );

//     await insertContractAddressInDb(
//       eContractid.UniswapLendingPoolConfigurator,
//       lendingPoolConfiguratorProxy.address
//     );

//     // Deploy deployment helpers
//     await deployStableAndVariableTokensHelper(
//       [lendingPoolProxy.address, addressesProvider.address],
//       verify
//     );
//     await deployATokensAndRatesHelper(
//       [lendingPoolProxy.address, addressesProvider.address, lendingPoolConfiguratorProxy.address],
//       verify
//     );

//     /**
//      * @dev Oracle deployment section
//      */

//     console.log("Uniswap oracle deployment beginning.")
//     const poolConfig = loadPoolConfig(pool);
//     console.log("Initialized pool config...");

//     const {
//       Mocks: {AllAssetsInitialPrices},
//       ProtocolGlobalParams: {UsdAddress, MockUsdPriceInWei},
//       LendingRateOracleRatesCommon,
//     } = poolConfig as ICommonConfiguration;
    
//     console.log("Initialized mocks, global params and lending rate oracle rates");

//     const defaultTokenList = {
//       ...Object.fromEntries(Object.keys(TokenContractId).map((symbol) => [symbol, ''])),
//       USD: UsdAddress,
//     } as iAssetBase<string>;
    
//     console.log("Initialized defaultTokenList");

//     const mockTokens = await getAllMockedTokens();

//     console.log("Initialized mock tokens");

//     const mockTokensAddress = Object.keys(mockTokens).reduce<iAssetBase<string>>((prev, curr) => {
//       prev[curr as keyof iAssetBase<string>] = mockTokens[curr].address;
//       return prev;
//     }, defaultTokenList);
//     console.log(mockTokensAddress);
//     console.log("Initialized mock tokens addresses");

//     // No need to re-initialize addressesProvider and admin

//     const fallbackOracle = await deployUniswapPriceOracle(verify);
//     console.log("Deployed fallback price oracle");

//     await waitForTx(await fallbackOracle.setEthUsdPrice(MockUsdPriceInWei));
//     console.log("set fallback ETH USD price");

//     await setInitialAssetPricesInOracle(AllAssetsInitialPrices, mockTokensAddress, fallbackOracle);
//     console.log("Set initial asset prices in oracle");

//     const mockAggregators = await deployAllMockAggregators(AllAssetsInitialPrices, verify);
//     console.log("Deployed mock aggregators");

//     const allTokenAddresses = getAllTokenAddresses(mockTokens);
//     console.log("Got all mock token addresses");

//     const allAggregatorsAddresses = getAllAggregatorsAddresses(mockAggregators);
//     console.log("Got all aggregator addresses");
//     console.log("allTokenAddresses object: \n", allTokenAddresses);
//     //Should modify this to potentially contain only the tokens in the Uniswap market
//     // const [tokens, aggregators] = getPairsTokenAggregator(
//     //   allTokenAddresses,
//     //   allAggregatorsAddresses
//     // );
//     // console.log("Got \"pairsToken aggregator\"");
//     // console.log("Tokens: \n", tokens);
    
//     // const assetAddressIndex = Object.keys(allReservesAddresses).findIndex(
//     //   (value) => value === assetSymbol
//     // );
//     // const [, assetAddress] = (Object.entries(assetsAddresses) as [string, string][])[
//     //   assetAddressIndex
//     // ];
//     // assetAddresses.push(assetAddress);

//     // await deployUniswapAaveOracle(
//     //   [tokens, aggregators, fallbackOracle.address, await getWethAddress(poolConfig)],
//     //   verify
//     // );
//     console.log("Deployed Uniswap Aave oracle");

//     await waitForTx(await addressesProvider.setPriceOracle(fallbackOracle.address));
//     console.log("Set price oracle in addresses provider");

//     const lendingRateOracle = await deployUniswapLendingRateOracle(verify);
//     console.log("Deployed lendingRateOracle");

//     await waitForTx(await addressesProvider.setLendingRateOracle(lendingRateOracle.address));
//     console.log("Set lending rate oracle in addresses provider");

//     const {USD, ...tokensAddressesWithoutUsd} = allTokenAddresses;
//     console.log("Initialized object with token addresses & usd")

//     const allReservesAddresses = {
//       ...tokensAddressesWithoutUsd,
//     };
//     console.log("Initialized object with all reserve addresses, allReservesAddresses:");
//     console.log(allReservesAddresses);

//     console.log("LendingRateOracleRatesCommon: \n", LendingRateOracleRatesCommon);
//     //
//     // -- test
//     //
//     const [tokens, aggregators] = getPairsTokenAggregator(
//       allTokenAddresses,
//       allAggregatorsAddresses
//     );
//     console.log("Got \"pairsToken aggregator\"");
//     console.log("Tokens: \n", tokens);
//     const assetAddresses: string[] = [];
//     const aggregatorAddresses: string[] = [];
//     for (const [assetSymbol, {borrowRate}] of Object.entries(LendingRateOracleRatesCommon) as [
//       string,
//       IMarketRates
//     ][]) {
//       const assetAddressIndex = Object.keys(allReservesAddresses).findIndex(
//         (value) => value === assetSymbol
//       );
//       const [, assetAddress] = (Object.entries(allReservesAddresses) as [string, string][])[
//         assetAddressIndex
//       ];

//       const [, aggregatorAddress] = (Object.entries(allAggregatorsAddresses) as [string, string][])[
//         assetAddressIndex
//       ];
//       aggregatorAddresses.push(aggregatorAddress);
//       assetAddresses.push(assetAddress);
//     }
//     console.log("\nPRICE ORACLE PARAMS:\nassetAddresses: %s\naggregatorAddresses: %s", assetAddresses, aggregatorAddresses);
//     await deployUniswapAaveOracle(
//       [assetAddresses, aggregatorAddresses, fallbackOracle.address, await getWethAddress(poolConfig)],
//       verify
//     );
//     //
//     // -- test end
//     //
//     console.log("TEST END-----------------------------------------------------------------------");
//     await setInitialMarketRatesInRatesOracleByHelper(
//       LendingRateOracleRatesCommon,
//       allReservesAddresses,
//       lendingRateOracle,
//       admin
//     );

//     console.log("Task complete");

//     /**
//      * @dev Initialization 
//      */

//     // No need to initialize poolConfig, mockTokens, allTokenAddresses, admin and
//     // addressesProvider and protoReservesAddresses (we use allReserveAddresses)
    
//     const testHelpers = await deployAaveProtocolDataProvider(addressesProvider.address, verify);

//     const reservesParams = getReservesConfigByPool(AavePools.uniswap);

//     const treasuryAddress = await getTreasuryAddress(poolConfig);

//     await initReservesByHelper(
//       addressesProvider,
//       reservesParams,
//       allReservesAddresses,
//       admin,
//       treasuryAddress,
//       ZERO_ADDRESS,
//       verify
//     );

//     await configureReservesByHelper(
//       addressesProvider,
//       reservesParams,
//       allReservesAddresses,
//       testHelpers,
//       admin
//     );

//     const collateralManager = await deployUniswapLendingPoolCollateralManager(verify);
//     await waitForTx(
//       await addressesProvider.setLendingPoolCollateralManager(collateralManager.address)
//     );
    
//     const mockFlashLoanReceiver = await deployUniswapMockFlashLoanReceiver(
//       addressesProvider.address,
//       verify
//     );

//     await insertContractAddressInDb(
//       eContractid.UniswapMockFlashLoanReceiver,
//       mockFlashLoanReceiver.address
//     );

//     await deployUniswapWalletBalancerProvider(verify);

//     await insertContractAddressInDb(eContractid.AaveProtocolDataProvider, testHelpers.address);

//     const lendingPoolAddress = await addressesProvider.getLendingPool();
//     const wethAddress = await getWethAddress(poolConfig);
//     await deployUniswapWETHGateway([wethAddress, lendingPoolAddress]);
//   });