mapping(address => uint256) public protocolInvestments;

constructor(address _treasuryWallet) {
    treasuryWallet = _treasuryWallet;
}

// Transfer |V1 GOV| tokens from the sender to this contract
require(IERC20(treasuryWallet).transferFrom(msg.sender, address(this), amount), "Transfer failed");

// Add the participant's collateral to the protocol investments
protocolInvestments[msg.sender] += amount;

function divertSlashedTokensToTreasury(address token, uint256 amount) external onlyOwner {
    require(amount > 0, "Invalid amount");

    // Transfer slashed tokens to the Treasury
    IERC20(token).transferFrom(msg.sender, address(this), amount);
}

 // Allow anyone to send funds in the form of stablecoins to the Treasury
 event StablecoinsReceived(address, address, uint);
function sendStablecoinsToTreasury(address token, uint256 amount) external nonReentrant {
    require(token != address(0), "Invalid token address");
    require(amount > 0, "Invalid amount");

    IERC20(token).transferFrom(msg.sender, address(this), amount);
    emit StablecoinsReceived(msg.sender, token, amount);
}

//**
 * @title FDV - Foundation  Contract
 * @dev This smart contract manages funds for protocols and users, facilitating investment 
 * The contract is owned by an address and can only be interacted with by designated parties.
 * It allows protocols to send investments, manage their funding details, and transfer amounts to a burning contract.
 * Only the designated foundation (multisig)address is allowed to trigger transfers to the burning contract.
 */
pragma solidity ^0.8.16;

import "./IBurning.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract FDV is Ownable {
    // Struct to store investment details for each protocol
    struct Protocol {
        uint Investments;           // Total investments received for the protocol
        uint AmountTransferred;     // Total amount transferred to the burning contract
        address UsdUsed;            // Address of the USD token used for investments
    }

    mapping(address => Protocol) public Details; // Protocol-specific investment details
    mapping(address => uint) public UserAmount;  // User-specific received amounts
    mapping (address =>uint )public  SlashedAmount; //Slashed Amount 

    IBurning public BurningAddress;     // Address of the Burning contract
    address public WeuFoundation;       // Address of the foundation managing the contract

    // Modifier to ensure that only the foundation can execute certain functions
    modifier onlyWeuFoundation() {
        require(msg.sender == WeuFoundation, "Only the foundation can call this function");
        _;
    }

    /**
     * @dev Receives an investment for a protocol.
     * @param _Protocol Address of the protocol sending the investment.
     * @param _amount Amount of the investment.
     * @param usdUsed Address of the USD token used for the investment.
     */
    function ReceiveInvestment(address _protocol, uint _amount, address usdUsed) external {
        require(_protocol != address(0), "Protocol address must not be zero");
        require(BurningAddress.UsdUsed(usdUsed) == true, "Token is not registered");

        Details[_protocol].Investments += _amount;
        Details[_protocol].UsdUsed = usdUsed;

        IERC20(usdUsed).transferFrom(msg.sender, address(this), _amount);
    }

    /**
     * @dev Sets the address of the burning contract.
     * @param _burningAddress Address of the burning contract.
     */
    function SetBurningAddress(address _burningAddress) external onlyOwner {
        require(_burningAddress != address(0), "Burning address cannot be zero");
        BurningAddress = IBurning(_burningAddress);
    }

    /**
     * @dev Receives an amount from a user.
     * @param usdUsed Address of the USD token used for the transaction.
     * @param _amount Amount received from the user.
     */
    function ReceiveAmount(address usdUsed, uint _amount) external {
        require(usdUsed != address(0), "USD address must not be zero");
        require(_amount > 0, "Received amount must be greater than zero");

        UserAmount[msg.sender] += _amount;
        IERC20(usdUsed).transferFrom(msg.sender, address(this), _amount);
    }

    /**
     * @dev Receives an amount from a user for slashed tokens.
     * @param usdUsed Address of the USD token used for the transaction.
     * @param _amount Amount received from the user.
     */

    function ReceiveSlashedTokensToTreasury(address usdUsed, uint256 amount) external onlyOwner {
    require(amount > 0, "Invalid amount");
    SlashedAmount[UsdUsed]=amount;

    // Transfer slashed tokens to the Treasury
    IERC20(usdUsed).transferFrom(msg.sender, address(this), amount);
    }

    /**
     * @dev Transfers an amount to the burning contract for a protocol.
     * @param _protocol Address of the protocol to transfer funds from.
     * @param _amount Amount to be transferred.
     */
    function TransferToBurning(address _protocol, uint _amount) external onlyWeuFoundation {
        require(_protocol != address(0), "Protocol address must not be zero");
        require((_amount + Details[_protocol].AmountTransferred) <= Details[_protocol].Investments);

        if (BurningAddress.getProtocolInitiated(_protocol) == true) {
            IERC20(Details[_protocol].UsdUsed).approve(address(BurningAddress), _amount);
            BurningAddress.addAmountToBurningPool(_protocol, _amount);
            Details[_protocol].AmountTransferred += _amount;
        } else {
            IERC20(Details[_protocol].UsdUsed).approve(address(BurningAddress), _amount);
            BurningAddress.initializeBurningPool(_protocol, Details[_protocol].UsdUsed, _amount);
            Details[_protocol].AmountTransferred += _amount;
        }
    }

    /**
     * @dev Sets the address of the foundation managing the contract.
     * @param _weuFoundation Address of the foundation.
     */
    function setWeuFoundation(address _weuFoundation) external onlyOwner {
        require(_weuFoundation != address(0), "Foundation address cannot be zero");
        WeuFoundation = _weuFoundation;
    }

}