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

interface IToken {
    function totalSupply() external view returns (uint256);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

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

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

    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

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

interface AggregatorV3Interface {
    function latestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );
}

contract DoughFiPresale {
    IToken public DoughFi;
    IToken public USDT;

    AggregatorV3Interface public priceFeedEth;

    address payable public owner;
    uint256 public tokenPerUSDT;
    uint256 public soldToken;
    uint256 public amountRaisedEth;
    uint256 public amountRaisedUsdt;
    uint256 public totalSupply;
    uint8 public EthTax = 10;
    uint8 public UsdtTax = 10;

    bool public CanBuy;
    bool public buywithUSDT;

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

    constructor() {
        priceFeedEth = AggregatorV3Interface(
            0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
        );
        owner = payable(0x21F3618356d0A8a736ccB494213ecF573bc5da17);
        DoughFi = IToken(0x8ec0DA6Bf56B04Dd9baA6808e0039a15C74BdB86);
        USDT = IToken(0xdAC17F958D2ee523a2206206994597C13D831ec7);
        totalSupply = DoughFi.totalSupply();
        CanBuy = true;
        buywithUSDT = true;
        tokenPerUSDT = 100 ether;
    }

    receive() external payable {
        buyTokenETH();
    }

    function getLatestPriceEth() public view returns (uint256) {
        (, int256 price, , , ) = priceFeedEth.latestRoundData();
        return uint256(price);
    }

    function buyTokenETH() public payable {
        require(CanBuy == true, "Can't buy token");
        uint256 amount = msg.value - ((msg.value * EthTax) / 100);
        uint256 numberOfTokens = EthToToken(amount);
        uint256 tokenValue = tokenForSale();
        require(tokenValue >= numberOfTokens, "Insufficient");
        soldToken += numberOfTokens;
        amountRaisedEth += msg.value;
        DoughFi.transferFrom(owner, msg.sender, numberOfTokens);
    }

    function buyTokenUSDT(uint256 _amount) external {
        require(CanBuy == true, "Can't buy token");
        require(buywithUSDT == true, "NOT BUY");
        uint256 extraAmount = (_amount - (_amount * UsdtTax) / 100);
        uint256 numberOfTokens = usdtToToken(extraAmount);
        uint256 tokenValue = tokenForSale();
        require(tokenValue >= numberOfTokens, "Insufficient");
        USDT.transferFrom(msg.sender, address(this), _amount);
        soldToken += numberOfTokens;
        amountRaisedUsdt += _amount;
        DoughFi.transferFrom(owner, msg.sender, numberOfTokens);
    }

    function tokenForSale() public view returns (uint256) {
        return DoughFi.allowance(owner, address(this));
    }

    function EthToToken(uint256 _amount) public view returns (uint256) {
        uint256 EthToUsd = (_amount * getLatestPriceEth()) / 1e8;
        uint256 numberOfTokens = (EthToUsd * tokenPerUSDT) / 1 ether;
        uint256 tokens = (numberOfTokens * (10**DoughFi.decimals())) / 1 ether;
        return tokens;
    }

    function usdtToToken(uint256 _amount) public view returns (uint256) {
        uint256 totalTokens = (_amount * tokenPerUSDT) / 1 ether;
        uint256 tokens = (totalTokens * (10**DoughFi.decimals())) /
            10**USDT.decimals();
        return tokens;
    }

    function setEthTax(uint8 _tax) external onlyOwner {
        EthTax = _tax;
    }

    function setUsdtTax(uint8 _tax) external onlyOwner {
        UsdtTax = _tax;
    }

    function setPriceFeedEth(address _priceFeedEth) external onlyOwner {
        priceFeedEth = AggregatorV3Interface(_priceFeedEth);
    }

    function changePrice(uint256 _price) external onlyOwner {
        tokenPerUSDT = _price;
    }

    function setTotalSupply(uint256 _totalSupply) external onlyOwner {
        totalSupply = _totalSupply;
    }

    function changeOwner(address payable _newOwner) external onlyOwner {
        owner = _newOwner;
    }

    function changeToken(address _token) external onlyOwner {
        DoughFi = IToken(_token);
    }

    function changeUSDT(address _usdt) external onlyOwner {
        USDT = IToken(_usdt);
    }

    function setBuying(bool enable) external onlyOwner {
        require(enable != CanBuy, "Already in that state");
        CanBuy = enable;
    }

    function setbuywithUSDT(bool enable) external onlyOwner {
        buywithUSDT = enable;
    }

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

    function withdrawTokens(address _tokenAddress, uint256 _amount)
        external
        onlyOwner
    {
        IToken token = IToken(_tokenAddress);
        require(
            token.balanceOf(address(this)) >= _amount,
            "Insufficient balance"
        );
        token.transfer(owner, _amount);
    }
}

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