pragma solidity ^0.4.11;



/**
 * Math operations with safety checks
 */
library SafeMath {
    function mul(uint a, uint b) internal returns (uint) {
        uint c = a * b;
        assert(a == 0 || c / a == b);
        return c;
    }

    function div(uint a, uint b) internal returns (uint) {
        // assert(b > 0); // Solidity automatically throws when dividing by 0
        uint c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
        return c;
    }

    function sub(uint a, uint b) internal returns (uint) {
        assert(b <= a);
        return a - b;
    }

    function add(uint a, uint b) internal returns (uint) {
        uint c = a + b;
        assert(c >= a);
        return c;
    }

    function max64(uint64 a, uint64 b) internal constant returns (uint64) {
        return a >= b ? a : b;
    }

    function min64(uint64 a, uint64 b) internal constant returns (uint64) {
        return a < b ? a : b;
    }

    function max256(uint256 a, uint256 b) internal constant returns (uint256) {
        return a >= b ? a : b;
    }

    function min256(uint256 a, uint256 b) internal constant returns (uint256) {
        return a < b ? a : b;
    }

    function assert(bool assertion) internal {
        if (!assertion) {
            throw;
        }
    }
}
contract ERC20_Interface  {
    function totalSupply() public view returns (uint);
    function balanceOf(address tokenOwner) public view returns (uint balance);
    function allowance(address tokenOwner, address spender) public view returns (uint remaining);
    function transfer(address to, uint tokens) public returns (bool success);
    function approve(address spender, uint tokens) public returns (bool success);
    function transferFrom(address from, address to, uint tokens) public returns (bool success);
    event Transfer(address indexed from, address indexed to, uint tokens);
    event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract Ownable {
  address public owner;
  address public waitNewOwner;
    //oracle address for feed total lock and reward this address is oracle
  address public oracleAddress;
  mapping(address => uint256) public pricePerticket;
  mapping(address => uint256) public prize;
  event transferOwner(address newOwner);
  
  function Ownable() public{
      owner = msg.sender;
  }
  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */

  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(owner == msg.sender);
    _;
  }
  
  modifier onlyOracleAddress() {
    require(oracleAddress == msg.sender);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   * and safe new contract new owner will be accept owner
   */
  function transferOwnership(address newOwner) onlyOwner public {
    if (newOwner != address(0)) {
      waitNewOwner = newOwner;
    }
  }
  function transferOracleAddress(address newOracle) onlyOwner public {
    if (newOracle != address(0)) {
      oracleAddress = newOracle;
    }
  }
 
  /**
   * this function accept when transfer to new owner and new owner will be accept owner for safe contract free owner
   */
   
  function acceptOwnership() public {
      if(waitNewOwner == msg.sender) {
          owner = msg.sender;
           transferOwner(msg.sender);
      }else{
          revert();
      }
  }

}


contract SlotMachine is Ownable{
    //this ticket is return number of owner ticket
    mapping(address => mapping(address => uint256)) public ticket;
    using SafeMath for uint;
    mapping (address => uint256) public balanceToken;

    event AdminDepositToken(address contractAddress, address sender, uint256 amount, string message);
    event AdminWithdrawToken(address contractAddress, address sender, uint256 amount, string message);
    event BuyTicket(address contractAddress, address _buyer, uint256 amount, string message);
    event SubTicket(address contractAddress, address _buyer, uint256 ticket, string message);
    event ChangePrice(address contractAddress, address _owner, uint256 newPrice);
    event ChangePrize(address contractAddress, address _owner, uint256 _prize);
    event TransferTicket(address contractAddress, address _sender, address _receiver, uint256 ticket);
    event ClaimReward(address contractAddress, address _lucker, uint256 amount, string message);
    
    function changePrice(address likeAddr, uint256 newPrice) onlyOwner public {
        pricePerticket[likeAddr] = newPrice;
        ChangePrice(likeAddr, msg.sender, newPrice);
    }
    function changePrize(address likeAddr, uint256 _prize) onlyOwner public {
        prize[likeAddr] = _prize;
        ChangePrize(likeAddr, msg.sender, _prize);
    }
    function SlotMachine(address likeAddr, address oracle, uint256 price, uint256 _prize) public {
          oracleAddress = oracle;
          pricePerticket[likeAddr] = price;
          prize[likeAddr] = _prize;
    }
    function buyTicket(address likeAddr, uint amount, string message) public returns (bool){
      require(amount >= pricePerticket[likeAddr]);
        if(amount > ERC20_Interface(likeAddr).allowance(msg.sender, address(this))) {  
          revert();  
        }  
        ERC20_Interface(likeAddr).transferFrom(msg.sender, address(this), amount);
        uint256 numTicket = amount/pricePerticket[likeAddr];
        balanceToken[likeAddr] = balanceToken[likeAddr].add(amount);
        ticket[likeAddr][msg.sender] = ticket[likeAddr][msg.sender].add(numTicket);
        BuyTicket(likeAddr, msg.sender, amount, message);
        return true;
    }
    function transferTicket(address likeAddr, address _address, uint _ticket) public returns (bool){
        require(ticket[likeAddr][msg.sender] > _ticket);
        ticket[likeAddr][msg.sender].sub(_ticket);
        ticket[likeAddr][_address].add(_ticket);
        TransferTicket(likeAddr, msg.sender, _address, _ticket);
        return true;
    }
    function subTicket(address likeAddr, uint _ticket, string message) public returns (bool){
        require(ticket[likeAddr][msg.sender] >= _ticket);
        ticket[likeAddr][msg.sender] = ticket[likeAddr][msg.sender].sub(_ticket);
        SubTicket(likeAddr, msg.sender, ticket[likeAddr][msg.sender], message);
        return true;
    }
    function adminWithdrawToken(address likeAddr, uint amount, string  message) onlyOwner public returns(bool) {
        require(amount <= balanceToken[likeAddr]);
        balanceToken[likeAddr] = balanceToken[likeAddr].sub(amount);
        ERC20_Interface(likeAddr).transfer(msg.sender, amount);    
        AdminWithdrawToken(likeAddr, msg.sender, amount, message);
        return true;
    }
    function adminDepositToken(address likeAddr, uint amount, string  message) onlyOwner public returns(bool) {
        if(amount > ERC20_Interface(likeAddr).allowance(msg.sender, address(this))) {  
          revert();  
        }  
        ERC20_Interface(likeAddr).transferFrom(msg.sender, address(this), amount);
        balanceToken[likeAddr] = balanceToken[likeAddr].add(amount);
        AdminDepositToken(likeAddr, msg.sender, amount, message);
        return true;
    }
    function claimReward(address likeAddr, address _lucker, string message) onlyOracleAddress public returns(bool) {
        require(prize[likeAddr] < balanceToken[likeAddr]);
        balanceToken[likeAddr] = balanceToken[likeAddr].sub(prize[likeAddr]);
        ERC20_Interface(likeAddr).transfer(_lucker, prize[likeAddr]);
        ClaimReward(likeAddr, _lucker, prize[likeAddr], message);
        return true;
    }
    
}