// SPDX-License-Identifier: MIT

// KEKW Casino Contract: 5 December 2023
// Version: 2.0

// Website: https://kekw.gg/casino
// telegram: https://t.me/kekw_gg
// X.com/Twtter: https://x.com/kekw_gg
// Token: ($KEKW) 0x0DF596AD12F927e41EC317AF7DD666cA3574845f
// Uniswap: https://app.uniswap.org/swap?outputCurrency=0x0DF596AD12F927e41EC317AF7DD666cA3574845f
// Dextools: https://www.dextools.io/app/en/ether/pair-explorer/0x14ba508aaf2c15231f9df265980d1d461e54192b

pragma solidity 0.8.18;

error BetTooHigh(uint256 maximumBet);

contract KEKW_Casino {
    address public dev;
    mapping(address => uint256) public casinoBalances;

    address[] public gameContracts;
    uint256 public winnerPercentage = 95;
    uint256 public casinoPercentage = 3;
    uint256 public devPercentage = 100 - winnerPercentage - casinoPercentage;

    constructor() {
        dev = msg.sender;
    }

    function addNewGameContrtact(address _gameContract) public restricted {
        gameContracts.push(_gameContract);
    }

    function removeGameContract(uint256 _gameContractIndex) public restricted {
        if (_gameContractIndex >= gameContracts.length) return;

        for (
            uint256 i = _gameContractIndex;
            i < gameContracts.length - 1;
            i++
        ) {
            gameContracts[i] = gameContracts[i + 1];
        }
        gameContracts.pop();
    }

    function updateFees(
        uint256 _winnerFees,
        uint256 _casinoFees,
        uint256 _devFees
    ) public restricted {
        require(
            (_winnerFees + _devFees + _casinoFees) == 100,
            "Total should be 100."
        );
        winnerPercentage = _winnerFees;
        devPercentage = _devFees;
        casinoPercentage = _casinoFees;
    }

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

    function getPlayersCasinoBalanace(address playerAddress)
        external
        view
        returns (uint256)
    {
        return casinoBalances[playerAddress];
    }

    function deposit() public payable {
        require(msg.value > 0, "Minimum Deposit should be greater than 0.");
        casinoBalances[msg.sender] += msg.value;
    }

    function withdraw(uint256 _amount) public {
        require(
            casinoBalances[msg.sender] >= _amount,
            "You can't withdraw more than your balance."
        );
        payable(msg.sender).transfer(_amount);
        casinoBalances[msg.sender] -= _amount;
    }

    function donate() public payable {
        require(msg.value > 0, "Minimum Deposit should be greater than 0.");
        casinoBalances[address(this)] += msg.value;
    }

    function houseWithdraw(uint256 _amount) public restricted {
        require(
            casinoBalances[address(this)] >= _amount,
            "You can't withdraw more than your balance."
        );
        payable(dev).transfer(_amount);
        casinoBalances[address(this)] -= _amount;
    }

    function existingGameContract(address _gameContract)
        public
        view
        returns (bool)
    {
        for (uint256 i = 0; i < gameContracts.length; i++) {
            if (gameContracts[i] == _gameContract) {
                return true;
            }
        }

        return false;
    }

    function debitUserBalance(address _user, uint256 _amount)
        public
        onlyAuthorizedGame
    {
        require(
            casinoBalances[_user] >= _amount,
            "You do not have enough balance to move further."
        );
        casinoBalances[_user] -= _amount;
    }

    function creditUserBalance(address _user, uint256 _amount)
        public
        onlyAuthorizedGame
    {
        casinoBalances[_user] += _amount;
    }

    function playAgainstUser(uint256 betAmount) public onlyAuthorizedGame {
        require(
            casinoBalances[address(this)] >= betAmount,
            "House does not have enough balance to join game."
        );
        uint256 maximumBet = (casinoBalances[address(this)] * 1) / 100;
        if (betAmount > maximumBet) {
            // https://soliditylang.org/blog/2021/04/21/custom-errors/
            revert BetTooHigh({maximumBet: maximumBet});
        }
        casinoBalances[address(this)] -= betAmount;
    }

    function winnerCallback(address winnerAddress, uint256 totalBetAmount)
        public
        onlyAuthorizedGame
    {
        casinoBalances[dev] += (totalBetAmount * devPercentage) / 100;
        casinoBalances[address(this)] +=
            (totalBetAmount * casinoPercentage) /
            100;

        casinoBalances[winnerAddress] += ((totalBetAmount * winnerPercentage) /
            100);
    }

    modifier onlyAuthorizedGame() {
        require(
            existingGameContract(msg.sender),
            "You are not Authorized Game Contract Address."
        );
        _;
    }

    modifier restricted() {
        require(msg.sender == dev);
        _;
    }
}

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