/**
 * Copyright (c) 2010-2020 Contributors to the openHAB project
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0
 *
 * SPDX-License-Identifier: EPL-2.0
 */

 /* ***********************************************************
 * This file was automatically generated on 2022-01-03.      *
 *                                                           *
 * openHAB Bindings Version 2.0.0                            *
 *                                                           *
 * If you have a bugfix for this file and want to commit it, *
 * please fix the bug in the generator. You can find a link  *
 * to the generators git repository on tinkerforge.com       *
 *************************************************************/

package org.openhab.binding.tinkerforge.internal.device;

import java.net.URI;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.eclipse.smarthome.config.core.Configuration;
import org.eclipse.smarthome.config.core.ConfigDescription;
import org.eclipse.smarthome.config.core.ConfigDescriptionBuilder;
import org.eclipse.smarthome.config.core.ConfigDescriptionParameter.Type;
import org.eclipse.smarthome.config.core.ConfigDescriptionParameterBuilder;
import org.eclipse.smarthome.config.core.ConfigDescriptionParameterGroup;
import org.eclipse.smarthome.config.core.ParameterOption;
import org.eclipse.smarthome.core.types.State;
import org.eclipse.smarthome.core.types.StateOption;
import org.eclipse.smarthome.core.types.Command;
import org.eclipse.smarthome.core.types.CommandDescriptionBuilder;
import org.eclipse.smarthome.core.types.CommandOption;
import org.eclipse.smarthome.core.thing.ChannelUID;
import org.eclipse.smarthome.core.thing.ThingStatus;
import org.eclipse.smarthome.core.thing.ThingTypeUID;
import org.eclipse.smarthome.core.thing.binding.BaseThingHandler;
import org.eclipse.smarthome.core.thing.type.ChannelDefinitionBuilder;
import org.eclipse.smarthome.core.thing.type.ChannelType;
import org.eclipse.smarthome.core.thing.type.ChannelTypeBuilder;
import org.eclipse.smarthome.core.thing.type.ChannelTypeUID;
import org.eclipse.smarthome.core.types.RefreshType;
import org.eclipse.smarthome.core.thing.type.ThingType;
import org.eclipse.smarthome.core.thing.type.ThingTypeBuilder;
import org.eclipse.smarthome.core.types.StateDescriptionFragmentBuilder;
import org.openhab.binding.tinkerforge.internal.TinkerforgeBindingConstants;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.eclipse.smarthome.core.library.types.DecimalType;
import org.eclipse.smarthome.core.library.types.QuantityType;
import org.eclipse.smarthome.core.library.unit.MetricPrefix;
import org.eclipse.smarthome.core.library.unit.SIUnits;
import org.eclipse.smarthome.core.library.unit.SmartHomeUnits;
import org.eclipse.smarthome.core.library.types.StringType;

import com.tinkerforge.BrickletEnergyMonitor;
import com.tinkerforge.IPConnection;
import com.tinkerforge.TinkerforgeException;

import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;

/**
 * Wraps the Java Bindings of the Energy Monitor Bricklet.
 * @author Erik Fleckstein - Initial contribution
 */
@NonNullByDefault
public class BrickletEnergyMonitorWrapper extends BrickletEnergyMonitor implements CoMCUFlashable, DeviceWrapper {
    public static final DeviceInfo DEVICE_INFO = new DeviceInfo(BrickletEnergyMonitor.DEVICE_DISPLAY_NAME, "brickletenergymonitor", BrickletEnergyMonitor.DEVICE_IDENTIFIER, BrickletEnergyMonitorWrapper.class, BrickletEnergyMonitorActions.class, "2.0.0", true);

    public BrickletEnergyMonitorWrapper(String uid, IPConnection ipcon) {
        super(uid, ipcon);
    }

    private List<ScheduledFuture<?>> manualChannelUpdates = new ArrayList<>();
    private List<ListenerReg<?>> listenerRegs = new ArrayList<>();

    public void cancelManualUpdates() {
        manualChannelUpdates.forEach(f -> f.cancel(true));
    }

