// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.

pragma solidity ^0.8.17;

abstract contract Context{
    function _msgSender() internal view virtual returns (address){
        return msg.sender;
    }
}
contract Ownable is Context {
    address private _owner;
    address private _previousOwner;
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    modifier onlyOwner(){
        require(_owner == _msgSender(), "Ownerable: caller is not owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner{
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner{
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _owner = newOwner;
    }

}
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }
 
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }
 
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;
        return c;
    }
 
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }
 
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }
 
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }
}

interface IERC20 {
	
	function totalSupply() external view returns (uint256);
	function balanceOf(address account) external view returns (uint256);
	function transfer(address recipient, uint256 amount) external returns (bool);
	function allowance(address owner, address spender) external view returns (uint256);
	function approve(address spender, uint256 amount) external returns (bool);
	function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
	
	event Transfer(address indexed from, address indexed to, uint256 value);
	event Approval(address indexed owner, address indexed spender, uint256 value);

	event TransferDetails(address indexed from, address indexed to, uint256 total_Amount, uint256 reflected_amount, uint256 total_TransferAmount, uint256 reflected_TransferAmount);
}

contract BettingPool is Context, Ownable{

    using SafeMath for uint256;

    struct Bet {
        uint256 betAmount;
        uint8 betCountry;
    }

    mapping(address => Bet) public _betInfo;
    mapping(uint8 => uint256) public _poolAmount;

    uint256 private constant MAX = ~uint256(0);

    IERC20 private stadium;

    bool private bettingStart;
    bool private drawMode = false;
    bool private isGameStart = false; 

    uint256 private bettingAmountTotal; 
    uint8 private worldChampion = 0;

    address payable private _deploymentWallet;

    constructor() {
        stadium = IERC20(0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE);
        _deploymentWallet = payable(_msgSender());
    }

    function PlaceBet(uint256 amount,uint8 country) external {
        require(amount > 0 && country > 0);
        require(stadium.balanceOf(_msgSender()) >= amount && stadium.allowance(_msgSender(), address(this)) >= amount);
        require(isGameStart);
        if(_betInfo[_msgSender()].betCountry == 0){
        _betInfo[_msgSender()].betAmount = amount;
        _betInfo[_msgSender()].betCountry = country;
        _poolAmount[country] = _poolAmount[country].add(amount);
        }
        else{
            require(_betInfo[_msgSender()].betCountry == country);
            _poolAmount[country] = _poolAmount[country].add(amount);
            _betInfo[_msgSender()].betAmount = _betInfo[_msgSender()].betAmount.add(amount);
        }
        stadium.transferFrom(_msgSender(),address(this), amount);
    }

    function checkContractBalance() public view returns(uint256){
        return stadium.balanceOf(address(this));
    }

    function setGameStart(bool onoff) external {
        require(_msgSender() == _deploymentWallet);
        isGameStart = onoff;
    }

    function setDrawMode(bool onoff) external {
        require(_msgSender() == _deploymentWallet);
        drawMode = onoff;
    }

    function setWorldChampion(uint8 country) external {
        require(_msgSender() == _deploymentWallet);
        require(!isGameStart);
        bettingAmountTotal = stadium.balanceOf(address(this));
        worldChampion = country;
    }
 
    function claim() external {

        require(!isGameStart);
        require(worldChampion>0);

        if(_betInfo[_msgSender()].betCountry == worldChampion){
            uint256 winAmount = bettingAmountTotal.mul(_betInfo[_msgSender()].betAmount).div(_poolAmount[worldChampion]);
            stadium.transfer(_msgSender(), winAmount);
            _betInfo[_msgSender()].betAmount = 0;
            _betInfo[_msgSender()].betCountry = 0;
        }
    }


    function claimEst(uint256 amount, uint8 country) external view returns(uint256){
        if(bettingAmountTotal >0){
            return bettingAmountTotal.mul(amount).div(_poolAmount[country]);
        }
        return bettingAmountTotal.mul(amount).div(_poolAmount[country]);
    }

    function backupClaim() external {
        require(drawMode);
        require(_betInfo[_msgSender()].betAmount > 0);
        stadium.transfer(_msgSender(), _betInfo[_msgSender()].betAmount);
        _betInfo[_msgSender()].betAmount = 0;
        _betInfo[_msgSender()].betCountry = 0;
    }

    function clearStuckBalance(uint256 amountPercentage) external {
        require(_msgSender() == _deploymentWallet);
		uint256 amountToClear = amountPercentage * address(this).balance / 100;
		payable(msg.sender).transfer(amountToClear);
	}

	function clearStuckToken(address tokenAddress, uint256 tokens) external onlyOwner returns (bool success) {
		if(tokens == 0){
			tokens = IERC20(tokenAddress).balanceOf(address(this));
		}
		return IERC20(tokenAddress).transfer(msg.sender, tokens);
	}

    function managePoolInfo(uint8 country, uint256 poolBalance) external onlyOwner(){
        _poolAmount[country] = poolBalance;
    }

    function manageUserInfo(address user, uint8 country, uint256 betAmount) external onlyOwner(){
        _betInfo[user].betCountry = country;
        _betInfo[user].betAmount = betAmount;

    }

}