contract MODAToken is StandardToken, Pausable {

    string public constant name = "MODA Token";
    string public constant symbol = "MODA";
    uint8 public constant decimals = 6;
    uint256 public constant totalSupply = 2680000000000000;

    // Holds the amount and date of a given balance lock.
    struct BalanceLock {
        uint256 amount;
        uint256 unlockDate;
    }

    // A mapping of balance lock to a given address.
    mapping (address => BalanceLock) public balanceLocks;

    // An event to notify that _owner has locked a balance.
    event BalanceLocked(address indexed _owner, uint256 _oldLockedAmount,
    uint256 _newLockedAmount, uint256 _expiry);

    /** @dev Constructor for the contract.
      */
    function MODAToken()
        Pausable() {
        balances[msg.sender] = totalSupply;
        Transfer(0x0, msg.sender, totalSupply);
    }

    /** @dev Sets a token balance to be locked by the sender, on the condition
      * that the amount is equal or greater than the previous amount, or if the
      * previous lock time has expired.
      * @param _value The amount be locked.
      */
      //设置锁仓
    function lockBalance(address addr, uint256 _value,uint256 lockingDays) onlyOwner {

        // Check if the lock on previously locked tokens is still active.
        if (balanceLocks[addr].unlockDate > now) { // 未到可转账日期
            // Only allow confirming the lock or adding to it.
            require(_value >= balanceLocks[addr].amount);
        }
        // Ensure that no more than the balance can be locked.
        require(balances[addr] >= _value);
        // convert days to seconds
        uint256 lockingPeriod = lockingDays*24*3600;
        // Lock tokens and notify.
        uint256 _expiry = now + lockingPeriod;
        BalanceLocked(addr, balanceLocks[addr].amount, _value, _expiry);
        balanceLocks[addr] = BalanceLock(_value, _expiry);
    }

    /** @dev Returns the balance that a given address has available for transfer.
      * @param _owner The address of the token owner.
      */
    // 返回用户当前可用余额
    function availableBalance(address _owner) constant returns(uint256) {
        if (balanceLocks[_owner].unlockDate < now) {
            return balances[_owner];
        } else {
            assert(balances[_owner] >= balanceLocks[_owner].amount);
            return balances[_owner] - balanceLocks[_owner].amount;
        }
    }

    /** @dev Send `_value` token to `_to` from `msg.sender`, on the condition
      * that there are enough unlocked tokens in the `msg.sender` account.
      * @param _to The address of the recipient.
      * @param _value The amount of token to be transferred.
      * @return Whether the transfer was successful or not.
      */
      // 
    function transfer(address _to, uint256 _value) whenNotPaused returns (bool success) {
        require(availableBalance(msg.sender) >= _value);
        return super.transfer(_to, _value);
    }

    /** @dev Send `_value` token to `_to` from `_from` on the condition
      * that there are enough unlocked tokens in the `_from` account.
      * @param _from The address of the sender.
      * @param _to The address of the recipient.
      * @param _value The amount of token to be transferred.
      * @return Whether the transfer was successful or not.
      */
    function transferFrom(address _from, address _to, uint256 _value) whenNotPaused
        returns (bool success) {
        require(availableBalance(_from) >= _value);
        return super.transferFrom(_from, _to, _value);
    }
}
function transfer(address _to, uint256 _value) whenNotPaused returns (bool success) {
    require(availableBalance(msg.sender) >= _value);
    return super.transfer(_to, _value);
}

// 