    public <T> T reg(T listener, Consumer<T> toRemove) {
        listenerRegs.add(new ListenerReg<T>(listener, toRemove));
        return listener;
    }

    
    private final Logger logger = LoggerFactory.getLogger(BrickletEnergyMonitorWrapper.class);

    @Override
    public void initialize(org.eclipse.smarthome.config.core.Configuration config, Function<String, org.eclipse.smarthome.config.core.Configuration> getChannelConfigFn, BiConsumer<String, org.eclipse.smarthome.core.types.State> updateStateFn, BiConsumer<String, String> triggerChannelFn, ScheduledExecutorService scheduler, BaseThingHandler handler) throws TinkerforgeException {
        this.setResponseExpectedAll(true);
        BrickletEnergyMonitorConfig cfg = (BrickletEnergyMonitorConfig) config.as(BrickletEnergyMonitorConfig.class);
        this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorVoltage", transformBrickletEnergyMonitorVoltageCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorCurrent", transformBrickletEnergyMonitorCurrentCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorEnergy", transformBrickletEnergyMonitorEnergyCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorRealPower", transformBrickletEnergyMonitorRealPowerCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorApparentPower", transformBrickletEnergyMonitorApparentPowerCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorReactivePower", transformBrickletEnergyMonitorReactivePowerCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorPowerFactor", transformBrickletEnergyMonitorPowerFactorCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
		this.addEnergyDataListener(this.reg((voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency) -> {if(true) {updateStateFn.accept("BrickletEnergyMonitorFrequency", transformBrickletEnergyMonitorFrequencyCallback0(voltage, current, energy, realPower, apparentPower, reactivePower, powerFactor, frequency, cfg));}}, this::removeEnergyDataListener));
        this.setEnergyDataCallbackConfiguration(cfg.energyDataUpdateInterval, true);
		this.setStatusLEDConfig(cfg.statusLEDConfig);
    }

    @Override
    public void dispose(org.eclipse.smarthome.config.core.Configuration config) throws TinkerforgeException {
        listenerRegs.forEach(ListenerReg::deregister);

        
        this.setEnergyDataCallbackConfiguration(0, true);
    }

    @Override
    public List<String> getEnabledChannels(org.eclipse.smarthome.config.core.Configuration config) throws TinkerforgeException{
        List<String> result = new ArrayList<String>();
        result.add("BrickletEnergyMonitorVoltage");
		result.add("BrickletEnergyMonitorCurrent");
		result.add("BrickletEnergyMonitorEnergy");
		result.add("BrickletEnergyMonitorRealPower");
		result.add("BrickletEnergyMonitorApparentPower");
		result.add("BrickletEnergyMonitorReactivePower");
		result.add("BrickletEnergyMonitorPowerFactor");
		result.add("BrickletEnergyMonitorFrequency");
		result.add("BrickletEnergyMonitorResetEnergy");
        return result;
    }

    public static @Nullable ChannelType getChannelType(ChannelTypeUID channelTypeUID) {
        switch(channelTypeUID.getId()) {
            case "BrickletEnergyMonitorVoltage":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorVoltage"), "Voltage", "Number:ElectricPotential").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorVoltage")).withDescription("Root mean square voltage.<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f %unit%").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorCurrent":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorCurrent"), "Current", "Number:ElectricCurrent").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorCurrent")).withDescription("Root mean square current.<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f %unit%").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorEnergy":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorEnergy"), "Energy", "Number:Energy").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorEnergy")).withDescription("Energy (integrated over time)<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f %unit%").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorRealPower":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorRealPower"), "Real Power", "Number:Power").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorRealPower")).withDescription("Real Power<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f %unit%").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorAppPower":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorAppPower"), "Apparent Power", "Number:Dimensionless").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorAppPower")).withDescription("Apparent Power<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f VA").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorReacPower":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorReacPower"), "Reactive Power", "Number:Dimensionless").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorReacPower")).withDescription("Reactive Power<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f var").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorFactor":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorFactor"), "Power Factor", "Number:Dimensionless").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorFactor")).withDescription("Power Factor<br/><br/>Integrated over 10 zero-crossings of the voltage sine wave. With a standard AC mains voltage frequency of 50Hz this results in a 5 measurements per second (or an integration time of 200ms per measurement). If no voltage transformer is connected, the Bricklet will use the current waveform to calculate the frequency and it will use an integration time of 10 zero-crossings of the current waveform.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.3f").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorFrequency":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorFrequency"), "Frequency", "Number:Frequency").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorFrequency")).withDescription("AC Frequency of the mains voltage<br/><br/>The frequency is recalculated every 6 seconds.")
