pragma solidity >0.5.4;

import "@daostack/infra/contracts/Reputation.sol";
import "openzeppelin-solidity/contracts/ownership/Ownable.sol";
import "openzeppelin-solidity/contracts/token/ERC20/IERC20.sol";

/**
 * @title An Avatar holds tokens, reputation and ether for a controller
 */
contract AvatarMock is Ownable {
    string public orgName;
    address public nativeToken;
    Reputation public nativeReputation;

    event GenericCall(
        address indexed _contract,
        bytes _data,
        uint256 _value,
        bool _success
    );
    event SendEther(uint256 _amountInWei, address indexed _to);
    event ExternalTokenTransfer(
        address indexed _externalToken,
        address indexed _to,
        uint256 _value
    );
    event ExternalTokenTransferFrom(
        address indexed _externalToken,
        address _from,
        address _to,
        uint256 _value
    );
    event ExternalTokenApproval(
        address indexed _externalToken,
        address _spender,
        uint256 _value
    );
    event ReceiveEther(address indexed _sender, uint256 _value);
    event MetaData(string _metaData);

    /**
    * @dev the constructor takes organization name, native token and reputation system
    and creates an avatar for a controller
    */
    constructor(
        string memory _orgName,
        address _nativeToken,
        Reputation _nativeReputation
    ) public {
        orgName = _orgName;
        nativeToken = _nativeToken;
        nativeReputation = _nativeReputation;
    }

    /**
     * @dev enables an avatar to receive ethers
     */
    function() external payable {
        emit ReceiveEther(msg.sender, msg.value);
    }

    /**
     * @dev perform a generic call to an arbitrary contract
     * @param _contract  the contract's address to call
     * @param _data ABI-encoded contract call to call `_contract` address.
     * @param _value value (ETH) to transfer with the transaction
     * @return bool    success or fail
     *         bytes - the return bytes of the called contract's function.
     */
    function genericCall(
        address _contract,
        bytes memory _data,
        uint256 _value
    ) public onlyOwner returns (bool success, bytes memory returnValue) {
        // solhint-disable-next-line avoid-call-value
        (success, returnValue) = _contract.call.value(_value)(_data);
        emit GenericCall(_contract, _data, _value, success);
    }

    /**
     * @dev send ethers from the avatar's wallet
     * @param _amountInWei amount to send in Wei units
     * @param _to send the ethers to this address
     * @return bool which represents success
     */
    function sendEther(uint256 _amountInWei, address payable _to)
        public
        onlyOwner
        returns (bool)
    {
        _to.transfer(_amountInWei);
        emit SendEther(_amountInWei, _to);
        return true;
    }

    /**
     * @dev external token transfer
     * @param _externalToken the token contract
     * @param _to the destination address
     * @param _value the amount of tokens to transfer
     * @return bool which represents success
     */
    function externalTokenTransfer(
        IERC20 _externalToken,
        address _to,
        uint256 _value
    ) public onlyOwner returns (bool) {
        _externalToken.transfer(_to, _value);
        emit ExternalTokenTransfer(address(_externalToken), _to, _value);
        return true;
    }

    /**
     * @dev external token transfer from a specific account
     * @param _externalToken the token contract
     * @param _from the account to spend token from
     * @param _to the destination address
     * @param _value the amount of tokens to transfer
     * @return bool which represents success
     */
    function externalTokenTransferFrom(
        IERC20 _externalToken,
        address _from,
        address _to,
        uint256 _value
    ) public onlyOwner returns (bool) {
        _externalToken.transferFrom(_from, _to, _value);
        emit ExternalTokenTransferFrom(address(_externalToken), _from, _to, _value);
        return true;
    }

    /**
     * @dev externalTokenApproval approve the spender address to spend a specified amount of tokens
     *      on behalf of msg.sender.
     * @param _externalToken the address of the Token Contract
     * @param _spender address
     * @param _value the amount of ether (in Wei) which the approval is referring to.
     * @return bool which represents a success
     */
    function externalTokenApproval(
        IERC20 _externalToken,
        address _spender,
        uint256 _value
    ) public onlyOwner returns (bool) {
        _externalToken.approve(_spender, _value);
        emit ExternalTokenApproval(address(_externalToken), _spender, _value);
        return true;
    }

    /**
     * @dev metaData emits an event with a string, should contain the hash of some meta data.
     * @param _metaData a string representing a hash of the meta data
     * @return bool which represents a success
     */
    function metaData(string memory _metaData) public onlyOwner returns (bool) {
        emit MetaData(_metaData);
        return true;
    }
}