pragma solidity ^0.4.24;

contract CoinCasino {
    address public owner;
    bytes32[] public hashes;
    Bet[] public bets;
    mapping (bytes32 => uint) public headbets;
    mapping (bytes32 => uint) public tailbets;
    uint public housebalance;
    uint public reserved;
    uint public unclaimedbets;
    uint public gasbalance;
    uint public fee = 1 finney;

    event newhash(bytes32 hash);
    event betplaced(address better, uint amount, bool guess);
    event betcashed(address better, uint amount);

    constructor (bytes32 hash) public {
        hashes.push(keccak256(abi.encodePacked(hash))); //uploadhash logic doesnt work with only one hash.
        hashes.push(hash);
        owner = msg.sender;
    }

    function() public payable {
        housebalance += msg.value;
    }

    function createbet(bool guess) public payable {
        require(msg.value >= fee);
        uint amount = msg.value - fee;
        require(housecancover(amount, guess));
        gasbalance += fee;
        housebalance += amount;
        if(guess) {
            headbets[hashes[hashes.length - 1]] += amount;
        } else {
            tailbets[hashes[hashes.length - 1]] += amount;
        }
        Bet memory bet;
        bet.better = msg.sender;
        bet.hashheight = hashes.length - 1;
        bet.amount = amount;
        bet.headsortails = guess;
        bet.cashedout = false;
        bets.push(bet);
        emit betplaced(msg.sender, amount, guess);
    }

    function cashinbet(uint id) public {
        Bet memory bet = bets[id];
        require(bet.better == msg.sender);
        require(!bet.cashedout);
        require(hashes.length-1 >= bet.hashheight + 2);
        bet.cashedout = true;
        if(hashtobool(hashes[bet.hashheight + 2]) == bet.headsortails) {
            unclaimedbets -= bet.amount *2;
            msg.sender.transfer(bet.amount*2);
        }
        emit betcashed(msg.sender, bet.amount * 2);
    }

    function uploadhash(bytes32 hash) public {
        require(keccak256(abi.encodePacked(hash)) == hashes[hashes.length - 1]);
        hashes.push(hash);
        if(hashtobool(hashes[hashes.length - 1])) {
            housebalance -= headbets[hashes[hashes.length - 1 - 2]] * 2;
            unclaimedbets += headbets[hashes[hashes.length - 1 - 2]] * 2;
        } else {
            housebalance -= tailbets[hashes[hashes.length - 1 - 2]] * 2;
            unclaimedbets += tailbets[hashes[hashes.length - 1 - 2]] * 2;
        }
        if(headbets[hashes[hashes.length - 1 - 1]] >= tailbets[hashes[hashes.length - 1 - 1]]) {
            reserved = headbets[hashes[hashes.length - 1 - 1]] * 2;
        } else {
            reserved = tailbets[hashes[hashes.length - 1 - 1]] * 2;
        }
        owner.transfer(gasbalance);
        gasbalance = 0;
        emit newhash(hash);
    }

    function hashtobool(bytes32 hash) pure internal returns (bool) {
        if(uint(hash)%2 == 0) {
            return true;
        } else {
            return false;
        }
    }

    function housecancover(uint amount, bool guess) internal view returns (bool) {
        if(guess) {
            if((headbets[hashes[hashes.length - 1]] + amount)*2 <= housebalance + amount - reserved) {
                return true;
            }
        } else {
            if((tailbets[hashes[hashes.length - 1]] + amount)*2 < housebalance + amount - reserved) {
                return true;
            }
        }
        return false;
    }

    /*function getbets() public view returns (Bet[]) {
        return bets;
    }*/

    struct Bet {
        address better;
        uint hashheight;
        uint amount;
        bool headsortails;
        bool cashedout;
    }
}