pragma solidity ^0.4.0;

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


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


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() public {
    owner = msg.sender;
  }

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

  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}


contract FredCoin is Ownable {

    string public name = "FredCoin";
    string public symbol = "FRD";


    mapping(address => uint) addressBalance;

    mapping(address => bool) whitelist;

    event whitelistAccessAtempt(address indexed _who);
    modifier onlyWhitelist{
        if(whitelist[msg.sender] == true){
            _;
        }
        else{
            whitelistAccessAtempt(msg.sender);
        }
    }

    function addWhitelist(address _who) onlyOwner{
        whitelist[_who] = true;
    }


    uint totalTokenSupply;
    uint tokenTransferLimit;

    function FredCoin(uint _totalSupply, uint _tokenLimit) public{
        whitelist[msg.sender] = true;
        totalTokenSupply = _totalSupply;
        tokenTransferLimit = _tokenLimit;
        addressBalance[msg.sender] = 1000;
    }


    function totalSupply() constant onlyWhitelist returns (uint totalSupply){
        totalSupply = totalTokenSupply;
    }
    function transferLimit() constant onlyWhitelist returns (uint transferLimit){
        transferLimit = tokenTransferLimit;
    }
    function setTransferLimit (uint _value) onlyOwner{
        tokenTransferLimit = _value;
    }

    function balanceOf(address _owner) onlyWhitelist constant returns (uint balance) {
        return addressBalance[_owner];
    }

    event NotEnoughFundsTransactionAttempt(address indexed _from, address indexed _to, uint _value);
    modifier haveEnoughTokens (address _from, address _to, uint _value){
        if(addressBalance[_from] > _value){
            _;
        }
        else{
            NotEnoughFundsTransactionAttempt(_from, _to, _value);
        }
    }

    event OverflowTransactionAttempt (address indexed _from, address indexed _to, uint _value);
    modifier stopOverflow (address _from, address _to, uint _value){
        if( addressBalance[_to]  < (addressBalance[_to] + _value) ){
            _;
        }
        else{
            OverflowTransactionAttempt(_from, _to, _value);
        }
    }

    event ExceedTransactionLimit (address indexed _from, address indexed _to, uint _value);
    modifier transferLimitExceed (address _from, address _to, uint _value){
        if(_value < tokenTransferLimit){
            _;
        }
        else{
            ExceedTransactionLimit(_from, _to, _value);
        }
    }

    event Transfer(address indexed _from, address indexed _to, uint256 _value);
    function transfer(address _to, uint256 _value)  onlyWhitelist haveEnoughTokens(msg.sender, _to, _value) stopOverflow(msg.sender, _to, _value) transferLimitExceed(msg.sender, _to, _value) returns (bool success)  {

                addressBalance[msg.sender] = addressBalance[msg.sender] - _value;
                addressBalance[_to] = addressBalance[_to] + _value;

                Transfer(msg.sender, _to, _value);
    }



    mapping(address => mapping(address => uint)) approved;

    event Approval(address indexed _owner, address indexed _spender, uint256 _value);
    function approve(address _spender, uint256 _value) returns (bool success){
        approved[msg.sender][_spender] = _value;
        Approval(msg.sender, _spender, _value);
        return true;
    }

    function allowance(address _owner, address _spender) constant returns (uint256 remaining){
        remaining = approved[_owner][_spender];
    }

    function transferFrom(address _from, address _to, uint256 _value)  stopOverflow(_from, _to, _value) haveEnoughTokens(_from, _to, _value) returns (bool success)  {
        if(allowance(_from, _to) > _value){
            addressBalance[_from] = addressBalance[_from] - _value;
            addressBalance[_to] = addressBalance[_to] + _value;
            Transfer(_from, _to, _value);
            return true;
        }
        return false;
    }
}