.withStateDescription(StateDescriptionFragmentBuilder.create().withPattern("%.2f %unit%").withReadOnly(true).build().toStateDescription()).build();
            case "BrickletEnergyMonitorReset":
                return ChannelTypeBuilder.state(new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorReset"), "Reset Energy Value", "String").withConfigDescriptionURI(URI.create("channel-type:tinkerforge:BrickletEnergyMonitorReset")).withDescription("Sets the energy value back to 0 Wh")
.withCommandDescription(CommandDescriptionBuilder.create().withCommandOption(new CommandOption("RESET", "Reset")).build()).build();
default:
                break;
        }

        return null;
    }

    public static ThingType getThingType(ThingTypeUID thingTypeUID) {
             Map<String, String> thingTypeProperties = ThingTypeBuilder.instance(thingTypeUID, "unused").build().getProperties();
             Map<String, String> props = new HashMap<String, String>(thingTypeProperties);
             props.putIfAbsent(TinkerforgeBindingConstants.PROPERTY_MINIMUM_FIRMWARE_VERSION, DEVICE_INFO.minimumFWVersion);
        return ThingTypeBuilder.instance(thingTypeUID, "Tinkerforge Energy Monitor Bricklet").isListed(false).withSupportedBridgeTypeUIDs(Arrays.asList(TinkerforgeBindingConstants.THING_TYPE_BRICK_DAEMON.toString())).withConfigDescriptionURI(URI.create("thing-type:tinkerforge:" + thingTypeUID.getId())).withDescription("Measures Voltage, Current, Energy, Real/Apparent/Reactive Power, Power Factor and Frequency").withChannelDefinitions(Arrays.asList(new ChannelDefinitionBuilder("BrickletEnergyMonitorVoltage", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorVoltage")).withLabel("Voltage").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorCurrent", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorCurrent")).withLabel("Current").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorEnergy", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorEnergy")).withLabel("Energy").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorRealPower", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorRealPower")).withLabel("Real Power").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorApparentPower", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorAppPower")).withLabel("Apparent Power").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorReactivePower", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorReacPower")).withLabel("Reactive Power").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorPowerFactor", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorFactor")).withLabel("Power Factor").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorFrequency", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorFrequency")).withLabel("Frequency").build(), new ChannelDefinitionBuilder("BrickletEnergyMonitorResetEnergy", new ChannelTypeUID("tinkerforge", "BrickletEnergyMonitorReset")).withLabel("Reset Energy Value").build())).withProperties(props).build();
    }

    public static @Nullable ConfigDescription getConfigDescription(URI uri) {
        switch(uri.toASCIIString()) {
            case "thing-type:tinkerforge:brickletenergymonitor":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList(ConfigDescriptionParameterBuilder.create("energyDataUpdateInterval", Type.INTEGER).withDefault("1000").withDescription("Specifies the update interval for all energy data in milliseconds. A value of 0 disables automatic updates.").withGroupName("update_intervals").withLabel("Energy Data Update Interval").withUnit("ms").withMinimum(BigDecimal.valueOf(0)).withMaximum(BigDecimal.valueOf(4294967295L)).build(), ConfigDescriptionParameterBuilder.create("statusLEDConfig", Type.INTEGER).withDefault("3").withDescription("The status LED configuration. By default the LED shows communication traffic between Brick and Bricklet, it flickers once for every 10 received data packets.<br/><br/>You can also turn the LED permanently on/off or show a heartbeat.<br/><br/>If the Bricklet is in bootloader mode, the LED is will show heartbeat by default.").withLabel("Status LED Configuration").withAdvanced(true).withLimitToOptions(true).withOptions(Arrays.asList(new ParameterOption("0", "Off"), new ParameterOption("1", "On"), new ParameterOption("2", "Show Heartbeat"), new ParameterOption("3", "Show Status"))).build())).withParameterGroups(Arrays.asList(new ConfigDescriptionParameterGroup("update_intervals", "null", true, "Update Intervals", "Update Intervals"))).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorVoltage":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorCurrent":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorEnergy":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorRealPower":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorAppPower":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorReacPower":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorFactor":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorFrequency":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            case "channel-type:tinkerforge:BrickletEnergyMonitorReset":
                return ConfigDescriptionBuilder.create(uri).withParameters(Arrays.asList()).withParameterGroups(Arrays.asList()).build();
            default:
                break;
        }
        return null;
    }

        @Override
    public void refreshValue(String channel, org.eclipse.smarthome.config.core.Configuration config, org.eclipse.smarthome.config.core.Configuration channelConfig, BiConsumer<String, org.eclipse.smarthome.core.types.State> updateStateFn, BiConsumer<String, String> triggerChannelFn) throws TinkerforgeException {
        BrickletEnergyMonitorConfig cfg = (BrickletEnergyMonitorConfig) config.as(BrickletEnergyMonitorConfig.class);
switch(channel) {
            case "BrickletEnergyMonitorVoltage":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorVoltageGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorCurrent":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorCurrentGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorEnergy":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorEnergyGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorRealPower":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorRealPowerGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorApparentPower":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorApparentPowerGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorReactivePower":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorReactivePowerGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorPowerFactor":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorPowerFactorGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorFrequency":
                   {
            BrickletEnergyMonitor.EnergyData value = this.getEnergyData();
            if(true)
                updateStateFn.accept(channel, transformBrickletEnergyMonitorFrequencyGetter0(value, cfg));
        }
                   return;
            case "BrickletEnergyMonitorResetEnergy":
               return;
default:
                logger.warn("Refresh for unknown channel {}", channel);
                break;
        }
    }
    

        @Override
    public List<SetterRefresh> handleCommand(org.eclipse.smarthome.config.core.Configuration config, org.eclipse.smarthome.config.core.Configuration channelConfig, String channel, Command command) throws TinkerforgeException {
        List<SetterRefresh> result = Collections.emptyList();
        
        switch(channel) {
            case "BrickletEnergyMonitorResetEnergy":
                if (command instanceof StringType) {
                    this.resetEnergy();
                }
        
                else {
                    logger.warn("Command type {} not supported for channel {}. Please use one of StringType.", command.getClass().getName(), channel);
                }
                
                break;
default:
                logger.warn("Command for unknown channel {}", channel);
        }
        return result;
    }

        private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorVoltageCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(voltage / 100.0, SmartHomeUnits.VOLT);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorCurrentCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(current / 100.0, SmartHomeUnits.AMPERE);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorEnergyCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(energy / 100.0, SmartHomeUnits.WATT_HOUR);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorRealPowerCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(realPower / 100.0, SmartHomeUnits.WATT);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorApparentPowerCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new DecimalType(apparentPower / 100.0);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorReactivePowerCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new DecimalType(reactivePower / 100.0);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorPowerFactorCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new DecimalType(powerFactor / 1000.0);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorFrequencyCallback0(int voltage, int current, int energy, int realPower, int apparentPower, int reactivePower, int powerFactor, int frequency, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(frequency / 100.0, SmartHomeUnits.HERTZ);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorVoltageGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(value.voltage / 100.0, SmartHomeUnits.VOLT);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorCurrentGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(value.current / 100.0, SmartHomeUnits.AMPERE);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorEnergyGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(value.energy / 100.0, SmartHomeUnits.WATT_HOUR);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorRealPowerGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(value.realPower / 100.0, SmartHomeUnits.WATT);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorApparentPowerGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new DecimalType(value.apparentPower / 100.0);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorReactivePowerGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new DecimalType(value.reactivePower / 100.0);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorPowerFactorGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new DecimalType(value.powerFactor / 1000.0);
    }
	    private org.eclipse.smarthome.core.types.State transformBrickletEnergyMonitorFrequencyGetter0(BrickletEnergyMonitor.EnergyData value, BrickletEnergyMonitorConfig cfg) {
        return new QuantityType<>(value.frequency / 100.0, SmartHomeUnits.HERTZ);
    }

}