StakingManager

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

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


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

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


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @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 {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @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 {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _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: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: MediCoinStakingV3.sol


pragma solidity ^0.8.20;




contract StakingManager is Ownable, ReentrancyGuard {
    IERC20 public immutable mediCoin;

    struct StakeInfo {
        uint256 amount;
        uint256 startTime;
        uint8 planId;
        bool active;
    }

    struct Plan {
        uint256 lockPeriod;           // in seconds
        uint256 apy;                  // APY in basis points (e.g., 700 = 7.00%)
        uint256 penaltyPercent;       // penalty for early withdraw (e.g., 1500 = 15.00%)
        bool allowEarlyWithdraw;      // if early withdraw is allowed
        bool compoundMonthly;         // does it compound monthly?
    }

    Plan[] public plans;
    mapping(address => StakeInfo[]) public userStakes;

    // ✅ NEW GLOBAL METRICS
    mapping(uint8 => uint256) public totalStakedPerPlan;
    mapping(uint8 => uint256) public totalStakersPerPlan;
    mapping(address => mapping(uint8 => bool)) public hasStakedPlan;
    
    // ✅ STAKING CAPS (Optional - can be enabled/disabled)
    bool public capsEnabled = false;
    uint256 public maxStakePerTransaction = 1000000 * 10**18;  // 1M MCN per stake
    uint256 public maxTotalPerWallet = 5000000 * 10**18;       // 5M MCN total per wallet
    mapping(address => uint256) public totalStakedByUser;      // Track user's total stakes
    
    // ✅ GLOBAL POOL CAP (Prevents bypass via multiple wallets)
    bool public globalCapEnabled = false;
    uint256 public maxGlobalStake = 50000000 * 10**18;         // 50M MCN total across all users
    uint256 public totalGlobalStaked = 0;                      // Track total staked by everyone

    event Staked(address indexed user, uint256 indexed stakeId, uint8 planId, uint256 amount);
    event Claimed(address indexed user, uint256 indexed stakeId, uint256 payout);
    event EarlyWithdrawn(address indexed user, uint256 indexed stakeId, uint256 payout);

    constructor(address _token) Ownable(msg.sender) {
        require(_token != address(0), "Token address required");
        mediCoin = IERC20(_token);

        // ✅ All plans now use monthly compounding for consistency
        plans.push(Plan(180 days, 500, 0, false, true));        // 6M - Fixed: now compounds monthly
        plans.push(Plan(365 days, 700, 500, true, true));       // 1Y
        plans.push(Plan(730 days, 1000, 900, true, true));      // 2Y
        plans.push(Plan(1095 days, 1500, 1200, true, true));    // 3Y
        plans.push(Plan(1825 days, 1800, 1500, true, true));    // 5Y
    }

    function stake(uint8 planId, uint256 amount) external nonReentrant {
        require(amount > 0, "Cannot stake zero");
        require(planId < plans.length, "Invalid plan");
        
        // ✅ Check global pool cap if enabled
        if (globalCapEnabled) {
            require(totalGlobalStaked + amount <= maxGlobalStake, "Global staking cap reached");
        }
        
        // ✅ Check per-wallet staking caps if enabled
        if (capsEnabled) {
            require(amount <= maxStakePerTransaction, "Exceeds per-transaction limit");
            require(totalStakedByUser[msg.sender] + amount <= maxTotalPerWallet, "Exceeds wallet total limit");
        }

        mediCoin.transferFrom(msg.sender, address(this), amount);

        userStakes[msg.sender].push(StakeInfo({
            amount: amount,
            startTime: block.timestamp,
            planId: planId,
            active: true
        }));

        // ✅ Track aggregate metrics
        totalStakedPerPlan[planId] += amount;
        totalStakedByUser[msg.sender] += amount;
        totalGlobalStaked += amount;
        if (!hasStakedPlan[msg.sender][planId]) {
            totalStakersPerPlan[planId]++;
            hasStakedPlan[msg.sender][planId] = true;
        }

        emit Staked(msg.sender, userStakes[msg.sender].length - 1, planId, amount);
    }

    function claim(uint256 stakeId) external nonReentrant {
        StakeInfo storage info = userStakes[msg.sender][stakeId];
        require(info.active, "Already claimed");
        Plan memory plan = plans[info.planId];
        uint256 endTime = info.startTime + plan.lockPeriod;
        require(block.timestamp >= endTime, "Stake still locked");

        uint256 reward = calculateRewards(info.amount, plan.apy, plan.lockPeriod, plan.compoundMonthly);
        uint256 payout = info.amount + reward;

        info.active = false;

        require(mediCoin.transfer(msg.sender, payout), "Transfer failed");
        emit Claimed(msg.sender, stakeId, payout);
    }

    function earlyWithdraw(uint256 stakeId) external nonReentrant {
        StakeInfo storage info = userStakes[msg.sender][stakeId];
        require(info.active, "Already withdrawn");

        Plan memory plan = plans[info.planId];
        require(plan.allowEarlyWithdraw, "Early withdraw not allowed");

        uint256 penalty = (info.amount * plan.penaltyPercent) / 10000;
        uint256 payout = info.amount - penalty;

        info.active = false;

        require(mediCoin.transfer(msg.sender, payout), "Transfer failed");
        emit EarlyWithdrawn(msg.sender, stakeId, payout);
    }

    function calculateRewards(
        uint256 principal, 
        uint256 apyBP, 
        uint256 durationInSeconds, 
        bool isCompoundMonthly
    ) public pure returns (uint256) {
        uint256 timeInYears = durationInSeconds / 365 days;

        if (isCompoundMonthly) {
            uint256 r = apyBP * 1e14 / 12; // Monthly interest rate in wei (1e18 precision)
            uint256 n = timeInYears * 12;
            uint256 amount = principal;

            for (uint256 i = 0; i < n; i++) {
                amount += (amount * r) / 1e18;
            }
            return amount - principal;
        } else {
            uint256 reward = (principal * apyBP * timeInYears) / 10000;
            return reward;
        }
    }

    // ✅ VIEW FUNCTIONS (Essential + Optional)

    function getUserStakes(address user) external view returns (StakeInfo[] memory) {
        return userStakes[user];
    }

    function getPlanStats(uint8 planId) external view returns (
        uint256 totalStaked,
        uint256 totalStakers,
        uint256 apy,
        uint256 lockPeriod,
        bool compoundMonthly
    ) {
        require(planId < plans.length, "Invalid plan");
        Plan memory plan = plans[planId];

        return (
            totalStakedPerPlan[planId],
            totalStakersPerPlan[planId],
            plan.apy,
            plan.lockPeriod,
            plan.compoundMonthly
        );
    }

    function getAllPlans() external view returns (Plan[] memory) {
        return plans;
    }

    function getTotalActiveStakes(address user) external view returns (uint256 count) {
        StakeInfo[] memory stakes = userStakes[user];
        for (uint256 i = 0; i < stakes.length; i++) {
            if (stakes[i].active) count++;
        }
    }

    function getGlobalStakingSummary() external view returns (
        uint256 totalUsers,
        uint256 totalPlans,
        uint256[] memory stakedPerPlan
    ) {
        uint256[] memory staked = new uint256[](plans.length);
        for (uint8 i = 0; i < plans.length; i++) {
            staked[i] = totalStakedPerPlan[i];
        }
        return (address(this).balance, plans.length, staked);
    }

    // ✅ Owner Functions
    function addNewPlan(
        uint256 lockPeriodDays, 
        uint256 apyBP, 
        uint256 penaltyBP, 
        bool allowEarly, 
        bool compoundMonthly
    ) external onlyOwner {
        plans.push(Plan(lockPeriodDays * 1 days, apyBP, penaltyBP, allowEarly, compoundMonthly));
    }

    function updatePlan(
        uint8 planId, 
        uint256 lockPeriodDays, 
        uint256 apyBP, 
        uint256 penaltyBP, 
        bool allowEarly,
        bool compoundMonthly
    ) external onlyOwner {
        require(planId < plans.length, "Invalid plan");
        plans[planId] = Plan(lockPeriodDays * 1 days, apyBP, penaltyBP, allowEarly, compoundMonthly);
    }

    // ✅ Owner Functions for Fund Management
    
    /**
     * @dev Withdraw accumulated penalty tokens or excess rewards
     * @param amount Amount of tokens to withdraw
     */
    function withdrawPenalties(uint256 amount) external onlyOwner nonReentrant {
        require(amount > 0, "Amount must be greater than 0");
        uint256 contractBalance = mediCoin.balanceOf(address(this));
        require(contractBalance >= amount, "Insufficient contract balance");
        require(mediCoin.transfer(msg.sender, amount), "Transfer failed");
    }

    /**
     * @dev Emergency function to withdraw all tokens from contract
     * Use with caution - ensure all active stakes are settled first
     */
    function emergencyWithdrawAll() external onlyOwner nonReentrant {
        uint256 contractBalance = mediCoin.balanceOf(address(this));
        require(contractBalance > 0, "No balance to withdraw");
        require(mediCoin.transfer(msg.sender, contractBalance), "Transfer failed");
    }

    /**
     * @dev Get current contract token balance
     */
    function getContractBalance() external view returns (uint256) {
        return mediCoin.balanceOf(address(this));
    }
    
    // ✅ Staking Cap Management Functions
    
    /**
     * @dev Enable or disable staking caps
     */
    function setCapsEnabled(bool _enabled) external onlyOwner {
        capsEnabled = _enabled;
    }
    
    /**
     * @dev Update maximum stake per transaction
     */
    function setMaxStakePerTransaction(uint256 _max) external onlyOwner {
        maxStakePerTransaction = _max;
    }
    
    /**
     * @dev Update maximum total stake per wallet
     */
    function setMaxTotalPerWallet(uint256 _max) external onlyOwner {
        maxTotalPerWallet = _max;
    }
    
    /**
     * @dev Get user's total staked amount across all plans
     */
    function getUserTotalStaked(address user) external view returns (uint256) {
        return totalStakedByUser[user];
    }
    
    // ✅ Global Pool Cap Management
    
    /**
     * @dev Enable or disable global pool cap
     */
    function setGlobalCapEnabled(bool _enabled) external onlyOwner {
        globalCapEnabled = _enabled;
    }
    
    /**
     * @dev Update maximum global stake pool
     */
    function setMaxGlobalStake(uint256 _max) external onlyOwner {
        maxGlobalStake = _max;
    }
    
    /**
     * @dev Get total staked across all users
     */
    function getTotalGlobalStaked() external view returns (uint256) {
        return totalGlobalStaked;
    }
    
    /**
     * @dev Get remaining capacity in global pool
     */
    function getGlobalStakeRemaining() external view returns (uint256) {
        if (totalGlobalStaked >= maxGlobalStake) {
            return 0;
        }
        return maxGlobalStake - totalGlobalStaked;
    }
}