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

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract ITradeWallet is Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    // user => token => amount
    mapping(address => mapping(address => uint256)) public userBalances;
    
    bool public paused;

    event DepositedToken(address indexed user, address indexed token, uint256 amount);
    event WithdrawnToken(address indexed admin, address indexed token, uint256 amount);
    event WithdrawnETH(address indexed admin, uint256 amount);
    event EmergencyPaused(address indexed admin, bool status);

    constructor() Ownable(msg.sender) {}

    modifier whenNotPaused() {
        require(!paused, "Contract paused");
        _;
    }

    receive() external payable {}
    fallback() external payable {}

    // =====================
    //         USER
    // =====================
    function depositToken(address token, uint256 amount) external {
        require(token != address(0), "Invalid token");
        
        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);
        userBalances[msg.sender][token] += amount;
        
        emit DepositedToken(msg.sender, token, amount);
    }

    // =====================
    //         ADMIN
    // =====================
    function withdrawETH(uint256 amount) external onlyOwner nonReentrant whenNotPaused {
        require(address(this).balance >= amount, "Insufficient ETH");
        
        (bool success, ) = owner().call{value: amount}("");
        require(success, "ETH transfer failed");
        
        emit WithdrawnETH(msg.sender, amount);
    }
    function withdrawToken(address token, uint256 amount) external onlyOwner nonReentrant whenNotPaused {
        require(token != address(0), "Invalid token");
        require(IERC20(token).balanceOf(address(this)) >= amount, "Insufficient token balance");

        IERC20(token).safeTransfer(owner(), amount);
        emit WithdrawnToken(msg.sender, token, amount);
    }
    function setPaused(bool _paused) external onlyOwner {
        paused = _paused;
        emit EmergencyPaused(msg.sender, _paused);
    }

    // =====================
    //        SEARCH
    // =====================
    function getBalance(address user, address token) external view returns (uint256) {
        return userBalances[user][token];
    }
    function getETHBalance() external view returns (uint256) {
        return address(this).balance;
    }
    function getTokenBalance(address token) external view returns (uint256) {
        return IERC20(token).balanceOf(address(this));
    }

    
}