// SPDX-License-Identifier: MIT

pragma solidity ^0.8.9;

//import "hardhat/console.sol";

/**
 * @title BSC50
 * @dev Implementation of the BSC50 interface.
 * BSC50 is a derivative of ERC20 which aims to integrate a liquidity pool on the token in order to enable native swaps, notably to reduce gas consumption.
 */

// Events interface for BSC50
interface IBSC50 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event AddLiquidity(uint32 _blockToUnlockLiquidity, uint256 value);
    event RemoveLiquidity(uint256 value);

    event FairMinted(address indexed to, uint256 amount, uint256 ethAmount);

    event FairLaunch(address indexed to, uint256 amount, uint256 ethAmount);
    event burnEvent(address indexed to, uint256 value);

    event claimStakeEvent(address indexed to, uint256 value);

    event Approval(address owner, address spender, uint256 amount);

    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out
    );
}

abstract contract BSC50V3 is IBSC50 {
    //bsc50 is IBSC50
    mapping(address account => uint256) private _balances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 public _maxWallet;
    uint32 public blockToUnlockLiquidity;

    address public owner;
    address public liquidityProvider;

    bool public tradingEnable;

    bool public liquidityAdded;

    bool public maxWalletEnable;

    uint256 public presaleAmount;

    bool public presaleEnable = false;

    mapping(address account => uint32) private lastTransaction;

    mapping(address => bool) public preSaleAccount;

    uint256 public preSaleTokenUnitAmount;

    uint256 public preSaleEthAmount;

    uint256 public preSaleLimitAmount;

    //is in pre sale mode
    bool public isInPreSale;

    uint256 public currentPreSaleAmount;

    //buy tax rate
    uint256 public buyTaxRate;

    //sell tax rate
    uint256 public sellTaxRate;

    //buy tax amount sum
    uint256 public buyTaxAmountSum;

    //sell tax amount sum
    uint256 public sellTaxAmountSum;

    address public stakeAddress;

    address public taxWalletProvider;

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }

    modifier onlyLiquidityProvider() {
        require(
            msg.sender == liquidityProvider,
            "You are not the liquidity provider"
        );
        _;
    }

    /**
     * @dev Sets the values for {name}, {symbol} and {totalSupply}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(
        string memory name_,
        string memory symbol_,
        uint256 totalSupply_,

        uint256 preSalelimitAmount_,

        uint256 preSaleAmount_,
        
        uint256 preSaleTokenPct_
    ) {
        _name = name_;

        _symbol = symbol_;

        _totalSupply = totalSupply_;

        _maxWallet = totalSupply_ / 500;

        owner = msg.sender;

        liquidityProvider = owner;

        taxWalletProvider = owner;

        tradingEnable = false;

        maxWalletEnable = false;

        //The Genesis contract requires a 40% reserve,
        //with 10% allocated to staking liquidity pools and 10% allocated to the market.

        // _balances[msg.sender] = (totalSupply_ * reserveTokenPct_) / 100;

        presaleAmount = (_totalSupply * preSaleTokenPct_) / 1000;

        _balances[address(this)] = 2 * presaleAmount;

        _balances[msg.sender] = _totalSupply - _balances[address(this)];

        liquidityAdded = false;

        //is in PreSale
        isInPreSale = true;

        //
        preSaleLimitAmount = preSalelimitAmount_;

        //
        preSaleEthAmount = preSaleAmount_;

        //
        preSaleTokenUnitAmount =
            presaleAmount /
            (preSalelimitAmount_ / preSaleAmount_);

        
        //buy tax 0%
        buyTaxRate = 0;

        //sell tax 2%
        sellTaxRate = 20;

        //buy tax sum
        buyTaxAmountSum = 0;

        //sell tax sum
        sellTaxAmountSum = 0;
    }

    /**
     * @dev Sends the presale amount to the investors
     */
    // function presale(address[] memory _investors) public onlyOwner {
    //     require(presaleEnable == false, "Presale already enabled");
    //     uint256 _amount = presaleAmount / _investors.length;
    //     for (uint256 i = 0; i < _investors.length; i++) {
    //         _balances[_investors[i]] += _amount;
    //     }
    //     presaleEnable = true;
    // }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     */

    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - the caller must have a balance of at least `value`.
     * - if the receiver is the contract, the caller must send the amount of tokens to sell
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        // sell or transfer

        if (to == address(this)) {
            require(
                isInPreSale == false,
                "You can't transfer in pre-sale mode"
            );

            sell(value);
        } else {
            _transfer(msg.sender, to, value);
        }
        return true;
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively burns if `to` is the zero address.
     * All customizations to transfers and burns should be done by overriding this function.
     * This function includes MEV protection, which prevents the same address from making two transactions in the same block.(lastTransaction)
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal virtual {
        // require(
        //     lastTransaction[msg.sender] < block.number ,
        //     "You can't make two transactions in the 2 block"
        // );

        //  require(from != address(0), "ERC20: transfer from the zero address");

       // lastTransaction[msg.sender] = uint32(block.number) + 2;

        // console.log("from", from);
        // console.log("to", to);

        require(
            _balances[from] >= value,
            "ERC20: transfer amount exceeds balance"
        );

        unchecked {
            _balances[from] = _balances[from] - value;
        }

        if (to == address(0)) {
            unchecked {
                _totalSupply -= value;
            }
        } else {
            unchecked {
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    function allowance(
        address ownerAddress,
        address spender
    ) public view virtual returns (uint256) {
        return _allowances[ownerAddress][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(
        address spender,
        uint256 amount
    ) public virtual returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][msg.sender];
        require(
            currentAllowance >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        _approve(sender, msg.sender, currentAllowance - amount);

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        _approve(
            msg.sender,
            spender,
            _allowances[msg.sender][spender] + addedValue
        );
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        uint256 currentAllowance = _allowances[msg.sender][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        _approve(msg.sender, spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Returns the amount of ETH and tokens in the contract, used for trading.
     */
    function getReserves() public view returns (uint256, uint256) {
        return (address(this).balance, _balances[address(this)]);
    }

    function getCurrentPrice() public view returns (uint256) {
        return ((address(this).balance * 10 ** 18) / _balances[address(this)]);
    }

    /**
     * @dev Enables or disables trading.
     * @param _tradingEnable: true to enable trading, false to disable trading.
     * onlyOwner modifier
     */
    function enableTrading(bool _tradingEnable) external onlyOwner {
        tradingEnable = _tradingEnable;
    }

    /**
     * @dev Enables or disables the max wallet.
     * @param _maxWalletEnable: true to enable max wallet, false to disable max wallet.
     * onlyOwner modifier
     */
    function enableMaxWallet(bool _maxWalletEnable) external onlyOwner {
        maxWalletEnable = _maxWalletEnable;
    }

    /**
     * @dev Sets the max wallet.
     * @param _maxWallet_: the new max wallet.
     * onlyOwner modifier
     */
    function setMaxWallet(uint256 _maxWallet_) external onlyOwner {
        _maxWallet = _maxWallet_;
    }

    /**
     * @dev Transfers the ownership of the contract to zero address
     * onlyOwner modifier
     */
    function renounceOwnership() external onlyOwner {
        owner = address(0);
    }

    /**
     * @dev Adds liquidity to the contract.
     * @param _blockToUnlockLiquidity: the block number to unlock the liquidity.
     * value: the amount of ETH to add to the liquidity.
     * onlyOwner modifier
     */
    function addLiquidity(uint32 _blockToUnlockLiquidity) internal {
        require(liquidityAdded == false, "Liquidity already added");

        require(
            currentPreSaleAmount >= preSaleLimitAmount,
            "preSaleAmount not reached"
        );

        liquidityAdded = true;

        // require(msg.value > 0, "No ETH sent");
        // require(block.number < _blockToUnlockLiquidity, "Block number too low");

        blockToUnlockLiquidity = _blockToUnlockLiquidity;
        tradingEnable = true;
        isInPreSale = false;

        emit AddLiquidity(_blockToUnlockLiquidity, currentPreSaleAmount);
    }

    /**
     * @dev Removes liquidity from the contract.
     * onlyLiquidityProvider modifier
     */
    function removeLiquidity() public onlyLiquidityProvider {
        require(block.number > blockToUnlockLiquidity, "Liquidity locked");

        tradingEnable = false;

        payable(msg.sender).transfer(address(this).balance);

        emit RemoveLiquidity(address(this).balance);
    }

    function setTaxProvider(address provider) public onlyLiquidityProvider {
        taxWalletProvider = provider;
    }

    function setTaxBuyTax(uint256 sellTax_) public onlyLiquidityProvider {
        sellTaxRate = sellTax_;
    }

    function setTaxSellTax(uint256 sellTax_) public onlyLiquidityProvider {
        sellTaxRate = sellTax_;
    }

    function setLiquidityProvider(
        address provider_
    ) public onlyLiquidityProvider {
        liquidityProvider = provider_;
    }

    function _approve(
        address owner_,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner_ != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner_][spender] = amount;
        emit Approval(owner_, spender, amount);
    }

    /**
     * @dev Extends the liquidity lock, only if the new block number is higher than the current one.
     * @param _blockToUnlockLiquidity: the new block number to unlock the liquidity.
     * onlyLiquidityProvider modifier
     */
    function extendLiquidityLock(
        uint32 _blockToUnlockLiquidity
    ) public onlyLiquidityProvider {
        require(
            blockToUnlockLiquidity < _blockToUnlockLiquidity,
            "You can't shorten duration"
        );

        blockToUnlockLiquidity = _blockToUnlockLiquidity;
    }

    /**
     * @dev Estimates the amount of tokens or ETH to receive when buying or selling.
     * @param value: the amount of ETH or tokens to swap.
     * @param _buy: true if buying, false if selling.
     */
    function getAmountOut(
        uint256 value,
        bool _buy
    ) public view returns (uint256) {
        (uint256 reserveETH, uint256 reserveToken) = getReserves();

        if (_buy) {
            return (value * reserveToken) / (reserveETH + value);
        } else {
            return (value * reserveETH) / (reserveToken + value);
        }
    }

    /**
     * @dev Buys tokens with ETH.
     * internal function
     */
    function buy() internal {
        require(tradingEnable, "Trading not enable");

        uint256 buyTax = (msg.value * buyTaxRate) / 1000;

        // console.log("buy tax", buyTax);

        // console.log("_balances[address(this)]", _balances[address(this)]);

        // console.log("(address(this).balance", address(this).balance);

        buyTaxAmountSum = buyTaxAmountSum + buyTax;

        uint256 token_amount = ((msg.value - buyTax) *
            (_balances[address(this)])) / ((address(this).balance));

        if (maxWalletEnable) {
            require(
                token_amount + _balances[msg.sender] <= _maxWallet,
                "Max wallet exceeded"
            );
        }

        _transfer(address(this), msg.sender, token_amount);

        //pay buy tax

        if(buyTax>0){
            payable(taxWalletProvider).transfer(buyTax);
        }

       // console.log("buy token Amount ", msg.value - buyTax, token_amount);

        emit Swap(msg.sender, msg.value - buyTax, 0, 0, token_amount);
    }

    /**
     * @dev Sells tokens for ETH.
     * internal function
     */
    function sell(uint256 sell_amount) internal {


        require(tradingEnable, "Trading not enable");
        require(sell_amount > 0, "sell amount max great than zero");

        uint256 sellTax = (sell_amount * sellTaxRate) / 1000;

        sellTaxAmountSum += sellTax;

        uint256 ethAmount = ((sell_amount - sellTax) *
            (address(this).balance)) /
            (_balances[address(this)] + sell_amount - sellTax);

        require(ethAmount > 0, "Sell amount too low");
        require(
            address(this).balance >= ethAmount,
            "Insufficient ETH in reserves"
        );

        _transfer(msg.sender, address(this), sell_amount);

        payable(msg.sender).transfer(ethAmount);

        this.transfer(taxWalletProvider, sellTax);

      //  console.log("sel token Amount ", ethAmount, sell_amount - sellTax);

        emit Swap(msg.sender, 0, sell_amount - sellTax, ethAmount, 0);
    }

    // function _burn() external {
    //     if (sellTaxAmountSum > 0) {
    //         _transfer(address(this), address(0x0), sellTaxAmountSum);

    //         emit burnEvent(address(0x0), sellTaxAmountSum);

    //         sellTaxAmountSum = 0;
    //     }
    // }

    /**
     * @dev Fallback function to buy tokens with ETH.
     */
    receive() external payable {
        if (isInPreSale) {
            // console.log("recv isInPreSale", msg.value);
            if (
                msg.value == preSaleEthAmount &&
                currentPreSaleAmount < preSaleLimitAmount
            ) {
                currentPreSaleAmount = currentPreSaleAmount + msg.value;

                _transfer(address(this), msg.sender, preSaleTokenUnitAmount);

                emit FairMinted(
                    msg.sender,
                    preSaleTokenUnitAmount,
                    preSaleEthAmount
                );

                if (currentPreSaleAmount == preSaleLimitAmount) {
                    addLiquidity((uint32)(block.number));

                    emit FairLaunch(
                        msg.sender,
                        _balances[address(this)],
                        preSaleLimitAmount
                    );

                    emit Swap(
                        msg.sender,
                        msg.value,
                        0,
                        0,
                        preSaleTokenUnitAmount
                    );
                }
            } else {
                payable(msg.sender).transfer(msg.value);
            }
        } else {
            buy();
        }
    }
}

contract Lions is BSC50V3 {
    uint256 private _totalSupply = 21_000_000_000 * 10 ** 18;

    constructor()
        BSC50V3("Lions", "Lions", _totalSupply, 1 ether, 1 ether, 135)
    {}
}

{
  "compilationTarget": {
    "Lions.sol": "Lions"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}