/**
 * Copyright 2017-2021, bZeroX, LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0.
 */

pragma solidity 0.5.17;

import "../openzeppelin/SafeMath.sol";
import "../openzeppelin/Ownable.sol";
import "../interfaces/IERC20.sol";
import "./PriceFeedsConstants.sol";

interface IPriceFeedsExt {
	function latestAnswer() external view returns (uint256);
}

/**
 * @title The Price Feeds contract.
 *
 * @notice This contract code comes from bZx. bZx is a protocol for tokenized
 * margin trading and lending https://bzx.network similar to the dYdX protocol.
 *
 * This contract queries the price feeds contracts where
 * oracles updates token prices computing relative token prices.
 * And besides it includes some calculations about loans such as
 * drawdown, margin and collateral.
 * */
contract PriceFeeds is Constants, Ownable {
	using SafeMath for uint256;

	/* Events */

	event GlobalPricingPaused(address indexed sender, bool indexed isPaused);

	/* Storage */

	/// Mapping of PriceFeedsExt instances.
	/// token => pricefeed
	mapping(address => IPriceFeedsExt) public pricesFeeds;

	/// Decimals of supported tokens.
	mapping(address => uint256) public decimals;

	/// Value on rBTC weis for the protocol token.
	uint256 public protocolTokenEthPrice = 0.0002 ether;

	/// Flag to pause pricings.
	bool public globalPricingPaused = false;

	/* Functions */

	/**
	 * @notice Contract deployment requires 3 parameters.
	 *
	 * @param _wrbtcTokenAddress The address of the wrapped wrBTC token.
	 * @param _protocolTokenAddress The address of the protocol token.
	 * @param _baseTokenAddress The address of the base token.
	 * */
	constructor(
		address _wrbtcTokenAddress,
		address _protocolTokenAddress,
		address _baseTokenAddress
	) public {
		/// Set decimals for this token.
		decimals[address(0)] = 18;
		decimals[_wrbtcTokenAddress] = 18;
		_setWrbtcToken(_wrbtcTokenAddress);
		_setProtocolTokenAddress(_protocolTokenAddress);
		_setBaseToken(_baseTokenAddress);
	}

	/**
	 * @notice Calculate the price ratio between two tokens.
	 *
	 * @dev Public wrapper for _queryRate internal function.
	 *
	 * @param sourceToken The address of the source tokens.
	 * @param destToken The address of the destiny tokens.
	 *
	 * @return rate The price ratio source/dest.
	 * @return precision The ratio precision.
	 * */
	function queryRate(address sourceToken, address destToken) public view returns (uint256 rate, uint256 precision) {
		return _queryRate(sourceToken, destToken);
	}

	/**
	 * @notice Calculate the relative precision between two tokens.
	 *
	 * @dev Public wrapper for _getDecimalPrecision internal function.
	 *
	 * @param sourceToken The address of the source tokens.
	 * @param destToken The address of the destiny tokens.
	 *
	 * @return The precision ratio source/dest.
	 * */
	function queryPrecision(address sourceToken, address destToken) public view returns (uint256) {
		return sourceToken != destToken ? _getDecimalPrecision(sourceToken, destToken) : 10**18;
	}

	/**
	 * @notice Price conversor: Calculate the price of an amount of source
	 * tokens in destiny token units.
	 *
	 * @dev NOTE: This function returns 0 during a pause, rather than a revert.
	 * Ensure calling contracts handle correctly.
	 *
	 * @param sourceToken The address of the source tokens.
	 * @param destToken The address of the destiny tokens.
	 * @param sourceAmount The amount of the source tokens.
	 *
	 * @return destAmount The amount of destiny tokens equivalent in price
	 *   to the amount of source tokens.
	 * */
	function queryReturn(
		address sourceToken,
		address destToken,
		uint256 sourceAmount
	) public view returns (uint256 destAmount) {
		if (globalPricingPaused) {
			return 0;
		}

		(uint256 rate, uint256 precision) = _queryRate(sourceToken, destToken);

		destAmount = sourceAmount.mul(rate).div(precision);
	}

	/**
	 * @notice Calculate the swap rate between two tokens.
	 *
	 * Regarding slippage, there is a hardcoded slippage limit of 5%, enforced
	 * by this function for all borrowing, lending and margin trading
	 * originated swaps performed in the Sovryn exchange.
	 *
	 * This means all operations in the Sovryn exchange are subject to losing
	 * up to 5% from the internal swap performed.
	 *
	 * @param sourceToken The address of the source tokens.
	 * @param destToken The address of the destiny tokens.
	 * @param sourceAmount The amount of source tokens.
	 * @param destAmount The amount of destiny tokens.
	 * @param maxSlippage The maximum slippage limit.
	 *
	 * @return sourceToDestSwapRate The swap rate between tokens.
	 * */
	function checkPriceDisagreement(
		address sourceToken,
		address destToken,
		uint256 sourceAmount,
		uint256 destAmount,
		uint256 maxSlippage
	) public view returns (uint256 sourceToDestSwapRate) {
		require(!globalPricingPaused, "pricing is paused");
		(uint256 rate, uint256 precision) = _queryRate(sourceToken, destToken);

		sourceToDestSwapRate = destAmount.mul(precision).div(sourceAmount);

		if (rate > sourceToDestSwapRate) {
			uint256 spreadValue = rate - sourceToDestSwapRate;
			spreadValue = spreadValue.mul(10**20).div(sourceToDestSwapRate);
			require(spreadValue <= maxSlippage, "price disagreement");
		}
	}

	/**
	 * @notice Calculate the rBTC amount equivalent to a given token amount.
	 * Native coin on RSK is rBTC. This code comes from Ethereum applications,
	 * so Eth refers to 10**18 weis of native coin, i.e.: 1 rBTC.
	 *
	 * @param tokenAddress The address of the token to calculate price.
	 * @param amount The amount of tokens to calculate price.
	 *
	 * @return ethAmount The amount of rBTC equivalent.
	 * */
	function amountInEth(address tokenAddress, uint256 amount) public view returns (uint256 ethAmount) {
		/// Token is wrBTC, amount in rBTC is the same.
		if (tokenAddress == address(wrbtcToken)) {
			ethAmount = amount;
		} else {
			(uint256 toEthRate, uint256 toEthPrecision) = queryRate(tokenAddress, address(wrbtcToken));
			ethAmount = amount.mul(toEthRate).div(toEthPrecision);
		}
	}

	/**
	 * @notice Calculate the maximum drawdown of a loan.
	 *
	 * A drawdown is commonly defined as the decline from a high peak to a
	 * pullback low of a specific investment or equity in an account.
	 *
	 * Drawdown magnitude refers to the amount of value that a user loses
	 * during the drawdown period.
	 *
	 * @param loanToken The address of the loan token.
	 * @param collateralToken The address of the collateral token.
	 * @param loanAmount The amount of the loan.
	 * @param collateralAmount The amount of the collateral.
	 * @param margin The relation between the position size and the loan.
	 *   margin = (total position size - loan) / loan
	 *
	 * @return maxDrawdown The maximum drawdown.
	 * */
	function getMaxDrawdown(
		address loanToken,
		address collateralToken,
		uint256 loanAmount,
		uint256 collateralAmount,
		uint256 margin
	) public view returns (uint256 maxDrawdown) {
		uint256 loanToCollateralAmount;
		if (collateralToken == loanToken) {
			loanToCollateralAmount = loanAmount;
		} else {
			(uint256 rate, uint256 precision) = queryRate(loanToken, collateralToken);
			loanToCollateralAmount = loanAmount.mul(rate).div(precision);
		}

		uint256 combined = loanToCollateralAmount.add(loanToCollateralAmount.mul(margin).div(10**20));

		maxDrawdown = collateralAmount > combined ? collateralAmount - combined : 0;
	}

	/**
	 * @notice Calculate the margin and the collateral on rBTC.
	 *
	 * @param loanToken The address of the loan token.
	 * @param collateralToken The address of the collateral token.
	 * @param loanAmount The amount of the loan.
	 * @param collateralAmount The amount of the collateral.
	 *
	 * @return currentMargin The margin of the loan.
	 * @return collateralInEthAmount The amount of collateral on rBTC.
	 * */
	function getCurrentMarginAndCollateralSize(
		address loanToken,
		address collateralToken,
		uint256 loanAmount,
		uint256 collateralAmount
	) public view returns (uint256 currentMargin, uint256 collateralInEthAmount) {
		(currentMargin, ) = getCurrentMargin(loanToken, collateralToken, loanAmount, collateralAmount);

		collateralInEthAmount = amountInEth(collateralToken, collateralAmount);
	}

	/**
	 * @notice Calculate the margin of a loan.
	 *
	 * @dev current margin = (total position size - loan) / loan
	 * The collateral amount passed as parameter equals the total position size.
	 *
	 * @param loanToken The address of the loan token.
	 * @param collateralToken The address of the collateral token.
	 * @param loanAmount The amount of the loan.
	 * @param collateralAmount The amount of the collateral.
	 *
	 * @return currentMargin The margin of the loan.
	 * @return collateralToLoanRate The price ratio between collateral and
	 *   loan tokens.
	 * */
	function getCurrentMargin(
		address loanToken,
		address collateralToken,
		uint256 loanAmount,
		uint256 collateralAmount
	) public view returns (uint256 currentMargin, uint256 collateralToLoanRate) {
		uint256 collateralToLoanAmount;
		if (collateralToken == loanToken) {
			collateralToLoanAmount = collateralAmount;
			collateralToLoanRate = 10**18;
		} else {
			uint256 collateralToLoanPrecision;
			(collateralToLoanRate, collateralToLoanPrecision) = queryRate(collateralToken, loanToken);

			collateralToLoanRate = collateralToLoanRate.mul(10**18).div(collateralToLoanPrecision);

			collateralToLoanAmount = collateralAmount.mul(collateralToLoanRate).div(10**18);
		}

		if (loanAmount != 0 && collateralToLoanAmount >= loanAmount) {
			return (collateralToLoanAmount.sub(loanAmount).mul(10**20).div(loanAmount), collateralToLoanRate);
		} else {
			return (0, collateralToLoanRate);
		}
	}

	/**
	 * @notice Get assessment about liquidating a loan.
	 *
	 * @param loanToken The address of the loan token.
	 * @param collateralToken The address of the collateral token.
	 * @param loanAmount The amount of the loan.
	 * @param collateralAmount The amount of the collateral.
	 * @param maintenanceMargin The minimum margin before liquidation.
	 *
	 * @return True/false to liquidate the loan.
	 * */
	function shouldLiquidate(
		address loanToken,
		address collateralToken,
		uint256 loanAmount,
		uint256 collateralAmount,
		uint256 maintenanceMargin
	) public view returns (bool) {
		(uint256 currentMargin, ) = getCurrentMargin(loanToken, collateralToken, loanAmount, collateralAmount);

		return currentMargin <= maintenanceMargin;
	}

	/*
	 * Owner functions
	 */

	/**
	 * @notice Set new value for protocolTokenEthPrice
	 *
	 * @param newPrice The new value for protocolTokenEthPrice
	 * */
	function setProtocolTokenEthPrice(uint256 newPrice) external onlyOwner {
		require(newPrice != 0, "invalid price");
		protocolTokenEthPrice = newPrice;
	}

	/**
	 * @notice Populate pricesFeeds mapping w/ values from feeds[]
	 *
	 * @param tokens The array of tokens to loop and get addresses.
	 * @param feeds The array of contract instances for every token.
	 * */
	function setPriceFeed(address[] calldata tokens, IPriceFeedsExt[] calldata feeds) external onlyOwner {
		require(tokens.length == feeds.length, "count mismatch");

		for (uint256 i = 0; i < tokens.length; i++) {
			pricesFeeds[tokens[i]] = feeds[i];
		}
	}

	/**
	 * @notice Populate decimals mapping w/ values from tokens[].decimals
	 *
	 * @param tokens The array of tokens to loop and get values from.
	 * */
	function setDecimals(IERC20[] calldata tokens) external onlyOwner {
		for (uint256 i = 0; i < tokens.length; i++) {
			decimals[address(tokens[i])] = tokens[i].decimals();
		}
	}

	/**
	 * @notice Set flag globalPricingPaused
	 *
	 * @param isPaused The new status of pause (true/false).
	 * */
	function setGlobalPricingPaused(bool isPaused) external onlyOwner {
		if (globalPricingPaused != isPaused) {
			globalPricingPaused = isPaused;

			emit GlobalPricingPaused(msg.sender, isPaused);
		}
	}

	/*
	 * Internal functions
	 */

	/**
	 * @notice Calculate the price ratio between two tokens.
	 *
	 * @param sourceToken The address of the source tokens.
	 * @param destToken The address of the destiny tokens.
	 *
	 * @return rate The price ratio source/dest.
	 * @return precision The ratio precision.
	 * */
	function _queryRate(address sourceToken, address destToken) internal view returns (uint256 rate, uint256 precision) {
		require(!globalPricingPaused, "pricing is paused");

		/// Different tokens, query prices and perform division.
		if (sourceToken != destToken) {
			uint256 sourceRate;
			if (sourceToken != address(baseToken) && sourceToken != protocolTokenAddress) {
				IPriceFeedsExt _sourceFeed = pricesFeeds[sourceToken];
				require(address(_sourceFeed) != address(0), "unsupported src feed");

				/// Query token price on priceFeedsExt instance.
				sourceRate = _sourceFeed.latestAnswer();
				require(sourceRate != 0 && (sourceRate >> 128) == 0, "price error");
			} else {
				sourceRate = sourceToken == protocolTokenAddress ? protocolTokenEthPrice : 10**18;
			}

			uint256 destRate;
			if (destToken != address(baseToken) && destToken != protocolTokenAddress) {
				IPriceFeedsExt _destFeed = pricesFeeds[destToken];
				require(address(_destFeed) != address(0), "unsupported dst feed");

				/// Query token price on priceFeedsExt instance.
				destRate = _destFeed.latestAnswer();
				require(destRate != 0 && (destRate >> 128) == 0, "price error");
			} else {
				destRate = destToken == protocolTokenAddress ? protocolTokenEthPrice : 10**18;
			}

			rate = sourceRate.mul(10**18).div(destRate);

			precision = _getDecimalPrecision(sourceToken, destToken);

			/// Same tokens, return 1 with decimals.
		} else {
			rate = 10**18;
			precision = 10**18;
		}
	}

	/**
	 * @notice Calculate the relative precision between two tokens.
	 *
	 * @param sourceToken The address of the source tokens.
	 * @param destToken The address of the destiny tokens.
	 *
	 * @return The precision ratio source/dest.
	 * */
	function _getDecimalPrecision(address sourceToken, address destToken) internal view returns (uint256) {
		/// Same tokens, return 1 with decimals.
		if (sourceToken == destToken) {
			return 10**18;

			/// Different tokens, query ERC20 precisions and return 18 +- diff.
		} else {
			uint256 sourceTokenDecimals = decimals[sourceToken];
			if (sourceTokenDecimals == 0) sourceTokenDecimals = IERC20(sourceToken).decimals();

			uint256 destTokenDecimals = decimals[destToken];
			if (destTokenDecimals == 0) destTokenDecimals = IERC20(destToken).decimals();

			if (destTokenDecimals >= sourceTokenDecimals) return 10**(SafeMath.sub(18, destTokenDecimals - sourceTokenDecimals));
			else return 10**(SafeMath.add(18, sourceTokenDecimals - destTokenDecimals));
		}
	}
}