pragma solidity ^0.4.13;


contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    
    uint256 c = a / b;
    
    return c;
  }

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

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



contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  
  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[msg.sender]);

    
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  
  function balanceOf(address _owner) public constant returns (uint256 balance) {
    return balances[_owner];
  }

}


contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public constant returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}


contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;


  
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  
  function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }

  
  function increaseApproval (address _spender, uint _addedValue) public returns (bool success) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

  function decreaseApproval (address _spender, uint _subtractedValue) public returns (bool success) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

}


contract Ownable {
  address public owner;


  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  
  function Ownable() {
    owner = msg.sender;
  }


  
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  
  function transferOwnership(address newOwner) onlyOwner public {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}





contract CryptoGripInitiative is StandardToken, Ownable {
    string  public  constant name = "Crypto Grip Initiative";

    string  public  constant symbol = "CGI";

    uint    public  constant decimals = 18;

    uint    public  saleStartTime;

    uint    public  saleEndTime;

    address public  tokenSaleContract;

    modifier onlyWhenTransferEnabled() {
        if (now <= saleEndTime && now >= saleStartTime) {
            require(msg.sender == tokenSaleContract || msg.sender == owner);
        }
        _;
    }

    modifier validDestination(address to) {
        require(to != address(0x0));
        require(to != address(this));
        _;
    }

    function CryptoGripInitiative(uint tokenTotalAmount, uint startTime, uint endTime, address admin) {
        
        balances[msg.sender] = tokenTotalAmount;
        totalSupply = tokenTotalAmount;
        Transfer(address(0x0), msg.sender, tokenTotalAmount);

        saleStartTime = startTime;
        saleEndTime = endTime;

        tokenSaleContract = msg.sender;
        transferOwnership(admin);
        
    }

    function transfer(address _to, uint _value)
    onlyWhenTransferEnabled
    validDestination(_to)
    returns (bool) {
        return super.transfer(_to, _value);
    }

    function transferFrom(address _from, address _to, uint _value)
    onlyWhenTransferEnabled
    validDestination(_to)
    returns (bool) {
        return super.transferFrom(_from, _to, _value);
    }

    event Burn(address indexed _burner, uint _value);

    function burn(uint _value) onlyWhenTransferEnabled
    returns (bool){
        balances[msg.sender] = balances[msg.sender].sub(_value);
        totalSupply = totalSupply.sub(_value);
        Burn(msg.sender, _value);
        Transfer(msg.sender, address(0x0), _value);
        return true;
    }

    
    
    
    
    
    

    function emergencyERC20Drain(ERC20 token, uint amount) onlyOwner {
        token.transfer(owner, amount);
    }
}







contract Whitelist {
    address public owner;

    address public sale;

    mapping (address => uint) public accepted;

    function Whitelist(address _owner, address _sale) {
        owner = _owner;
        sale = _sale;
    }

    function accept(address a, uint amountInWei) {
        assert(msg.sender == owner || msg.sender == sale);

        accepted[a] = amountInWei * 10 ** 18;
    }

    function setSale(address sale_) {
        assert(msg.sender == owner);

        sale = sale_;
    }

    function getCap(address _user) constant returns (uint) {
        uint cap = accepted[_user];
        return cap;
    }
}






contract ContributorApprover {
    Whitelist public list;

    mapping (address => uint)    public participated;

    uint public presaleStartTime;

    uint public remainingPresaleCap;

    uint public remainingPublicSaleCap;

    uint                      public openSaleStartTime;

    uint                      public openSaleEndTime;

    using SafeMath for uint;


    function ContributorApprover(
    Whitelist _whitelistContract,
    uint preIcoCap,
    uint IcoCap,
    uint _presaleStartTime,
    uint _openSaleStartTime,
    uint _openSaleEndTime) {
        list = _whitelistContract;
        openSaleStartTime = _openSaleStartTime;
        openSaleEndTime = _openSaleEndTime;
        presaleStartTime = _presaleStartTime;
        remainingPresaleCap = preIcoCap * 10 ** 18;
        remainingPublicSaleCap = IcoCap * 10 ** 18;

        
        require(presaleStartTime < openSaleStartTime);
        
        require(openSaleStartTime < openSaleEndTime);
    }

    
    function contributorCap(address contributor) constant returns (uint) {
        return list.getCap(contributor);
    }

    function eligible(address contributor, uint amountInWei) constant returns (uint) {
        
        if (now < presaleStartTime) return 0;
        
        if (now >= openSaleEndTime) return 0;

        
        if (now < openSaleStartTime) {
            
            if (remainingPresaleCap <= 0) {
                return 0;
            }
            
            uint cap = contributorCap(contributor);
            
            uint remainedCap = cap.sub(participated[contributor]);
            
            if (remainedCap > remainingPresaleCap) {
                remainedCap = remainingPresaleCap;
            }
            
            if (remainedCap > amountInWei) return amountInWei;
            
            else return remainedCap;
        }
        
        else {
            
            if (remainingPublicSaleCap <= 0) {
                return 0;
            }
            
            if (amountInWei > remainingPublicSaleCap) {
                return remainingPublicSaleCap;
            }
            
            else {
                return amountInWei;
            }
        }
    }

    function eligibleTestAndIncrement(address contributor, uint amountInWei) internal returns (uint) {
        uint result = eligible(contributor, amountInWei);
        participated[contributor] = participated[contributor].add(result);
        
        if (now < openSaleStartTime) {
            
            remainingPresaleCap = remainingPresaleCap.sub(result);
        }
        
        else {
            
            remainingPublicSaleCap = remainingPublicSaleCap.sub(result);
        }

        return result;
    }

    function saleEnded() constant returns (bool) {
        return now > openSaleEndTime;
    }

    function saleStarted() constant returns (bool) {
        return now >= presaleStartTime;
    }

    function publicSaleStarted() constant returns (bool) {
        return now >= openSaleStartTime;
    }
}






contract CryptoGripTokenSale is ContributorApprover {
    uint    public  constant tokensPerEthPresale = 1055;

    uint    public  constant tokensPerEthPublicSale = 755;

    address             public admin;

    address             public gripWallet;

    CryptoGripInitiative public token;

    uint                public raisedWei;

    bool                public haltSale;

    function CryptoGripTokenSale(address _admin,
    address _gripWallet,
    Whitelist _whiteListContract,
    uint _totalTokenSupply,
    uint _premintedTokenSupply,
    uint _presaleStartTime,
    uint _publicSaleStartTime,
    uint _publicSaleEndTime,
    uint _presaleCap,
    uint _publicSaleCap)

    ContributorApprover(_whiteListContract,
    _presaleCap,
    _publicSaleCap,
    _presaleStartTime,
    _publicSaleStartTime,
    _publicSaleEndTime)
    {
        admin = _admin;
        gripWallet = _gripWallet;

        token = new CryptoGripInitiative(_totalTokenSupply * 10 ** 18, _presaleStartTime, _publicSaleEndTime, _admin);

        
        token.transfer(gripWallet, _premintedTokenSupply * 10 ** 18);
    }

    function setHaltSale(bool halt) {
        require(msg.sender == admin);
        haltSale = halt;
    }

    function() payable {
        buy(msg.sender);
    }

    event Buy(address _buyer, uint _tokens, uint _payedWei);

    function buy(address recipient) payable returns (uint){
        require(tx.gasprice <= 50000000000 wei);

        require(!haltSale);
        require(saleStarted());
        require(!saleEnded());

        uint weiPayment = eligibleTestAndIncrement(recipient, msg.value);

        require(weiPayment > 0);

        
        if (msg.value > weiPayment) {
            msg.sender.transfer(msg.value.sub(weiPayment));
        }

        
        sendETHToMultiSig(weiPayment);
        raisedWei = raisedWei.add(weiPayment);

        uint recievedTokens = 0;

        if (now < openSaleStartTime) {
            recievedTokens = weiPayment.mul(tokensPerEthPresale);
        }
        else {
            recievedTokens = weiPayment.mul(tokensPerEthPublicSale);
        }

        assert(token.transfer(recipient, recievedTokens));


        Buy(recipient, recievedTokens, weiPayment);

        return weiPayment;
    }

    function sendETHToMultiSig(uint value) internal {
        gripWallet.transfer(value);
    }

    event FinalizeSale();
    
    function finalizeSale() {
        require(saleEnded());
        require(msg.sender == admin);

        
        token.burn(token.balanceOf(this));

        FinalizeSale();
    }

    
    
    function emergencyDrain(ERC20 anyToken) returns (bool){
        require(msg.sender == admin);
        require(saleEnded());

        if (this.balance > 0) {
            sendETHToMultiSig(this.balance);
        }

        if (anyToken != address(0x0)) {
            assert(anyToken.transfer(gripWallet, anyToken.balanceOf(this)));
        }

        return true;
    }

    
    
    function debugBuy() payable {
        require(msg.value == 123);
        sendETHToMultiSig(msg.value);
    }
}