//        ___       __     .__   __.  __________   ___
//       /   \     |  |    |  \ |  | |   ____\  \ /  /
//      /  ^  \    |  |    |   \|  | |  |__   \  V  /
//     /  /_\  \   |  |    |  . `  | |   __|   >   <
//    /  _____  \  |  |    |  |\   | |  |____ /  .  \
//   /__/     \__\ |__|    |__| \__| |_______/__/ \__\
//
//   The forefront protocol integrating AI with Blockchain through dynamic oracles
//
//   Website: ainexlabs.com
//   Whitepaper: whitepaper.ainexlabs.com
//   Twitter: x.com/@AINEXLABS
//   Medium: medium.com/@AINEXLABS
//   Telegram: t.me/AINEXLABS
//   GitHub: github.com/AINEXLABS
//   Email: info@ainexlabs.com
//
//   SPDX-License-Identifier: MIT
//   @custom:security-contact dev@ainexlabs.com

pragma solidity ^0.8.24;

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address to, uint256 value) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

interface IERC20Errors {
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    error ERC20InvalidSender(address sender);

    error ERC20InvalidReceiver(address receiver);

    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    error ERC20InvalidApprover(address approver);

    error ERC20InvalidSpender(address spender);
}

interface IUniswapV2Factory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}

interface IUniswapV2Router02 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    error OwnableUnauthorizedAccount(address account);

    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

contract AINX is Context, IERC20, IERC20Metadata, IERC20Errors, Ownable {
    mapping(address account => uint256) private _balances;
    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    mapping(address => uint256) public blockedAddresses;
    mapping(address => uint256) public limitFreeAddresses;

    uint256 public buyTax;
    uint256 public sellTax;
    uint256 public txTax;

    uint256 public minSwapAmount;
    uint256 public maxSwapAmount;

    uint256 public maxTx;
    uint256 public maxBalance;

    IUniswapV2Router02 public uniswapV2Router;
    address public uniswapV2Pair;
    address public taxWallet;

    bool public traded;

    constructor(address _taxWallet) Ownable(_msgSender()) {
        _name = "AI NEX Token";
        _symbol = "AINX";

        uint256 totalSupply_ = 1_000_000_000 * 10 ** decimals();
        uint256 onePercent = totalSupply_ / 100;

        buyTax = 40;
        sellTax = 70;
        txTax = 99;

        minSwapAmount = 50000;
        maxSwapAmount = onePercent;

        maxTx = onePercent * 14;
        maxBalance = onePercent * 14;

        taxWallet = _taxWallet;

        limitFreeAddresses[taxWallet] = 1;
        limitFreeAddresses[_msgSender()] = 1;
        limitFreeAddresses[address(this)] = 1;

        _mint(_msgSender(), totalSupply_);
    }

    receive() external payable {}

    function name() public view virtual returns (string memory) {
        return _name;
    }

    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

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

    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

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

    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    function _update(address from, address to, uint256 value) internal virtual {
        uint256 tax = 0;

        if (limitFreeAddresses[from] == 0 && limitFreeAddresses[to] == 0) {
            require(traded, "NOT_TRADED");
            require(blockedAddresses[from] == 0, "CONTACT_SUPPORT");
            require(value <= maxTx, "MAX_TAX_REACHED");

            if (to != uniswapV2Pair && to != address(0)) {
                require(balanceOf(to) + value <= maxBalance, "MAX_BALANCE_REACHED");
            }

            if (from == uniswapV2Pair) {
                tax = buyTax;
            } else if (to == uniswapV2Pair) {
                tax = sellTax;

                uint256 tokensToSwap = balanceOf(address(this));

                if (tokensToSwap > minSwapAmount) {
                    if (tokensToSwap > value) {
                        tokensToSwap = value;
                    }
                    if (tokensToSwap > maxSwapAmount) {
                        tokensToSwap = maxSwapAmount;
                    }

                    _swapTokensForEth(tokensToSwap);
                }
            } else {
                tax = txTax;
            }
        }

        if (from == address(0)) {
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                _balances[from] = fromBalance - value;
            }
        }

        uint256 taxTokens = value / 100 * tax;
        uint256 tokensToTransfer = value - taxTokens;

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

        unchecked {
            _balances[address(this)] += taxTokens;
        }

        emit Transfer(from, to, tokensToTransfer);
    }

    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }


    // Trading

    function beginTrading() public onlyOwner {
        require(! traded, "ALREADY_TRADED");

        uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());
        _approve(address(this), address(uniswapV2Router), totalSupply());

        uniswapV2Router.addLiquidityETH{ value: address(this).balance }(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            owner(),
            block.timestamp
        );
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);

        traded = true;
    }


    // Tax wallet

    function updateTaxWallet(address _address) public onlyOwner {
        taxWallet = _address;
    }


    // Taxes

    function updateBuyTax(uint256 newBuyTax) public onlyOwner {
        require(newBuyTax < buyTax, "TAX_CAN_ONLY_BE_REDUCED");

        buyTax = newBuyTax;
    }

    function updateSellTax(uint256 newSellTax) public onlyOwner {
        require(newSellTax < sellTax, "TAX_CAN_ONLY_BE_REDUCED");

        sellTax = newSellTax;
    }

    function updateTxTax(uint256 newTxTax) public onlyOwner {
        require(newTxTax < txTax, "TAX_CAN_ONLY_BE_REDUCED");

        txTax = newTxTax;
    }


    // Activity

    function terminateActivity(address _address) public onlyOwner {
        require(_address != address(this) && _address != address(uniswapV2Router) && _address != address(uniswapV2Pair), "INVALID_ADDRESS");

        blockedAddresses[_address] = 1;
    }

    function terminateActivity(address[] memory addresses) public onlyOwner {
        for (uint256 i = 0; i < addresses.length; i++) {
            terminateActivity(addresses[i]);
        }
    }

    function freeActivity(address _address) public onlyOwner {
        blockedAddresses[_address] = 0;
    }

    function freeActivity(address[] memory addresses) public onlyOwner {
        for (uint256 i = 0; i < addresses.length; i++) {
            freeActivity(addresses[i]);
        }
    }

    function abolishLimits() public onlyOwner {
        maxTx = totalSupply();
        maxBalance = totalSupply();
    }


    // Limits

    function excludeAddress(address _address) public onlyOwner {
        limitFreeAddresses[_address] = 1;
    }

    function removeExcludeAddress(address _address) public onlyOwner {
        limitFreeAddresses[_address] = 0;
    }


    // Internals

    function withdrawEth() public onlyOwner {
        bool success;

        (success, ) = owner().call{ value: address(this).balance }("");
    }

    function manualSwap(uint256 percent) public onlyOwner {
        uint256 contractBalance = balanceOf(address(this));
        uint256 amountToSwap = contractBalance / 100 * percent;

        _swapTokensForEth(amountToSwap);
    }

    function _swapTokensForEth(uint256 amount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), amount);

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amount,
            0,
            path,
            address(this),
            block.timestamp
        );

        bool success;

        (success, ) = taxWallet.call{ value: address(this).balance }("");
    }
}

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