// File: contracts/CollateralRatioGuardian.sol



// SPDX-License-Identifier: GPL-3.0

pragma solidity 0.8.17;

import "./ILybra.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract CollateralRatioGuardian is Ownable {
    ILybra public immutable lybra;
    AggregatorV3Interface internal priceFeed =
        AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);

    mapping (address => RepaymentSetting) public userRepaymentSettings;
    uint256 public fee = 200 * 1e18;

    struct RepaymentSetting {
        uint256 triggerCollateralRatio;
        uint256 expectedCollateralRatio;
        bool active;
    }

    event UserActivatedAutoRepayment(address indexed user, uint256 triggerCollateralRatio, uint256 expectedCollateralRatio);
    event UserDeactivatedAutoRepayment(address indexed user);
    event ServiceFeeChanged(uint256 newFee, uint256 time);
    event ExecuteAutoRepayment(address indexed user, address keeper, uint256 repayAmount, uint256 fee, uint256 time);

    constructor(address _lybra) {
        lybra = ILybra(_lybra);
    }

    /**
    * @notice Allows the admin to modify the service fee, with a maximum of 500 eUSD.
    * @dev Only the admin is allowed to call this function to modify the service fee.
    * @param _fee The new service fee amount. Must be between 100 and 500 eUSD.
    */
    function setFee(uint256 _fee) external onlyOwner {
        require(_fee <= 500 * 1e18 && _fee >= 100 * 1e18, "Fee must be between 100 and 500 eUSD");
        fee = _fee;
        emit ServiceFeeChanged(_fee, block.timestamp);
    }

    /**
    * @notice Enables the user to activate the automatic repayment feature.
    * @dev The user can enable the automatic repayment feature by calling this function.
    * @param expectedCollateralRatio The expected collateralization rate. Must be greater than the trigger collateralization rate and the safe collateralization rate specified by the Lybra contract.
    * @param triggerCollateralRatio The trigger collateralization rate. Must be greater than the bad collateralization rate specified by the Lybra contract.
    */
    function enableAutoRepayment(uint256 triggerCollateralRatio, uint256 expectedCollateralRatio) external {
        require(expectedCollateralRatio > triggerCollateralRatio, "The expectedCollateralRatio needs to be higher than the triggerCollateralRatio.");
        require(triggerCollateralRatio > lybra.badCollateralRate(), "The triggerCollateralRatio needs to be higher than lybra.badCollateralRatio.");
        require(expectedCollateralRatio >= lybra.safeCollateralRate(), "The expectedCollateralRatio needs to be greater than or equal to lybra.safeCollateralRatio");
        userRepaymentSettings[msg.sender] = RepaymentSetting(triggerCollateralRatio, expectedCollateralRatio, true);
        emit UserActivatedAutoRepayment(msg.sender, triggerCollateralRatio, expectedCollateralRatio);
    }

    /**
    * @notice Allows the user to disable the automatic repayment feature.
    */
    function disableAutoRepayment() external {
        require(userRepaymentSettings[msg.sender].active == true, "The automatic repayment is not enabled.");
         userRepaymentSettings[msg.sender].active = false;
         emit UserDeactivatedAutoRepayment(msg.sender);
    }

    /**
    * @notice Retrieves the real-time price of ETH using Chainlink.
    * @return The real-time price of ETH.convert the return value from Chainlink to 18 decimals.
    */
    function getEtherPrice() public view returns (uint256) {
        // prettier-ignore
        (
            /* uint80 roundID */,
            int price,
            /*uint startedAt*/,
            /*uint timeStamp*/,
            /*uint80 answeredInRound*/
        ) = priceFeed.latestRoundData();
        require(price > 0, "The ChainLink return value must be greater than 0.");
        return uint256(price * 1e10);
    }

    
    /**
    * @dev Allows any third-party keeper to trigger automatic repayment for a user.
    * Requirements:
    * `user` must have enabled the automatic repayment feature.
    * Current collateral ratio of the user must be less than or equal to userSetting.triggerCollateralRatio.
    * `user` must have authorized this contract to spend eUSD in an amount greater than the repayment amount + fee.
    */
    function execute(address user) external {
        RepaymentSetting memory userSetting = userRepaymentSettings[user];
        require(userSetting.active == true, "The user has not enabled the automatic repayment");
        uint256 userCollateralRatio = getCollateralRatio(user);
        require(userCollateralRatio <= userSetting.triggerCollateralRatio, "The user's collateralRate is not below the trigger collateralRate");

        uint256 targetDebt = (lybra.depositedEther(user) * getEtherPrice()) * 100 / userSetting.expectedCollateralRatio;
        uint256 repayAmount = lybra.getBorrowedOf(user) - targetDebt ;
        lybra.transferFrom(user, address(this), repayAmount + fee);
        lybra.burn(user, repayAmount);
        uint256 balance = lybra.balanceOf(address(this)) < fee ? lybra.balanceOf(address(this)):fee;
        lybra.transfer(msg.sender, balance);
        emit ExecuteAutoRepayment(user, msg.sender, repayAmount, balance, block.timestamp);
    }

    /**
    * @dev Returns whether it is possible to invoke the automatic repayment function on behalf of `user`.
    * @return True if it is possible to invoke the automatic repayment function on behalf of `user`, otherwise false.
    */
    function checkExecutionFeasibility(address user) external view returns(bool) {
        RepaymentSetting memory userSetting = userRepaymentSettings[user];
        if(userSetting.active != true) return false;
        uint256 userCollateralRatio = getCollateralRatio(user);
        if(userCollateralRatio > userSetting.triggerCollateralRatio) return false;

        uint256 targetDebt = (lybra.depositedEther(user) * getEtherPrice()) * 100 / userSetting.expectedCollateralRatio;
        uint256 totalAmount = lybra.getBorrowedOf(user) - targetDebt + fee;
        if(lybra.allowance(user, address(this)) < totalAmount || lybra.balanceOf(user) < totalAmount) return false;
        return true;
    }

    /**
    * @dev Retrieves the current collateral ratio of `user`.
    */
    function getCollateralRatio(address user) public view returns (uint256) {
        if (lybra.getBorrowedOf(user) == 0) return 1e22;
        return
            (lybra.depositedEther(user) * getEtherPrice()) * 100 /
            lybra.getBorrowedOf(user);
    }
    
}

