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

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title RewardToken
 * @author Your Name
 * @notice An ERC20 token used as a reward for the staking contract.
 * @dev This token is mintable only by the owner of the contract.
 */
contract RewardToken is ERC20, Ownable {
    /**
     * @notice Custom error for when a non-owner tries to mint.
     */
    error RewardToken__NotOwner();

    /**
     * @notice Custom error for minting to the zero address.
     */
    error RewardToken__MintToZeroAddress();

    /**
     * @notice Emitted when tokens are minted.
     * @param to The address that received the tokens.
     * @param amount The amount of tokens minted.
     */
    event TokensMinted(address indexed to, uint256 amount);

    /**
     * @dev Sets the initial owner, token name, and symbol.
     * @param _initialOwner The address that will be the owner of the contract.
     */
     /constructor函数仅在合约创建时执行一次
    constructor(address _initialOwner) ERC20("Reward Token", "RWT") Ownable(_initialOwner) {}

    /**
     * @notice Mints new tokens and assigns them to an account.
     * @dev Can only be called by the contract owner.
     * @param to The address to mint tokens to.
     * @param amount The amount of tokens to mint.
     */
    function mint(address to, uint256 amount) public onlyOwner {
	    /address(0)是指一个空地址
	    
        if (to == address(0)) {
            revert RewardToken__MintToZeroAddress();
        }
		/*_mint是ERC20内置的一个函数，用于发行代币，在接收者 `to` 的地址上增加 
		amount数量的代币余额。*/
        _mint(to, amount);
        emit TokensMinted(to, amount);
    }
}

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

import {Test, console} from "forge-std/Test.sol";
import {RewardToken} from "src/RewardToken.sol";

/**
 * @title RewardToken Test Suite
 * @notice Tests for the RewardToken contract.
 */
contract RewardTokenTest is Test {
    RewardToken public rewardToken;
    address public owner;
    address public user;

    /**
     * @notice Sets up the testing environment before each test case.
     */
    function setUp() public {
        // Create an owner and a regular user for tests
        owner = makeAddr("owner");
        user = makeAddr("user");

        // Deploy the RewardToken contract, setting 'owner' as the initial owner
        vm.startPrank(owner);
        rewardToken = new RewardToken(owner);
        vm.stopPrank();
    }

    /*//////////////////////////////////////////////////////////////
                            CONSTRUCTOR TESTS
    //////////////////////////////////////////////////////////////*/

    function test_InitialState() public {
        assertEq(rewardToken.name(), "Reward Token", "Token name should be 'Reward Token'");
        assertEq(rewardToken.symbol(), "RWT", "Token symbol should be 'RWT'");
        assertEq(rewardToken.owner(), owner, "Initial owner should be set correctly");
        assertEq(rewardToken.totalSupply(), 0, "Initial total supply should be 0");
    }

    /*//////////////////////////////////////////////////////////////
                                MINT TESTS
    //////////////////////////////////////////////////////////////*/

    function test_Mint_Success() public {
        uint256 mintAmount = 100 ether;

        vm.prank(owner); // The owner is the one calling mint
        rewardToken.mint(user, mintAmount);

        assertEq(rewardToken.balanceOf(user), mintAmount, "User balance should be updated after mint");
        assertEq(rewardToken.totalSupply(), mintAmount, "Total supply should be updated after mint");
    }

    function testFuzz_Mint_Success(uint96 amount) public {
        // We use uint96 for fuzzing to get a good range of values without easily overflowing.
        // Let's assume 0 is not a valid mint amount for this specific test logic.
        vm.assume(amount > 0);
        
        uint256 totalSupplyBefore = rewardToken.totalSupply();
        uint256 userBalanceBefore = rewardToken.balanceOf(user);

        vm.prank(owner);
        rewardToken.mint(user, amount);

        assertEq(rewardToken.balanceOf(user), userBalanceBefore + amount, "User balance should increase by amount");
        assertEq(rewardToken.totalSupply(), totalSupplyBefore + amount, "Total supply should increase by amount");
    }

    function test_RevertWhen_MintByNonOwner() public {
        uint256 mintAmount = 100 ether;

        // We expect this call to revert with Ownable's specific error message.
        // The error signature is `OwnableUnauthorizedAccount(address account)`.
        vm.expectRevert(abi.encodeWithSelector(bytes4(keccak256("OwnableUnauthorizedAccount(address)")), user));
        
        // 'user' (a non-owner) tries to call mint
        vm.prank(user);
        rewardToken.mint(user, mintAmount);
    }

    function test_RevertWhen_MintToZeroAddress() public {
        uint256 mintAmount = 100 ether;

        // We expect this to revert with our custom error.
        vm.expectRevert(RewardToken.RewardToken__MintToZeroAddress.selector);

        vm.prank(owner);
        rewardToken.mint(address(0), mintAmount);
    }

    function test_Event_TokensMinted() public {
        uint256 mintAmount = 100 ether;

        // Expect an event to be emitted.
        // We check:
        // 1. The topic at index 1 is the 'to' address (indexed parameter).
        // 2. The event is emitted from the rewardToken contract address.
        vm.expectEmit(true, false, false, true);
        emit RewardToken.TokensMinted(user, mintAmount);

        vm.prank(owner);
        rewardToken.mint(user, mintAmount);
    }
}