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

/**
 * @title Create.xyz Token
 * @dev A token with 5% tax on transfers, staking, wagering, and lottery features.
 * 
 * Website: https://www.create.xyz/
 * Discord: https://discord.gg/6g738f
 *
 * This token implements basic ERC20 functionality with added gaming features.
 * It includes a 5% transfer tax, staking with rewards, a wagering system,
 * and a simple lottery. Use responsibly and enjoy!
 */

contract TaxedToken {
    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    address public owner;
    address public taxWallet;
    uint256 private constant TAX_RATE = 5;

    struct Stake {
        uint256 amount;
        uint256 since;
    }

    mapping(address => Stake) public stakes;
    uint256 public totalStaked;
    uint256 public stakingRewardRate = 5; // 5% annual reward
    uint256 public minStakeDuration = 1 days;

    struct Wager {
        uint256 amount;
        uint256 outcome;
    }

    mapping(address => Wager) public wagers;
    uint256 public totalWagered;

    uint256 public lotteryPool;
    mapping(address => bool) public lotteryParticipants;
    address[] public participantList;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Staked(address indexed user, uint256 amount);
    event Unstaked(address indexed user, uint256 amount, uint256 reward);
    event WagerPlaced(address indexed user, uint256 amount, uint256 outcome);
    event WagerResolved(address indexed user, uint256 amount, bool won);
    event LotteryEntered(address indexed user);
    event LotteryWon(address indexed winner, uint256 amount);

    constructor(string memory _name, string memory _symbol, uint256 initialSupply, address initialTaxWallet) {
        name = _name;
        symbol = _symbol;
        owner = msg.sender;
        taxWallet = initialTaxWallet;
        _mint(msg.sender, initialSupply);
    }

    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "Invalid address");
        totalSupply += amount;
        balanceOf[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    function transfer(address to, uint256 amount) public returns (bool) {
        return _transfer(msg.sender, to, amount);
    }

    function approve(address spender, uint256 amount) public returns (bool) {
        allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public returns (bool) {
        require(allowance[from][msg.sender] >= amount, "Insufficient allowance");
        allowance[from][msg.sender] -= amount;
        return _transfer(from, to, amount);
    }

    function _transfer(address from, address to, uint256 amount) internal returns (bool) {
        require(from != address(0), "Transfer from zero address");
        require(to != address(0), "Transfer to zero address");
        require(balanceOf[from] >= amount, "Insufficient balance");

        uint256 taxAmount = (amount * TAX_RATE) / 100;
        uint256 transferAmount = amount - taxAmount;

        balanceOf[from] -= amount;
        balanceOf[taxWallet] += taxAmount;
        balanceOf[to] += transferAmount;

        emit Transfer(from, taxWallet, taxAmount);
        emit Transfer(from, to, transferAmount);
        return true;
    }

    function setTaxWallet(address newTaxWallet) external {
        require(msg.sender == owner, "Only owner can set tax wallet");
        require(newTaxWallet != address(0), "Invalid address");
        taxWallet = newTaxWallet;
    }

    function stake(uint256 amount) external {
        require(amount > 0, "Cannot stake 0");
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");

        if (stakes[msg.sender].amount > 0) {
            unstake();
        }

        _transfer(msg.sender, address(this), amount);
        stakes[msg.sender] = Stake(amount, block.timestamp);
        totalStaked += amount;

        emit Staked(msg.sender, amount);
    }

    function unstake() public {
        Stake memory userStake = stakes[msg.sender];
        require(userStake.amount > 0, "No active stake");
        require(block.timestamp >= userStake.since + minStakeDuration, "Minimum stake duration not met");

        uint256 reward = calculateStakingReward(msg.sender);
        uint256 total = userStake.amount + reward;

        delete stakes[msg.sender];
        totalStaked -= userStake.amount;

        _mint(address(this), reward);
        _transfer(address(this), msg.sender, total);

        emit Unstaked(msg.sender, userStake.amount, reward);
    }

    function calculateStakingReward(address user) public view returns (uint256) {
        Stake memory userStake = stakes[user];
        if (userStake.amount == 0) return 0;

        uint256 stakeDuration = block.timestamp - userStake.since;
        return (userStake.amount * stakingRewardRate * stakeDuration) / (365 days * 100);
    }

    function placeWager(uint256 amount, uint256 outcome) external {
        require(amount > 0, "Cannot wager 0");
        require(balanceOf[msg.sender] >= amount, "Insufficient balance");
        require(outcome < 2, "Invalid outcome");

        _transfer(msg.sender, address(this), amount);
        wagers[msg.sender] = Wager(amount, outcome);
        totalWagered += amount;

        emit WagerPlaced(msg.sender, amount, outcome);
    }

    function resolveWager(address user, uint256 result) external {
        require(msg.sender == owner, "Only owner can resolve wagers");
        Wager memory userWager = wagers[user];
        require(userWager.amount > 0, "No active wager");

        bool won = userWager.outcome == result;
        uint256 payout = won ? userWager.amount * 2 : 0;

        delete wagers[user];
        totalWagered -= userWager.amount;

        if (won) {
            _transfer(address(this), user, payout);
        }

        emit WagerResolved(user, payout, won);
    }

    function enterLottery() external {
        require(balanceOf[msg.sender] >= 100, "Insufficient balance for lottery entry");
        require(!lotteryParticipants[msg.sender], "Already entered lottery");

        _transfer(msg.sender, address(this), 100);
        lotteryParticipants[msg.sender] = true;
        participantList.push(msg.sender);
        lotteryPool += 100;

        emit LotteryEntered(msg.sender);
    }

    function drawLottery() external {
        require(msg.sender == owner, "Only owner can draw lottery");
        require(participantList.length > 0, "No participants in lottery");

        uint256 winnerIndex = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty))) % participantList.length;
        address winner = participantList[winnerIndex];

        uint256 prize = lotteryPool;
        lotteryPool = 0;

        for (uint256 i = 0; i < participantList.length; i++) {
            delete lotteryParticipants[participantList[i]];
        }
        delete participantList;

        _transfer(address(this), winner, prize);

        emit LotteryWon(winner, prize);
    }

    // Advanced utility functions (for future expansion)

    function arithmeticOperation(uint256 a, uint256 b) public pure returns (uint256) {
        return a + b;
    }

    function generateHash(string memory input) public pure returns (bytes32) {
        return keccak256(abi.encodePacked(input));
    }

    function getAddressBalance(address addr) public view returns (uint256) {
        return addr.balance;
    }

    struct UserProfile {
        uint256 id;
        string name;
        bool isActive;
    }

    mapping(address => UserProfile) private userProfiles;

    function createUserProfile(uint256 id, string memory name) public {
        userProfiles[msg.sender] = UserProfile(id, name, true);
    }

    function getUserProfile() public view returns (UserProfile memory) {
        return userProfiles[msg.sender];
    }

    uint256[] private dataStore;

    function addToDataStore(uint256 number) public {
        dataStore.push(number);
    }

    function getDataStore() public view returns (uint256[] memory) {
        return dataStore;
    }

    event SystemNotification(address indexed user, uint256 value, string message);

    function emitSystemNotification(uint256 value, string memory message) public {
        emit SystemNotification(msg.sender, value, message);
    }

    function calculateArraySum(uint256[] memory numbers) public pure returns (uint256) {
        uint256 sum = 0;
        for (uint256 i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
        return sum;
    }

    function getTotalBalanceOfAddresses(address[] memory addresses) public view returns (uint256) {
        uint256 totalBalance = 0;
        for (uint256 i = 0; i < addresses.length; i++) {
            totalBalance += addresses[i].balance;
        }
        return totalBalance;
    }

    // ... more advanced utility functions ...
}

{
  "compilationTarget": {
    "TaxedToken.sol": "TaxedToken"
  },
  "evmVersion": "cancun",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}