Creating a Season-Based Reward System

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

import "./VoucherRedeemContract.sol";
import "./SeasonManager.sol";

contract SeasonRedemptionManager {
    address public owner;
    SeasonManager public seasonManager;
    VoucherRedeemContract public redeemContract;
    
    // Mapping from season ID to redemption token address
    mapping(uint256 => address) public seasonRedemptionTokens;
    
    // Mapping from season ID to conversion rate
    mapping(uint256 => uint256) public seasonConversionRates;
    
    // Mapping from season ID to redemption deadline (0 means no deadline)
    mapping(uint256 => uint256) public seasonRedemptionDeadlines;
    
    event RedemptionRuleSet(uint256 seasonId, address redemptionToken, uint256 conversionRate, uint256 deadline);
    
    constructor(address _seasonManager, address _redeemContract) {
        owner = msg.sender;
        seasonManager = SeasonManager(_seasonManager);
        redeemContract = VoucherRedeemContract(_redeemContract);
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }
    
    function setSeasonRedemptionRule(
        uint256 seasonId,
        address redemptionToken,
        uint256 conversionRate,
        uint256 deadline
    ) external onlyOwner {
        address voucherAddress = seasonManager.getSeasonVoucher(seasonId);
        require(voucherAddress != address(0), "Season does not exist");
        
        // Store the redemption rules
        seasonRedemptionTokens[seasonId] = redemptionToken;
        seasonConversionRates[seasonId] = conversionRate;
        seasonRedemptionDeadlines[seasonId] = deadline;
        
        // Configure the redemption contract
        redeemContract.addSupportedVoucher(voucherAddress, redemptionToken, conversionRate);
        
        emit RedemptionRuleSet(seasonId, redemptionToken, conversionRate, deadline);
    }
    
    function updateSeasonConversionRate(uint256 seasonId, uint256 newConversionRate) external onlyOwner {
        address voucherAddress = seasonManager.getSeasonVoucher(seasonId);
        require(voucherAddress != address(0), "Season does not exist");
        
        // Update the conversion rate
        seasonConversionRates[seasonId] = newConversionRate;
        
        // Update the redemption contract
        redeemContract.updateConversionRate(voucherAddress, newConversionRate);
        
        emit RedemptionRuleSet(
            seasonId,
            seasonRedemptionTokens[seasonId],
            newConversionRate,
            seasonRedemptionDeadlines[seasonId]
        );
    }
    
    function updateSeasonRedemptionDeadline(uint256 seasonId, uint256 newDeadline) external onlyOwner {
        address voucherAddress = seasonManager.getSeasonVoucher(seasonId);
        require(voucherAddress != address(0), "Season does not exist");
        
        // Update the deadline
        seasonRedemptionDeadlines[seasonId] = newDeadline;
        
        emit RedemptionRuleSet(
            seasonId,
            seasonRedemptionTokens[seasonId],
            seasonConversionRates[seasonId],
            newDeadline
        );
    }
    
    function canRedeem(uint256 seasonId) public view returns (bool) {
        uint256 deadline = seasonRedemptionDeadlines[seasonId];
        if (deadline == 0) {
            return true; // No deadline means redemption is always allowed
        }
        
        return block.timestamp <= deadline;
    }
}

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

import "./TapAntsVoucher.sol";
import "./SeasonManager.sol";

contract VoucherDistributor {
    address public owner;
    SeasonManager public seasonManager;
    
    // Mapping to track user activities
    mapping(address => mapping(string => uint256)) public userActivities;
    
    // Mapping to track vouchers already claimed for activities
    mapping(address => mapping(string => bool)) public activityClaimed;
    
    event ActivityRecorded(address user, string activityId, uint256 value);
    event VouchersDistributed(address user, uint256 seasonId, uint256 amount);
    
    constructor(address _seasonManager) {
        owner = msg.sender;
        seasonManager = SeasonManager(_seasonManager);
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }
    
    // Record a user activity (called by authorized backend)
    function recordActivity(address user, string calldata activityId, uint256 value) external onlyOwner {
        userActivities[user][activityId] = value;
        emit ActivityRecorded(user, activityId, value);
    }
    
    // Distribute vouchers based on a specific activity
    function distributeVouchersForActivity(
        address user,
        string calldata activityId,
        uint256 amount
    ) external onlyOwner {
        require(!activityClaimed[user][activityId], "Activity already claimed");
        require(userActivities[user][activityId] > 0, "No activity recorded");
        
        // Mark activity as claimed
        activityClaimed[user][activityId] = true;
        
        // Get the current season voucher
        uint256 currentSeasonId = seasonManager.currentSeasonId();
        address voucherAddress = seasonManager.getCurrentSeasonVoucher();
        
        // Mint vouchers to the user
        TapAntsVoucher voucher = TapAntsVoucher(voucherAddress);
        voucher.mint(user, amount);
        
        emit VouchersDistributed(user, currentSeasonId, amount);
    }
    
    // Batch distribute vouchers to multiple users
    function batchDistributeVouchers(
        address[] calldata users,
        uint256[] calldata amounts
    ) external onlyOwner {
        require(users.length == amounts.length, "Arrays length mismatch");
        
        uint256 currentSeasonId = seasonManager.currentSeasonId();
        address voucherAddress = seasonManager.getCurrentSeasonVoucher();
        TapAntsVoucher voucher = TapAntsVoucher(voucherAddress);
        
        for (uint256 i = 0; i < users.length; i++) {
            voucher.mint(users[i], amounts[i]);
            emit VouchersDistributed(users[i], currentSeasonId, amounts[i]);
        }
    }
}

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

