// SPDX-License-Identifier: MIT

pragma solidity ^0.8.25;

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

contract Charlie BitMe Coin is ERC20, Ownable {

struct StakingInfo {
uint256 amount;
uint256 startTime;
uint256 lastRewardTime;
}

mapping(address => StakingInfo) public stakings;

uint256 public constant stakingMinAmount = 5000 * (10 ** 18); // Updated staking minimum to $50.00 worth of coins
uint256 public constant stakingDuration = 30 days;
uint256 public constant rewardRate = 100; // 100 CBME coins per day per 5000 staked coins
uint256 public constant maxDumpingLimit = 5; // 5% dumping limit within 24 hours
uint256 public burnPercentage = 10; // 10% of earned rewards will be burned

mapping(address => uint256) public lastUnstakeTime;

event Staked(address indexed user, uint256 amount);
event Unstaked(address indexed user, uint256 amount);
event RewardsClaimed(address indexed user, uint256 amount);
event CoinsBurned(uint256 amount);

constructor() ERC20("Charlie BitMe Coin", "CHRLE") Ownable(msg.sender) {
_mint(msg.sender, 10000000000e18);
}

function stake(address _user, uint256 _amount) external {
require(_amount >= stakingMinAmount, "Amount is below minimum");
require(balanceOf(_user) >= _amount, "Insufficient balance");

if (stakings[_user].amount == 0) {
stakings[_user].startTime = block.timestamp;
}

stakings[_user].amount += _amount;
stakings[_user].lastRewardTime = block.timestamp;

// Burn the staked coins
_burn(_user, _amount);

emit Staked(_user, _amount);
}

function unstake(uint256 _amount) external {
require(_amount <= stakings[msg.sender].amount, "Amount exceeds staked balance");
require(canUnstake(msg.sender, _amount), "Dumping limit exceeded");

uint256 reward = calculateReward(msg.sender);
uint256 burnAmount = (reward * burnPercentage) / 100; // Calculate the amount to burn

// Deduct the burn amount from the reward
uint256 netReward = reward - burnAmount;

stakings[msg.sender].amount -= _amount;
lastUnstakeTime[msg.sender] = block.timestamp;

// Transfer the staked amount and net reward to the user
_transfer(address(this), msg.sender, _amount + netReward);

// Burn the specified percentage of the reward
_burn(address(this), burnAmount);

emit Unstaked(msg.sender, _amount);
emit RewardsClaimed(msg.sender, netReward);
}

function calculateReward(address _user) internal view returns (uint256) {
StakingInfo memory info = stakings[_user];
uint256 stakingTime = block.timestamp - info.lastRewardTime;
return (info.amount * stakingTime * rewardRate) / (stakingDuration * 1 days * 100);
}

function canUnstake(address _user, uint256 _amount) internal view returns (bool) {
uint256 lastUnstake = lastUnstakeTime[_user];
if (lastUnstake == 0) {
return true;
}

uint256 timeSinceLastUnstake = block.timestamp - lastUnstake;
uint256 maxDumpingAmount = (stakingDuration * stakings[_user].amount * maxDumpingLimit) / (1 days * 100);
return (_amount <= maxDumpingAmount) && (timeSinceLastUnstake >= 1 days);
}

function burn(uint256 amount) public {
_burn(address(0), amount);
emit CoinsBurned(amount);
}
}