pragma solidity 0.6.11;

import "github.com/provable-things/ethereum-api/blob/master/provableAPI_0.6.sol";

contract BettingSystem is usingProvable {

    address payable owner;

    constructor() public payable {
        owner = msg.sender;
    }

   event LogMessage(string description);

    mapping(string => address payable[]) winnerAddresses;
    mapping(string => mapping(address => uint256)) winnerAmounts;
    mapping(string => string) betUrls;
    mapping(string => address payable[]) betAddresses;
    mapping(string => string[]) betResults;
    mapping(string => uint256[]) betAmounts;
    mapping(string => uint) betDeadlines;
    mapping(bytes32 => string) betQueries;
    mapping(bytes32 => bool) finishedQueries;

    function createBet(string calldata id, string calldata url, uint64 deadline, uint32 delay) external payable {
        require(bytes(id).length > 5 && bytes(betUrls[id]).length == 0  && bytes(url).length > 18 && deadline > block.timestamp);
        betUrls[id] = url;
        betDeadlines[id] = deadline;
        scheduleBet(id, url, delay);
    }

    function placeBet(string calldata id, string calldata result) external payable {
        require(bytes(id).length > 5 && bytes(betUrls[id]).length != 0 && betDeadlines[id] > block.timestamp);
        betAddresses[id].push(msg.sender);
        betAmounts[id].push(msg.value);
        betResults[id].push(result);
    }

    function scheduleBet(string calldata betId, string calldata betUrl, uint32 betDelay) internal {
       if (provable_getPrice("URL") > address(this).balance) {
           revertBet(betId);
           emit LogMessage("Provable query was NOT sent, please add some ETH to cover for the query fee");
       } else {
           bytes32 queryId = provable_query(betDelay, "URL", betUrl);
           LogMessage("Provable query was sent, standing by for the answer..");
           betQueries[queryId] = betId;
       }
   }

    function __callback(bytes32 queryId, string calldata queryResult) override public {
       emit LogMessage("Executing callback.");
       require(msg.sender == provable_cbAddress() && !finishedQueries[queryId]);
       finishedQueries[queryId] = true;
       string memory betId = betQueries[queryId];
       uint256 loserPool = 0;
       uint256 winnerPool = 0;

       for (uint i = 0; i < betAddresses[betId].length; i++) {
           address payable player = betAddresses[betId][i];
           uint256 amount = betAmounts[betId][i];
           string memory result = betResults[betId][i];
           if (strcmp(result, queryResult)) {
               winnerAddresses[betId].push(player);
               winnerAmounts[betId][player] += amount;
               winnerPool += amount;
           } else {
               loserPool += amount;
           }
       }

       if (winnerPool == 0) {
           for (uint i = 0; i < betAddresses[betId].length; i++) {
               address payable player = betAddresses[betId][i];
               uint256 refund = betAmounts[betId][i];
               uint256 fee = refund / 20;
               refund -= fee;
               owner.transfer(fee);
               player.transfer(refund);
           }
       } else {
           for (uint i = 0; i < winnerAddresses[betId].length; i++) {
               address payable winner = winnerAddresses[betId][i];
               uint256 winnerAmount = winnerAmounts[betId][winner];
               uint256 fraction = winnerPool / winnerAmount;
               uint256 reward = loserPool / fraction + winnerAmount;
               uint256 fee = reward / 100;
               reward -= fee;
               owner.transfer(fee);
               winner.transfer(reward);
           }
       }
    }

    function memcmp(bytes memory a, bytes memory b) internal pure returns(bool){
        return (a.length == b.length) && (keccak256(a) == keccak256(b));
    }

    function strcmp(string memory a, string memory b) internal pure returns(bool){
        return memcmp(bytes(a), bytes(b));
    }

    function revertBet(string calldata id) internal {
        betUrls[id] = "";
        betDeadlines[id] = 0;
    }
}