// SPDX-License-Identifier: GPL-3.0

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;

    event LogMessage(string);


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

    function createBet(string calldata betId, string calldata url, uint64 deadline, uint64 schedule) public payable {
        require(deadline <= schedule);
        if (createdBets[betId]) {
            emit LogMessage("ERROR: Duplicated BetId");
            return;
        }
        scheduleBet(betId, url, deadline, schedule);
    }

    // BetId -> Result -> Total pooled per result
    mapping(string => mapping(string => uint256)) resultPools;

    // BetId -> Total pooled
    mapping(string => uint256) betPools;

    // BetId -> User -> Result -> User bet per result
    mapping(string => mapping(address => mapping(string => uint256))) resultAmounts;


    function placeBet(string calldata betId, string calldata result) public payable {
        require(betDeadlines[betId] > block.timestamp && createdBets[betId] && !finishedBets[betId]);
        resultPools[betId][result] += msg.value;
        betPools[betId] += msg.value;
        resultAmounts[betId][msg.sender][result] += msg.value;
    }


    mapping(string => mapping(address => bool)) claimedBets;
    function reclaimBet(string calldata betId) public {
        require(finishedBets[betId] && !claimedBets[betId][msg.sender]);
        claimedBets[betId][msg.sender] = true;
        string memory result = betResults[betId];
        uint256 userBet = resultAmounts[betId][msg.sender][result];
        if (userBet < 2) {
            return;
        }
        uint256 winnerPool = resultPools[betId][result];
        uint256 loserPool = betPools[betId] - winnerPool;
        uint256 reward = loserPool / (winnerPool / userBet) + userBet;
        uint256 fee = (reward / 100) + 2;
        reward -= fee;
        if (reward != 0) {
            msg.sender.transfer(reward);
        }
        owner.transfer(fee / 2);
    }

    // BetId -> Deadline to place new bets
    mapping(string => uint64) betDeadlines;
    // BetId -> Scheduled time to run
    mapping(string => uint64) betSchedules;

    mapping(string => bool) createdBets;
    mapping(bytes32 => string) queryBets;

    function scheduleBet(string calldata betId, string calldata url, uint64 deadline, uint64 schedule) internal {
       if (provable_getPrice("URL") > msg.value) {
           emit LogMessage("ERROR: Bet creation not successful due to lack of funds.");
           return;
       } else {
           bytes32 queryId;
           if (deadline == 0) {
               provable_query("URL", url);
           } else {
               provable_query(schedule, "URL", url);
           }
           queryBets[queryId] = betId;
           betSchedules[betId] = schedule;
           betDeadlines[betId] = deadline;
           createdBets[betId] = true;
       }
    }

    mapping(string => bool) finishedBets;
    mapping(string => string) betResults;
    function __callback(bytes32 queryId, string memory result) override public {
        emit LogMessage("Callback executed");
        require(msg.sender == provable_cbAddress());
        string memory betId = queryBets[queryId];
        betResults[betId] = result;
        finishedBets[betId] = true;
    }
}