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

/**
 * @title Boopy Token (BOOPY)
 * @notice This smart contract is part of an experimental tokenomics model
 *         designed to make it easier to distribute tokens directly and fairly.
 *
 * @dev Boopy (BOOPY) Tokenomics:
 *      - 40% FREE distribution via 0 ETH transaction (airdrop)
 *      - 40% PUBLIC sale via >= 0.001 ETH
 *      - 20% SUPPLY claimed for Liquidity Pools
 *
 * The goal is to create an initial token distribution that is transparent,
 * community-first, and no presale, whitelisting, or centralized control.
 *
 * Created by: BoopyBase
 * Website: https://boopybase.xyz
 * Twitter/X: BoopyBase
 * Telegram: https://t.me/BoopyBase
 * Year: 2025
 */

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            uint256 c = a + b;
            require(c >= a, "Addition overflow");
            return c;
        }
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            require(b <= a, "Subtraction underflow");
            return a - b;
        }
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            if (a == 0) return 0;
            uint256 c = a * b;
            require(c / a == b, "Multiplication overflow");
            return c;
        }
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            require(b > 0, "Division by zero");
            return a / b;
        }
    }
}

contract BoopyToken {
    using SafeMath for uint256;

    string public constant name = "Boopy";
    string public constant symbol = "BOOPY";
    uint8 public constant decimals = 18;
    uint256 public totalSupply = 1_000_000_000 * 1e18;

    address public vault = 0xa33C89d0B972B9110A8E974A891e13b11948bf8f;

    uint256 public constant AIRDROP_AMOUNT = 5_000 * 1e18;
    uint256 public constant PUBLIC_AMOUNT = 50_000 * 1e18;
    uint256 public constant MIN_PUBLIC_ETH = 0.005 ether;

    uint256 public airdropSupply = totalSupply * 40 / 100; // 400M
    uint256 public publicSupply = totalSupply * 40 / 100;  // 400M
    uint256 public vaultSupply = totalSupply * 20 / 100;   // 200M

    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private allowed;
    mapping(address => bool) public hasClaimed;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);

    constructor() {
        balances[vault] = vaultSupply;
        balances[address(this)] = airdropSupply.add(publicSupply);
        emit Transfer(address(0), vault, vaultSupply);
        emit Transfer(address(0), address(this), airdropSupply.add(publicSupply));
    }

    // Token claiming logic
    receive() external payable {
        _distribute(msg.sender, msg.value);
        if (msg.value > 0) {
            payable(vault).transfer(msg.value);
        }
    }

    function claimBoopy() external {
        _distribute(msg.sender, 0);
    }

    function _distribute(address recipient, uint256 ethAmount) internal {
        require(!hasClaimed[recipient], "Already claimed");

        uint256 amount;
        if (ethAmount == 0) {
            require(airdropSupply >= AIRDROP_AMOUNT, "Airdrop exhausted");
            amount = AIRDROP_AMOUNT;
            airdropSupply = airdropSupply.sub(AIRDROP_AMOUNT);
        } else if (ethAmount >= MIN_PUBLIC_ETH) {
            require(publicSupply >= PUBLIC_AMOUNT, "Public sale exhausted");
            amount = PUBLIC_AMOUNT;
            publicSupply = publicSupply.sub(PUBLIC_AMOUNT);
        } else {
            revert("Invalid ETH amount");
        }

        hasClaimed[recipient] = true;
        _transfer(address(this), recipient, amount);
    }

    function withdrawUnsoldTokens() external {
        require(msg.sender == vault, "Only vault can withdraw");
        uint256 amount = balances[address(this)];
        _transfer(address(this), vault, amount);
    }

    // ERC20 functionality
    function balanceOf(address account) public view returns (uint256) {
        return balances[account];
    }

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

    function _transfer(address from, address to, uint256 value) internal {
        require(to != address(0), "Invalid address");
        require(balances[from] >= value, "Insufficient balance");

        balances[from] = balances[from].sub(value);
        balances[to] = balances[to].add(value);
        emit Transfer(from, to, value);
    }

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

    function allowance(address owner, address spender) public view returns (uint256) {
        return allowed[owner][spender];
    }

    function transferFrom(address from, address to, uint256 value) public returns (bool) {
        require(value <= allowed[from][msg.sender], "Allowance exceeded");
        allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
        _transfer(from, to, value);
        return true;
    }

    // Debug signature
    function _BOOPY_signature_hash() internal pure returns (bytes32) {
        return keccak256("BOOPY-by-BoopyBase-2025");
    }
}

{
  "compilationTarget": {
    "contracts/Boopy.sol": "BoopyToken"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "remappings": []
}