// File: @openzeppelin/contracts/access/Ownable.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol



// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface AggregatorV3Interface {
  function decimals() external view returns (uint8);

  function description() external view returns (string memory);

  function version() external view returns (uint256);

  function getRoundData(uint80 _roundId)
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );

  function latestRoundData()
    external
    view
    returns (
      uint80 roundId,
      int256 answer,
      uint256 startedAt,
      uint256 updatedAt,
      uint80 answeredInRound
    );
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// File: contracts/ILybra.sol



// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.17;

interface ILybra {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function sharesOf(address account) external view returns (uint256);

    function totalDepositedEther() external view returns (uint256);

    function badCollateralRate() external view returns (uint256);

    function burn(address onBehalfOf, uint256 amount) external;

    function safeCollateralRate() external view returns (uint256);

    function redemptionFee() external view returns (uint256);

    function keeperRate() external view returns (uint256);

    function depositedEther(address user) external view returns (uint256);

    function getBorrowedOf(address user) external view returns (uint256);

    function isRedemptionProvider(address user) external view returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function transfer(
        address _recipient,
        uint256 _amount
    ) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);

    function transferShares(
        address _recipient,
        uint256 _sharesAmount
    ) external returns (uint256);

    function getSharesByMintedEUSD(
        uint256 _EUSDAmount
    ) external view returns (uint256);

    function getMintedEUSDByShares(
        uint256 _sharesAmount
    ) external view returns (uint256);
}

// File: @openzeppelin/contracts/utils/Context.sol



// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}