import "./SeasonManager.sol";
import "./SeasonRedemptionManager.sol";
import "./TapAntsVoucher.sol";

contract SeasonTransitionManager {
    address public owner;
    SeasonManager public seasonManager;
    SeasonRedemptionManager public redemptionManager;
    
    // Mapping to track if a user has migrated vouchers from one season to another
    mapping(address => mapping(uint256 => mapping(uint256 => bool))) public seasonMigrated;
    
    event SeasonTransitioned(uint256 oldSeasonId, uint256 newSeasonId);
    event VouchersMigrated(address user, uint256 fromSeasonId, uint256 toSeasonId, uint256 amount);
    
    constructor(address _seasonManager, address _redemptionManager) {
        owner = msg.sender;
        seasonManager = SeasonManager(_seasonManager);
        redemptionManager = SeasonRedemptionManager(_redemptionManager);
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }
    
    // Transition to a new season
    function transitionToNewSeason(string calldata name, string calldata symbol) external onlyOwner {
        uint256 oldSeasonId = seasonManager.currentSeasonId();
        
        // Create a new season
        seasonManager.createNewSeason(name, symbol);
        
        uint256 newSeasonId = seasonManager.currentSeasonId();
        
        emit SeasonTransitioned(oldSeasonId, newSeasonId);
    }
    
    // Allow users to migrate unredeemed vouchers from a previous season to the current season
    function migrateVouchers(uint256 fromSeasonId, uint256 amount) external {
        address user = msg.sender;
        uint256 currentSeasonId = seasonManager.currentSeasonId();
        
        // Check if the user has already migrated from this season
        require(!seasonMigrated[user][fromSeasonId][currentSeasonId], "Already migrated");
        
        // Check if the season can still be redeemed
        require(!redemptionManager.canRedeem(fromSeasonId), "Season can still be redeemed");
        
        // Get the voucher contracts
        address fromVoucherAddress = seasonManager.getSeasonVoucher(fromSeasonId);
        address toVoucherAddress = seasonManager.getCurrentSeasonVoucher();
        
        require(fromVoucherAddress != address(0), "From season does not exist");
        require(toVoucherAddress != address(0), "To season does not exist");
        
        TapAntsVoucher fromVoucher = TapAntsVoucher(fromVoucherAddress);
        TapAntsVoucher toVoucher = TapAntsVoucher(toVoucherAddress);
        
        // Check if the user has enough vouchers
        uint256 balance = fromVoucher.balanceOf(user);
        require(balance >= amount, "Insufficient vouchers");
        
        // Burn vouchers from the old season
        fromVoucher.burn(user, amount, "");
        
        // Apply migration rate (e.g., 80% of original value)
        uint256 migrationRate = 80; // 80%
        uint256 migratedAmount = (amount * migrationRate) / 100;
        
        // Mint vouchers for the new season
        toVoucher.mint(user, migratedAmount);
        
        // Mark as migrated
        seasonMigrated[user][fromSeasonId][currentSeasonId] = true;
        
        emit VouchersMigrated(user, fromSeasonId, currentSeasonId, migratedAmount);
    }
    
    // Allow admin to set migration rates between seasons
    function setMigrationRate(uint256 fromSeasonId, uint256 toSeasonId, uint256 rate) external onlyOwner {
        // Implementation for setting custom migration rates between specific seasons
    }
}