Contract

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract IntraverseStakeProtocol is ERC1155Holder, Ownable, ReentrancyGuard {
    // Errors
    error InvalidAddress();
    error RewardPerDayTooLow();
    error ContractNotWhitelisted();
    error NoStakedTokens();
    error NoRewardsToClaim();
    error TokenNotStaked();
    error TokenAlreadyStaked();
    error InvalidAmount();
    error LockPeriodNotOver();
    error InvalidLockPeriod();
    error InsufficientBalance();
    error WithdrawalFailed();

    // Events
    event Staked(address indexed user, address indexed contractAddress, uint256 tokenId, uint256 amount, uint256 timestamp);
    event Unstaked(address indexed user, address indexed contractAddress, uint256 tokenId, uint256 amount, uint256 timestamp);
    event UnstakedAll(address indexed user, uint256 timestamp);
    event RewardClaimed(address indexed user, uint256 amount, uint256 timestamp);
    event RewardPerDayUpdated(uint256 oldValue, uint256 newValue, uint256 timestamp);
    event ContractAddressAdded(address indexed contractAddress, uint256 timestamp);
    event ContractAddressRemoved(address indexed contractAddress, uint256 timestamp);
    event RewardedTokenIdUpdated(uint256 oldTokenId, uint256 newTokenId, uint256 timestamp);
    event DailyTokenCountUpdated(uint256 day, uint256 count);
    event LockPeriodUpdated(uint256 oldValue, uint256 newValue, uint256 timestamp);

    // Structs
    struct StakeInfo {
        address contractAddress;
        uint256 tokenId;
        uint256 amount;
        uint256 lastClaimTimestamp;
    }

    // Config settings
    uint256 public rewardPerDay;
    uint256 public deploymentTimestamp;
    uint256 public DAY_IN_SECONDS; // configurable for testing
    uint256 public constant MAX_DAYS_TO_PROCESS = 181; // Maximum days to process in one transaction
    mapping(address => bool) public whitelistedContracts;
    
    // The specific token ID that will receive rewards
    uint256 public rewardedTokenId;
    
    // Daily counts of rewardedTokenId NFTs staked
    mapping(uint256 => uint256) public dailyRewardedTokenCount;
    
    // Track the latest day for which token count was updated
    uint256 public lastTokenCountUpdateDay;
    
    // User data
    mapping(address => StakeInfo[]) public userStakes;
    mapping(address => mapping(address => mapping(uint256 => uint256))) public stakedTokenIndex; // user -> contract -> tokenId -> index+1 (0 means not staked)
    mapping(address => uint256) public totalUserReward;
    
    // Track all active stakers for reward updates
    address[] public allStakers;
    mapping(address => uint256) public stakerIndex; // Map staker to index in allStakers array (index+1, 0 means not in array)

    // Lock period settings
    uint256 public lockPeriodDays;
    mapping(address => uint256) public userLockTimestamp;

    constructor(uint256 _rewardPerDay, uint256 _rewardedTokenId, uint256 _dayInSeconds, uint256 _lockPeriodDays) Ownable(msg.sender) {
        if (_lockPeriodDays == 0) revert InvalidLockPeriod();
        rewardPerDay = _rewardPerDay;
        rewardedTokenId = _rewardedTokenId;
        deploymentTimestamp = block.timestamp;
        DAY_IN_SECONDS = _dayInSeconds > 0 ? _dayInSeconds : 86400; // Use custom value or default to 24 hours
        lockPeriodDays = _lockPeriodDays;
    }

    /**
     * @notice Get the current day count since contract deployment
     * @return The current day number (starting from 0)
     */
    function getCurrentDay() public view returns (uint256) {
        return (block.timestamp - deploymentTimestamp) / DAY_IN_SECONDS;
    }

    /**
     * @notice Get the day number for a specific timestamp
     * @param timestamp The timestamp to convert to a day number
     * @return The day number since contract deployment
     */
    function getDayForTimestamp(uint256 timestamp) public view returns (uint256) {
        return (timestamp - deploymentTimestamp) / DAY_IN_SECONDS;
    }

    /**
     * @notice Check if user's lock period is over
     * @param user The address of the user to check
     * @return Whether the lock period is over
     */
    function isLockPeriodOver(address user) public view returns (bool) {
        if (userLockTimestamp[user] == 0) return true;
        return block.timestamp >= userLockTimestamp[user] + (lockPeriodDays * DAY_IN_SECONDS);
    }

    /**
     * @notice Stake ERC1155 tokens in the contract
     * @param contractAddress The address of the ERC1155 contract
     * @param tokenId The ID of the token to stake
     * @param amount The amount of tokens to stake
     */
    function stake(address contractAddress, uint256 tokenId, uint256 amount) external nonReentrant returns (bool done) {
        // Validate parameters
        if (contractAddress == address(0)) revert InvalidAddress();
        if (!whitelistedContracts[contractAddress]) revert ContractNotWhitelisted();
        if (amount == 0) revert InvalidAmount();
        
        address sender = msg.sender;
        
        // Check if the user has approved this contract to transfer their tokens
        require(IERC1155(contractAddress).isApprovedForAll(sender, address(this)), 
                "ERC1155: caller is not owner nor approved");
        
        // Add user to stakers list if not already there
        if (stakerIndex[sender] == 0) {
            allStakers.push(sender);
            stakerIndex[sender] = allStakers.length;
        }
        
        // Check if user already has this token staked
        uint256 existingIndex = stakedTokenIndex[sender][contractAddress][tokenId];
        
        if (existingIndex > 0) {
            // Update existing stake
            uint256 index = existingIndex - 1;
            StakeInfo storage stakeInfo = userStakes[sender][index];
            
            // Update rewards before changing stake amount
            bool rewardsProcessed;
            (rewardsProcessed, ) = _processRewardsWithDailyLimit(sender, index, MAX_DAYS_TO_PROCESS);

            // Make sure all rewards are processed
            if (!rewardsProcessed) {
                // in this case, the user will have to call syncUserRewards()
                // to process the rewards or call the function again until done is true

                // note that in this case, nothing has changed in the contract except the lastClaimTimestamp
                // of user's stakes, which should have been updated anyway at some point
                // allStakers and stakerIndex are not affected (cause user is already in the array)
                return false;
            }
            
            // Update stake amount
            unchecked {
                stakeInfo.amount += amount;
            }
        } else {
            // Create new stake
            StakeInfo memory newStake = StakeInfo({
                contractAddress: contractAddress,
                tokenId: tokenId,
                amount: amount,
                lastClaimTimestamp: block.timestamp
            });
            
            userStakes[sender].push(newStake);
            stakedTokenIndex[sender][contractAddress][tokenId] = userStakes[sender].length;
        }
        
        // Transfer tokens to this contract
        // Need to first get approval from msg.sender
        IERC1155(contractAddress).safeTransferFrom(
            sender,
            address(this),
            tokenId,
            amount,
            ""
        );

        // Set or update lock period timestamp
        userLockTimestamp[sender] = block.timestamp;
        
        // Update daily token count if this is a rewarded token
        if (tokenId == rewardedTokenId) {
            uint256 nextDay;
            unchecked {
                nextDay = getCurrentDay() + 1;
            }
            _updateDailyRewardedTokenCount(nextDay, amount, true);
            emit DailyTokenCountUpdated(nextDay, dailyRewardedTokenCount[nextDay]);
        }
        
        emit Staked(sender, contractAddress, tokenId, amount, block.timestamp);
        return true;
    }

    /**
     * @notice Unstake specific ERC1155 tokens
     * @param contractAddress The address of the ERC1155 contract
     * @param tokenId The ID of the token to unstake
     * @param amount The amount of tokens to unstake
     */
    function unstake(address contractAddress, uint256 tokenId, uint256 amount) external nonReentrant returns (bool done) {
        // Validate parameters
        if (contractAddress == address(0)) revert InvalidAddress();
        if (amount == 0) revert InvalidAmount();
        if (!isLockPeriodOver(msg.sender)) revert LockPeriodNotOver();
        
        // Check if user has this token staked
        uint256 existingIndex = stakedTokenIndex[msg.sender][contractAddress][tokenId];
        if (existingIndex == 0) revert TokenNotStaked();
        
        uint256 index = existingIndex - 1;
        StakeInfo storage stakeInfo = userStakes[msg.sender][index];
        
        // Ensure user has enough tokens staked
        if (amount > stakeInfo.amount) revert InvalidAmount();
        
        // Update rewards before changing stake amount
        bool rewardsProcessed;
        (rewardsProcessed, ) = _processRewardsWithDailyLimit(msg.sender, index, MAX_DAYS_TO_PROCESS);
        if (!rewardsProcessed) {
            // in this case, the user will have to call syncUserRewards()
            // to process the rewards or call the function again until done is true

            // note that in this case, nothing has changed in the contract except the lastClaimTimestamp
            // of user's stakes, which should have been updated anyway at some point
            return false;
        }
        
        // Update daily token count if this is a rewarded token
        if (tokenId == rewardedTokenId) {
            uint256 nextDay = getCurrentDay() + 1;
            _updateDailyRewardedTokenCount(nextDay, amount, false);
            emit DailyTokenCountUpdated(nextDay, dailyRewardedTokenCount[nextDay]);
        }
        
        // Update stake amount or remove if all tokens unstaked
        if (amount == stakeInfo.amount) {
            // Remove stake by swapping with the last one and popping
            uint256 lastIndex = userStakes[msg.sender].length - 1;
            
            if (index != lastIndex) {
                // Swap with the last item
                StakeInfo memory lastStake = userStakes[msg.sender][lastIndex];
                userStakes[msg.sender][index] = lastStake;
                stakedTokenIndex[msg.sender][lastStake.contractAddress][lastStake.tokenId] = index + 1;
            }
            
            // Remove the last item
            userStakes[msg.sender].pop();
            stakedTokenIndex[msg.sender][contractAddress][tokenId] = 0;
            
            // Check if user has no more stakes
            if (userStakes[msg.sender].length == 0) {
                _removeStaker(msg.sender);
                // Clear lock timestamp when all stakes are removed
                userLockTimestamp[msg.sender] = 0;
            }
        } else {
            // Update stake amount
            stakeInfo.amount -= amount;
        }
        
        // Transfer tokens back to user
        IERC1155(contractAddress).safeTransferFrom(
            address(this),
            msg.sender,
            tokenId,
            amount,
            bytes("")
        );
        
        emit Unstaked(msg.sender, contractAddress, tokenId, amount, block.timestamp);
        return true;
    }


    /**
     * @notice Unstake all ERC1155 tokens for a user
     */
    function unstakeAll() external nonReentrant returns (bool done) {
        if (!isLockPeriodOver(msg.sender)) revert LockPeriodNotOver();
        
        StakeInfo[] storage stakes = userStakes[msg.sender];
        
        if (stakes.length == 0) revert NoStakedTokens();

        uint256 daysQuota = MAX_DAYS_TO_PROCESS;
        bool rewardsProcessed;
        
        // Update rewards for all stakes before unstaking
        for (uint256 i = 0; i < stakes.length; i++) {
            (rewardsProcessed, daysQuota) = _processRewardsWithDailyLimit(msg.sender, i, daysQuota);
            if (!rewardsProcessed) {
                // in this case, the user will have to call syncUserRewards()
                // to process the rewards or call the function again until done is true

                // note that in this case, nothing has changed in the contract except the lastClaimTimestamp
                // of user's stakes, which should have been updated anyway at some point
                return false;
            }
        }
        
        
        // Transfer all tokens back to user
        for (uint256 i = 0; i < stakes.length; i++) {
            StakeInfo memory stakeInfo = stakes[i];
            
            // Update daily token count if this is a rewarded token
            if (stakeInfo.tokenId == rewardedTokenId) {
                uint256 nextDay = getCurrentDay() + 1;
                _updateDailyRewardedTokenCount(nextDay, stakeInfo.amount, false);
                emit DailyTokenCountUpdated(nextDay, dailyRewardedTokenCount[nextDay]);
            }
            
            IERC1155(stakeInfo.contractAddress).safeTransferFrom(
                address(this),
                msg.sender,
                stakeInfo.tokenId,
                stakeInfo.amount,
                bytes("")
            );
            
            // Clear staking index mapping
            stakedTokenIndex[msg.sender][stakeInfo.contractAddress][stakeInfo.tokenId] = 0;
        }
        
        // Clear all stakes
        delete userStakes[msg.sender];
        
        // Remove from active stakers list
        _removeStaker(msg.sender);
        
        // Clear lock timestamp
        userLockTimestamp[msg.sender] = 0;
        
        emit UnstakedAll(msg.sender, block.timestamp);
        return true;
    }

    /**
     * @notice Helper function to update daily rewarded token count
     * @param day The day to update
     * @param amount The amount to add or subtract
     * @param isAddition Whether to add (true) or subtract (false) the amount
     */
    function _updateDailyRewardedTokenCount(uint256 day, uint256 amount, bool isAddition) internal {
        // Ensure token counts are current up to the requested day
        _syncTokenCountsUpToDay(day);
        
        // Update the token count for the specified day
        if (isAddition) {
            dailyRewardedTokenCount[day] += amount;
        } else {
            if (amount <= dailyRewardedTokenCount[day]) {
                dailyRewardedTokenCount[day] -= amount;
            } else {
                dailyRewardedTokenCount[day] = 0;
            }
        }
    }

    /**
     * @notice Synchronize token counts up to a specified day
     * @param targetDay The day to sync up to
     */
    function _syncTokenCountsUpToDay(uint256 targetDay) internal {
        // If we already have data for this day or later, no need to sync
        if (targetDay <= lastTokenCountUpdateDay) {
            return;
        }
        
        // If this is the first update ever, just set the last updated day
        // because there is no data to propagate 
        // (this is the first time the contract is being used for staking)
        if (lastTokenCountUpdateDay == 0) {
            lastTokenCountUpdateDay = targetDay;
            return;
        }
        
        // Start from the day after the last update
        uint256 startDay = lastTokenCountUpdateDay + 1;
        
        // Get the token count from the last updated day
        uint256 lastKnownCount = dailyRewardedTokenCount[lastTokenCountUpdateDay];
        
        // Propagate the last known count forward to all days up to the target day
        for (uint256 day = startDay; day <= targetDay; day++) {
            dailyRewardedTokenCount[day] = lastKnownCount;
        }
        
        // Update the last updated day
        lastTokenCountUpdateDay = targetDay;
    }

    /**
     * @notice Get the adjusted token count for a day, handling days with missing data
     * @param day The day to get the token count for
     * @return The token count for the day, using the previous day's count if missing
     */
    function _getAdjustedTokenCountForDay(uint256 day) internal view returns (uint256) {
        // If the requested day is after the last updated day, use the last known count
        if (day > lastTokenCountUpdateDay && lastTokenCountUpdateDay > 0) {
            return dailyRewardedTokenCount[lastTokenCountUpdateDay];
        }
        
        // Return the token count for the requested day (will be 0 if not set)
        return dailyRewardedTokenCount[day];
    }

    /**
     * @notice Claim rewards for all staked tokens
     */
    function claimRewards() external nonReentrant returns (bool done) {
        uint256 daysQuota = MAX_DAYS_TO_PROCESS;
        bool rewardsProcessed;
        StakeInfo[] storage stakes = userStakes[msg.sender];
        
        // Process rewards for any active stakes
        for (uint256 i = 0; i < stakes.length; i++) {
            (rewardsProcessed, daysQuota) = _processRewardsWithDailyLimit(msg.sender, i, daysQuota);
            if (!rewardsProcessed) {
                // in this case, the user will have to call syncUserRewards()
                // to process the rewards or call the function again until done is true

                // note that in this case, nothing has changed in the contract except the lastClaimTimestamp
                // of user's stakes, which should have been updated anyway at some point
                return false;
            }
        }
        
        uint256 rewardAmount = totalUserReward[msg.sender];
        
        // If no rewards to claim, just return success
        if (rewardAmount == 0) return true;
        
        totalUserReward[msg.sender] = 0;
        
        _transferReward(msg.sender, rewardAmount);
        
        emit RewardClaimed(msg.sender, rewardAmount, block.timestamp);
        return true;
    }


    /**
     * @notice Calculate the number of transactions required to fully sync a user's rewards
     * @param user The address of the user
     * @return The number of transactions needed to process all pending rewards
     */
    function requiredSyncTrxs(address user) external view returns (uint256) {
        StakeInfo[] storage stakes = userStakes[user];
        uint256 totalDays = 0;
        for (uint256 i = 0; i < stakes.length; i++) {
            StakeInfo storage stakeInfo = stakes[i];
            if (stakeInfo.tokenId != rewardedTokenId) {
                continue;
            }
            uint256 lastClaimDay = getDayForTimestamp(stakeInfo.lastClaimTimestamp);
            uint256 currentDay = getCurrentDay();
            if (currentDay - lastClaimDay > totalDays) {
                totalDays += currentDay - lastClaimDay;
            }
        }
        return (totalDays + MAX_DAYS_TO_PROCESS - 1) / MAX_DAYS_TO_PROCESS;
    }

    /**
     * @notice Process rewards for a user with a daily processing limit
     * @param user The address of the user
     * @return Whether the sync was fully completed
     */
    function syncUserRewards(address user) external returns (bool) {
        StakeInfo[] storage stakes = userStakes[user];
        uint256 daysQuota = MAX_DAYS_TO_PROCESS;
        bool rewardsProcessed;
        
        for (uint256 i = 0; i < stakes.length; i++) {
            (rewardsProcessed, daysQuota) = _processRewardsWithDailyLimit(user, i, daysQuota);
            if (!rewardsProcessed) {
                return false;
            }
        }
        return true;
    }

    /**
     * @notice Process rewards for a specific stake with a limit on days to process
     * @param user The address of the user
     * @param stakeIndex The index of the stake in the user's stakes array
     * @param daysQuota The maximum number of days to process in this transaction
     * @return done Whether all days were processed
     * @return remainingQuota The remaining days quota that can be used for other stakes
     */
    function _processRewardsWithDailyLimit(address user, uint256 stakeIndex, uint256 daysQuota) internal returns (bool, uint256) {
        StakeInfo storage stakeInfo = userStakes[user][stakeIndex];
        
        if (stakeInfo.tokenId != rewardedTokenId) {
            return (true, daysQuota);
        }

        if (block.timestamp <= stakeInfo.lastClaimTimestamp) {
            return (true, daysQuota);
        }

        uint256 lastClaimDay = getDayForTimestamp(stakeInfo.lastClaimTimestamp);
        uint256 currentDay = getCurrentDay();
        
        // Only rewards from the next day after last claim
        if (currentDay <= lastClaimDay) {
            return (true, daysQuota);
        }
        
        // Calculate reward for the unclaimed day
        uint256 reward = 0;
        bool done = false;
        if (currentDay - lastClaimDay <= daysQuota) {
            done = true;
        }
        
        // For each day, calculate the proportional share of the daily reward
        for (uint256 day = lastClaimDay + 1; day <= currentDay && daysQuota > 0; day++) {
            uint256 totalTokensStakedForDay = _getAdjustedTokenCountForDay(day);
            
            daysQuota --;
            
            // Update last claim timestamp
            stakeInfo.lastClaimTimestamp += DAY_IN_SECONDS;
            
            // Skip day with no staked tokens to avoid division by zero
            if (totalTokensStakedForDay == 0) {
                continue;
            }
            
            // Calculate the proportional share of the daily reward pool
            uint256 dailyReward = (rewardPerDay * stakeInfo.amount) / totalTokensStakedForDay;
            reward += dailyReward;
        }
        
        // Add to user's total reward
        totalUserReward[user] += reward;
        
        return (done, daysQuota);
    }

    /**
     * @notice Transfer reward to a user
     * @dev This is a placeholder for the actual reward transfer mechanism
     * @param user The address of the user to reward
     * @param amount The amount of reward to transfer
     */
    function _transferReward(address user, uint256 amount) internal {
        // Implement the reward transfer mechanism
        // This could be a token transfer, ETH transfer, or other mechanism
        // For now, we'll use a simple ETH transfer
        (bool success, ) = payable(user).call{value: amount}("");
        require(success, "Reward transfer failed");
    }

    /**
     * @notice Get all stakes for a user
     * @param user The address of the user
     * @return An array of StakeInfo structs
     */
    function getUserStakes(address user) external view returns (StakeInfo[] memory) {
        return userStakes[user];
    }

    /**
     * @notice Get the pending rewards for a user without claiming them
     * @param user The address of the user
     * @return The amount of pending rewards
     */
    function getPendingRewards(address user) external view returns (uint256) {
        StakeInfo[] storage stakes = userStakes[user];
        
        uint256 pendingReward = totalUserReward[user];
        uint256 currentDay = getCurrentDay();
        
        // Calculate additional pending rewards for each stake
        for (uint256 i = 0; i < stakes.length; i++) {
            StakeInfo storage stakeInfo = stakes[i];
            
            // Only calculate rewards for the specific token ID that's eligible
            if (stakeInfo.tokenId != rewardedTokenId) {
                continue;
            }
            
            uint256 lastClaimDay = getDayForTimestamp(stakeInfo.lastClaimTimestamp);
            
            // Only calculate rewards from the next day after last claim
            if (currentDay <= lastClaimDay) {
                continue;
            }
            
            // For each day, calculate the proportional share of the daily reward
            for (uint256 day = lastClaimDay + 1; day <= currentDay; day++) {
                uint256 totalTokensStakedForDay = _getAdjustedTokenCountForDay(day);
                
                // Skip day with no staked tokens to avoid division by zero
                if (totalTokensStakedForDay == 0) {
                    continue;
                }
                
                // Calculate the proportional share of the daily reward pool
                uint256 dailyReward = (rewardPerDay * stakeInfo.amount) / totalTokensStakedForDay;
                pendingReward += dailyReward;
            }
        }
        
        return pendingReward;
    }

    /**
     * @notice Update the reward per day
     * @param _rewardPerDay The new reward per day value
     */
    function setRewardPerDay(uint256 _rewardPerDay, uint256 _quota) external onlyOwner returns (bool done) {

        // Update all user stakes with the old reward rate until now
        bool updateCompleted = _updateAllStakesForAllUsers(_quota);
        if (!updateCompleted) {
            return false;
        }

        
        uint256 oldRewardPerDay = rewardPerDay;
        rewardPerDay = _rewardPerDay;
        
        emit RewardPerDayUpdated(oldRewardPerDay, _rewardPerDay, block.timestamp);
        return true;
    }

    /**
     * @notice Add a contract address to the whitelist
     * @param contractAddress The address to add
     */
    function addContractAddress(address contractAddress) external onlyOwner {
        if (contractAddress == address(0)) revert InvalidAddress();
        
        whitelistedContracts[contractAddress] = true;
        emit ContractAddressAdded(contractAddress, block.timestamp);
    }

    /**
     * @notice Remove a contract address from the whitelist
     * @param contractAddress The address to remove
     */
    function removeContractAddress(address contractAddress) external onlyOwner {
        if (contractAddress == address(0)) revert InvalidAddress();
        
        whitelistedContracts[contractAddress] = false;
        emit ContractAddressRemoved(contractAddress, block.timestamp);
    }

    /**
     * @notice Helper function to remove a staker from the allStakers array
     * @param staker The address of the staker to remove
     */
    function _removeStaker(address staker) internal {
        uint256 index = stakerIndex[staker];
        if (index == 0) return; // Not in the array
        
        unchecked {
            index = index - 1;
        }
        
        // If this is not the last element, swap with the last one
        uint256 lastIndex = allStakers.length - 1;
        if (index != lastIndex) {
            address lastStaker = allStakers[lastIndex];
            allStakers[index] = lastStaker;
            unchecked {
                stakerIndex[lastStaker] = index + 1;
            }
        }
        
        // Remove the last element
        allStakers.pop();
        stakerIndex[staker] = 0;
    }

    /**
     * @notice Update rewards for all stakes of all users
     * @dev This is called when reward rate changes to ensure fairness
     */
    function _updateAllStakesForAllUsers(uint256 _quota) internal returns (bool) {
        bool rewardsProcessed;

        // Iterate through all active stakers and update their rewards
        for (uint256 i = 0; i < allStakers.length; i++) {
            address staker = allStakers[i];
            
            // Update all stakes for this staker
            StakeInfo[] storage stakes = userStakes[staker];
            for (uint256 j = 0; j < stakes.length; j++) {
                (rewardsProcessed, _quota) = _processRewardsWithDailyLimit(staker, j, _quota);
                if (!rewardsProcessed) {
                    return false;
                }
            }
        }
        return true;
    }

    /**
     * @dev Function to receive ETH when msg.data is empty
     */
    receive() external payable {}

    /**
     * @dev Fallback function
     */
    fallback() external payable {}

    /**
     * @notice Withdraw ETH from the contract (owner only)
     * @param amount The amount to withdraw
     */
    function withdraw(uint256 amount) external onlyOwner {
        if (amount > address(this).balance) revert InsufficientBalance();
        (bool success, ) = payable(owner()).call{value: amount}("");
        if (!success) revert WithdrawalFailed();
    }

    /**
     * @notice Get the total amount of rewarded token staked for a specific day
     * @param day The day number to query
     * @return The total amount of rewarded tokens staked on that day
     */
    function getDailyRewardedTokenCount(uint256 day) external view returns (uint256) {
        return _getAdjustedTokenCountForDay(day);
    }

    /**
     * @notice Update the lock period days
     * @param _lockPeriodDays The new lock period in days
     */
    function setLockPeriodDays(uint256 _lockPeriodDays) external onlyOwner {
        if (_lockPeriodDays == 0) revert InvalidLockPeriod();
        uint256 oldLockPeriodDays = lockPeriodDays;
        lockPeriodDays = _lockPeriodDays;
        emit LockPeriodUpdated(oldLockPeriodDays, _lockPeriodDays, block.timestamp);
    }

    /**
     * @notice Get the remaining lock time for a user in seconds
     * @param user The address of the user to check
     * @return Remaining lock time in seconds (0 if lock period is over)
     */
    function getRemainingLockTime(address user) external view returns (uint256) {
        if (userLockTimestamp[user] == 0) return 0;
        uint256 unlockTime = userLockTimestamp[user] + (lockPeriodDays * DAY_IN_SECONDS);
        if (block.timestamp >= unlockTime) return 0;
        return unlockTime - block.timestamp;
    }
}