contract MexaCoin is Pausable, StandardToken, BlackList {
    
    string public name;
    string public symbol;
    uint public decimals;
    address public upgradedAddress;
    bool public deprecated;

    // Inicializa el contrato con el suministro inicial de monedas al creador
    //
    // @param _initialSupply    Suministro inicial de monedas
    // @param _name             Establece el nombre de la moneda
    // @param _symbol           Establece el simbolo de la moneda
    // @param _decimals         Establece el numero de decimales

    constructor (uint _initialSupply, string _name, string _symbol, uint _decimals) public {
        _totalSupply = _initialSupply;
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        balances[owner] = _initialSupply;
        deprecated = false;
    }

    // Transferencias entre direcciones
    // Requiere que ni el emisor ni el receptor esten en la lista negra
    // Suspende actividades cuando el contrato se encuentra en pausa
    // Utiliza ERC20.sol para actualizar el contrato si el actual llega a ser obsoleto
    //
    // @param _to               Direccion a la que se envian las monedas
    // @param _value            Cantidad de monedas a enviar
    function transfer(address _to, uint _value) public whenNotPaused {
        require(!isBlackListed[msg.sender]);
        require(!isBlackListed[_to]);
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value);
        } else {
            return super.transfer(_to, _value);
        }
    }

    // Refleja el balance de una direccion
    // Utiliza ERC20.sol para actualizar el contrato si el actual llega a ser obsoleto
    //
    // @param who               Direccion a consultar
    function balanceOf(address who) public constant returns (uint) {
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).balanceOf(who);
        } else {
            return super.balanceOf(who);
        }
    }
    
    // Transferencias desde direcciones a nombre de terceros (concesiones)
    // Require que ni el emisor ni el receptor esten en la lista negra
    // Suspende actividades cuando el contrato se encuentra en pausa
    // Utiliza ERC20.sol para actualizar el contrato si el actual llega a ser obsoleto
    //
    // @param _from             Direccion de la que se envian las monedas
    // @param _to               Direccion a la que se envian las monedas
    // @param _value            Cantidad de monedas a enviar
    function transferFrom(address _from, address _to, uint _value) public whenNotPaused {
        require(!isBlackListed[_from]);
        require(!isBlackListed[_to]);
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value);
        } else {
            return super.transferFrom(_from, _to, _value);
        }
    }

    // Permite genera concesiones a direcciones de terceros especificando la direccion y la cantidad de monedas a conceder
    // Require que ni el emisor ni el receptor esten en la lista negra
    // Suspende actividades cuando el contrato se encuentra en pausa
    // Utiliza ERC20.sol para actualizar el contrato si el actual llega a ser obsoleto
    //
    // @param _spender          Direccion a la que se le conceden las monedas
    // @param _value            Cantidad de monedas a conceder
    function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) whenNotPaused {
        require(!isBlackListed[msg.sender]);
        require(!isBlackListed[_spender]);
        if (deprecated) {
            return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value);
        } else {
            return super.approve(_spender, _value);
        }
    }

    // Refleja cantidad de moendas restantes en concesion
    // Utiliza ERC20.sol para actualizar el contrato si el actual llega a ser obsoleto
    //
    // @param _owner            Direccion de quien concede las monedas
    // @param _spender          Direccion que posee la concesion
    function allowance(address _owner, address _spender) public constant returns (uint remaining) {
        if (deprecated) {
            return StandardToken(upgradedAddress).allowance(_owner, _spender);
        } else {
            return super.allowance(_owner, _spender);
        }
    }

    // Suspende el actual contrato a favor de uno nuevo
    //
    // @param _upgradedAddress  Direccion del nuevo contrato
    function deprecate(address _upgradedAddress) public onlyOwner {
        deprecated = true;
        upgradedAddress = _upgradedAddress;
        emit Deprecate(_upgradedAddress);
    }

    // Refleja la cantidad total de monedas generada por el contrato
    //
    function totalSupply() public constant returns (uint) {
        if (deprecated) {
            return StandardToken(upgradedAddress).totalSupply();
        } else {
            return _totalSupply;
        }
    }

    // Genera nuevas monedas y las deposita en la direccion del creador
    //
    // @param _amount           Numero de monedas a generar
    function issue(uint amount) public onlyOwner {
        require(_totalSupply + amount > _totalSupply);
        require(balances[owner] + amount > balances[owner]);

        balances[owner] += amount;
        _totalSupply += amount;
        emit Issue(amount);
    }

    // Retiro de monedas
    // Las moendas son retiradas de la cuenta del creador
    // El balance en la cuenta debe ser suficiente para completar la transaccion de lo contrario se generara un error
    // @param _amount           Nuemro de monedas a retirar
    function redeem(uint amount) public onlyOwner {
        require(_totalSupply >= amount);
        require(balances[owner] >= amount);

        _totalSupply -= amount;
        balances[owner] -= amount;
        emit Redeem(amount);
    }
    
    // Establece el valor de las cuotas en caso de existir
    //
    // @param newBasisPoints    Cuota base
    // @param newMaxFee         Cuota maxima
    function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner {
        // Asegura el valor maximo que no podran sobrepasar las cuotas
        require(newBasisPoints < 50);
        require(newMaxFee < 1000);

        basisPointsRate = newBasisPoints;
        maximumFee = newMaxFee.mul(10**decimals);

        emit Params(basisPointsRate, maximumFee);
    }
    
    // Genera un evento publico en el Blockchain que notificara a los clientes cuando nuevas moendas sean generadas
    event Issue(uint amount);

    // Genera un evento publico en el Blockchain que notificara a los clientes cuando nuevas moendas sean generadas
    event Redeem(uint amount);

    // Genera un evento publico en el Blockchain que notificara a los clientes cuando nuevas moendas sean generadas
    event Deprecate(address newAddress);

    // Genera un evento publico en el Blockchain que notificara a los clientes cuando nuevas moendas sean generadas
    event Params(uint feeBasisPoints, uint maxFee);
}
function totalSupply() public constant returns (uint) {
    if (deprecated) {
        return StandardToken(upgradedAddress).totalSupply();
    } else {
        return _totalSupply;
    }
}

// Refleja la cantidad total de monedas generada por el contrato
//