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

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

    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);
}

contract Ownable {
    address payable ownerAddress;

    constructor() {
        ownerAddress = payable(0x21F3618356d0A8a736ccB494213ecF573bc5da17);
    }

    modifier onlyOwner() {
        require(msg.sender == owner(), "Caller Not An Owner");
        _;
    }

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

    function transferOwnership(address payable newOwner) external onlyOwner {
        require(newOwner != address(0));
        setOwner(newOwner);
    }

    function setOwner(address payable newOwner) internal {
        ownerAddress = newOwner;
    }

    function renounceOwnership() external onlyOwner {
        ownerAddress = payable(address(0));
    }
}

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

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

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

contract DOUGHFI is IERC20, Ownable {
    string public name;
    string public symbol;
    uint8 public decimals;
    uint256 public totalSupply;

    uint256 public tax;
    uint256 public limitTaxes;

    uint256 public liquidityTax;
    uint256 public limitLiquidity;

    uint8 public devFeeTaxPercentage;
    uint8 public liquidityFeeTaxPercentage;

    IUniswapV2Router02 private uniswapV2Router;
    address private uniswapV2Pair;
    bool public SwapEnabled;
    bool public addliquidity;

    address payable public devWallet;

    bool inSwapAndLiquify;

    mapping(address => uint256) private balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) public ExcludedFromFee;

    modifier lockTheSwap() {
        inSwapAndLiquify = true;
        _;
        inSwapAndLiquify = false;
    }

    constructor(address payable _devWallet) {
        name = "DoughFi";
        symbol = "DOUGH";
        decimals = 18;
        devFeeTaxPercentage = 7;
        liquidityFeeTaxPercentage = 3;

        limitTaxes = 5000 ether;
        limitLiquidity = 5000 ether;

        SwapEnabled = true;
        addliquidity = true;
        ExcludedFromFee[owner()] = true;
        ExcludedFromFee[address(this)] = true;
        ExcludedFromFee[_devWallet] = true;
        devWallet = payable(_devWallet);
        _mint(owner(), 5_00_000_000 * 10**uint256(decimals));
    }

    function initializePair() external onlyOwner {
        uniswapV2Router = IUniswapV2Router02(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );

        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
            address(this),
            uniswapV2Router.WETH()
        );
    }

    function balanceOf(address account)
        external
        view
        override
        returns (uint256)
    {
        return balances[account];
    }

    function transfer(address recipient, uint256 amount)
        external
        override
        returns (bool)
    {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address _owner, address spender)
        external
        view
        override
        returns (uint256)
    {
        return _allowances[_owner][spender];
    }

    function approve(address spender, uint256 amount)
        external
        override
        returns (bool)
    {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        _transfer(sender, recipient, amount);
        uint256 currentAllowance = _allowances[sender][msg.sender];
        require(currentAllowance >= amount, "exceeds allowance");
        _approve(sender, msg.sender, currentAllowance - amount);
        return true;
    }

    function _approve(
        address owner_,
        address spender,
        uint256 amount
    ) private {
        require(owner_ != address(0), "from zero address");
        require(spender != address(0), "to zero address");
        _allowances[owner_][spender] = amount;
        emit Approval(owner_, spender, amount);
    }

    function setLimitTaxes(uint256 newLimit) external onlyOwner {
        limitTaxes = newLimit;
    }

    function setLimitLiquidity(uint256 newLimit) external onlyOwner {
        limitLiquidity = newLimit;
    }

    function excludeFromFee(address account) external onlyOwner {
        ExcludedFromFee[account] = true;
    }

    function includeInFee(address account) external onlyOwner {
        ExcludedFromFee[account] = false;
    }

    function setdevWallet(address wallet) external onlyOwner {
        devWallet = payable(wallet);
    }

    function pauseTrading(bool _set) external onlyOwner {
        SwapEnabled = _set;
    }

    function pauseliquidity(bool _set) external onlyOwner {
        addliquidity = _set;
    }

    function setDevFeeTaxPercentage(uint8 _devFeeTaxPercentage)
        external
        onlyOwner
    {
        devFeeTaxPercentage = _devFeeTaxPercentage;
    }

    function setLiquidityFeeTaxPercentage(uint8 _liquidityFeeTaxPercentage)
        external
        onlyOwner
    {
        liquidityFeeTaxPercentage = _liquidityFeeTaxPercentage;
    }

    function mint(address account, uint256 amount) external onlyOwner {
        require(
            totalSupply + amount <= 1_000_000_000 * 10**uint256(decimals),
            "Exceeds limit"
        );
        _mint(account, amount);
    }

    function _mint(address account, uint256 amount) private {
        totalSupply += amount;
        balances[account] += amount;
        emit Transfer(address(0), account, amount);
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal {
        require(amount > 0, "greater than zero");
        require(amount <= balances[from], "Insufficient");

        bool isFromOrToUniswapPair = (from == uniswapV2Pair ||
            to == uniswapV2Pair);
        bool shouldApplyFee = !ExcludedFromFee[from] && !ExcludedFromFee[to];

        if (isFromOrToUniswapPair && shouldApplyFee) {
            uint256 liquidityFeeTax = (amount * liquidityFeeTaxPercentage) /
                100;
            uint256 devFeeTax = (amount * devFeeTaxPercentage) / 100;
            uint256 transferAmount = amount - liquidityFeeTax - devFeeTax;

            _transferTokens(from, to, transferAmount);
            _transferTokens(from, address(this), liquidityFeeTax + devFeeTax);

            tax += devFeeTax;
            liquidityTax += liquidityFeeTax;
        } else {
            _transferTokens(from, to, amount);
        }

        if (!isFromOrToUniswapPair) {
            if (SwapEnabled && from != uniswapV2Pair) {
                _manageTaxes();
            }

            if (addliquidity && from != uniswapV2Pair) {
                _manageLiquidity();
            }
        }
    }

    function _transferTokens(
        address from,
        address to,
        uint256 amount
    ) private {
        balances[from] -= amount;
        balances[to] += amount;
        emit Transfer(from, to, amount);
    }

    function _manageTaxes() private {
        uint256 contractTokenBalance = tax;

        if (contractTokenBalance >= limitTaxes) {
            contractTokenBalance = limitTaxes;
            swapTokensForEth(contractTokenBalance);
            _distribute();
            tax -= contractTokenBalance;
        }
    }

    function _manageLiquidity() private {
        uint256 tokenBal = liquidityTax;

        if (tokenBal >= limitLiquidity) {
            tokenBal = limitLiquidity;
            swapAndLiquify(tokenBal);
            liquidityTax -= tokenBal;
        }
    }

    function _distribute() internal {
        uint256 contractETHBalance = address(this).balance;
        uint256 totaltax = devFeeTaxPercentage;
        uint256 devFee = ((contractETHBalance) * (devFeeTaxPercentage)) /
            (totaltax);
        payable(devWallet).transfer(devFee);
    }

    function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap {
        require(contractTokenBalance > 0, "greater than 0");

        uint256 half = contractTokenBalance / 2;
        uint256 otherHalf = contractTokenBalance - half;

        uint256 initialBalance = address(this).balance;

        swapTokensForEth(half);
        uint256 newBalance = address(this).balance - initialBalance;

        addLiquidity(otherHalf, newBalance);
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp + 360
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            owner(),
            block.timestamp
        );
    }

    function withdrawEth(uint256 amount) external onlyOwner {
        require(amount <= address(this).balance, "Insufficient");
        payable(msg.sender).transfer(amount);
    }

    function getEthBalance() external view returns (uint256) {
        return address(this).balance;
    }

    receive() external payable {}
}

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