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

/**
 * ============================================================================
 * CRYPTCHUS DUAL-TOKEN ECOSYSTEM SMART CONTRACTS (BEP-20 + ERC-20)
 * 1. CryptChusToken (CHUS) — Tradable Appreciating Growth & Prediction Token
 * 2. CryptChusUSD (CHUSD)  — 1:1 USD-Pegged Stablecoin (Runs Alongside USDC & USDT)
 *
 * BINANCE SMART CHAIN (BNB Smart Chain / BEP-20 — Chain ID: 56 / 0x38):
 * - PancakeSwap V2 Router: 0x10ED43C718714eb63d5aA57B78B54704E256024E
 * - BSC Native Wrapped BNB (WBNB): 0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c
 * - BSC Official USDT (BEP-20):    0x55d398326f99059fF775485246999027B3197955
 * - BSC Official USDC (BEP-20):    0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d
 * - BscScan Block Explorer:        https://bscscan.com
 * ============================================================================
 */

interface IBEP20Minimal {
    function getOwner() external view returns (address);
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

/**
 * @title 1. CryptChus Coin (CHUS) — BEP-20 & ERC-20 Growth & Prediction Utility Token
 * @notice Compatible with Binance Smart Chain (PancakeSwap V2/V3), SushiSwap, Uniswap, Polygon, and Coinbase Base L2
 */
contract CryptChusToken {
    string public constant name = "CryptChus Coin";
    string public constant symbol = "CHUS";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    address public owner;
    address public predictionTreasury;
    address public constant PANCAKESWAP_V2_ROUTER = 0x10ED43C718714eb63d5aA57B78B54704E256024E;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event PredictionFeeBurned(address indexed burner, uint256 amountBurned, uint256 newTotalSupply);

    constructor(address _treasury) {
        owner = msg.sender;
        predictionTreasury = _treasury == address(0) ? msg.sender : _treasury;
        uint256 initialSupply = 10_000_000 * (10 ** uint256(decimals));
        totalSupply = initialSupply;
        balanceOf[predictionTreasury] = initialSupply;
        emit Transfer(address(0), predictionTreasury, initialSupply);
    }

    // BEP-20 Standard Required Method for Binance Smart Chain & PancakeSwap
    function getOwner() external view returns (address) {
        return owner;
    }

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

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

    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        uint256 currentAllowance = allowance[from][msg.sender];
        require(currentAllowance >= value, "BEP20/ERC20: insufficient allowance");
        unchecked {
            allowance[from][msg.sender] = currentAllowance - value;
        }
        return _transfer(from, to, value);
    }

    function burnPredictionFee(uint256 value) external returns (bool) {
        require(balanceOf[msg.sender] >= value, "BEP20/ERC20: burn amount exceeds balance");
        unchecked {
            balanceOf[msg.sender] -= value;
            totalSupply -= value;
        }
        emit Transfer(msg.sender, address(0), value);
        emit PredictionFeeBurned(msg.sender, value, totalSupply);
        return true;
    }

    function _transfer(address from, address to, uint256 value) internal returns (bool) {
        require(to != address(0), "BEP20/ERC20: transfer to zero address");
        require(balanceOf[from] >= value, "BEP20/ERC20: insufficient balance");
        unchecked {
            balanceOf[from] -= value;
            balanceOf[to] += value;
        }
        emit Transfer(from, to, value);
        return true;
    }
}

/**
 * @title 2. CryptChus USD (CHUSD) — Official BEP-20 & ERC-20 1:1 Dollar-Pegged Stablecoin
 * @notice Pegged 1:1 to $1.00 USD alongside BSC USDC (0x8AC7...80d) and BSC USDT (0x55d3...955) via Peg Stability Module (PSM)
 */
contract CryptChusUSD {
    string public constant name = "CryptChus USD Stablecoin";
    string public constant symbol = "CHUSD";
    uint8 public constant decimals = 18;
    uint256 public totalSupply;
    address public owner;
    address public reserveVault;
    address public usdcToken;
    address public usdtToken;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event StablecoinMinted1to1(address indexed user, string backingAsset, uint256 amountCHUSD);
    event StablecoinRedeemed1to1(address indexed user, string payoutAsset, uint256 amountCHUSD);

    constructor(address _reserveVault, address _usdc, address _usdt) {
        owner = msg.sender;
        reserveVault = _reserveVault == address(0) ? msg.sender : _reserveVault;
        // Defaults to Binance Smart Chain Official BEP-20 USDC & USDT if zero passed
        usdcToken = _usdc == address(0) ? 0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d : _usdc;
        usdtToken = _usdt == address(0) ? 0x55d398326f99059fF775485246999027B3197955 : _usdt;
        uint256 initialReserve = 10_000_000 * (10 ** uint256(decimals));
        totalSupply = initialReserve;
        balanceOf[reserveVault] = initialReserve;
        emit Transfer(address(0), reserveVault, initialReserve);
    }

    // BEP-20 Standard Required Method for Binance Smart Chain
    function getOwner() external view returns (address) {
        return owner;
    }

    function transfer(address to, uint256 value) external returns (bool) {
        require(to != address(0) && balanceOf[msg.sender] >= value, "CHUSD: invalid transfer");
        unchecked {
            balanceOf[msg.sender] -= value;
            balanceOf[to] += value;
        }
        emit Transfer(msg.sender, to, value);
        return true;
    }

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

    // 1:1 Peg Stability Minter with BEP-20 / ERC-20 USDC or USDT
    function mintWithStablecoin(address stableAsset, uint256 amount18) external returns (bool) {
        require(stableAsset == usdcToken || stableAsset == usdtToken, "Only USDC or USDT accepted for 1:1 PSM");
        IBEP20Minimal(stableAsset).transferFrom(msg.sender, reserveVault, amount18);
        totalSupply += amount18;
        balanceOf[msg.sender] += amount18;
        emit Transfer(address(0), msg.sender, amount18);
        emit StablecoinMinted1to1(msg.sender, stableAsset == usdcToken ? "USDC" : "USDT", amount18);
        return true;
    }
}