net.intelie.liverig.plugin.settings.CurvesSettings Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of liverig-plugin-components Show documentation
liverig plugin components
The newest version!
package net.intelie.liverig.plugin.settings;

import com.google.common.collect.ImmutableMap;
import net.intelie.live.EntityContext;
import net.intelie.live.Live;
import net.intelie.live.SettingsRoot;
import net.intelie.liverig.plugin.curves.Curve;
import net.intelie.liverig.plugin.curves.CurvesObserver;
import net.intelie.liverig.plugin.data.CurvesSettingLogData;
import net.intelie.liverig.plugin.util.BaseObserverCollection;
import net.intelie.liverig.plugin.util.ObserverCollection;
import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

public class CurvesSettings {
    private static final Logger LOGGER = LoggerFactory.getLogger(CurvesSettings.class);
    private final SettingsRoot settings;
    private String curvesSettingsId;
    private final  Function curveFromEntry;
    private volatile ImmutableMap curves = ImmutableMap.of();
    private final SettingLogReader logReader;
    private final ObserverCollection> observers = new BaseObserverCollection<>();

    public CurvesSettings(SettingsRoot settingsRoot, EntityContext context, String curvesSettingsId, Function curvefromEntry){
        this.settings = settingsRoot;
        this.curvesSettingsId = curvesSettingsId;
        this.curveFromEntry = curvefromEntry;
        this.logReader = new SettingLogReader(context, SharedSettings.baseSettingsNode(settingsRoot).cd(curvesSettingsId));
        loadFromSettings();
    }

    public Map getCurves() {
        return curves;
    }

    public List loggedCurves(boolean includeData, @Nullable Integer page, @Nullable Integer pageSize) {
        return this.logReader.loggedSettingsPrefix(page, pageSize)
                .map(CurvesSettingLogData::new)
                .map(c -> includeData ? c : c.withoutNewValue())
                .collect(Collectors.toList());
    }

    public Map loggedCurveById(Integer id) {
        Map loggedSetting = this.logReader.loggedSettingsById(id, Map.class);
        if (loggedSetting == null) {
            return null;
        }
        return convertFromMap(loggedSetting);
    }

    public void saveToSettings(Map input) {
        LOGGER.info("Saving calculated curves settings, {} entries", input.size());
        SharedSettings sharedSettings = new SharedSettings<>(settings, curvesSettingsId, this::convertFromMap);
        sharedSettings.set(input);
        loadFromSettings();
        ImmutableMap localCurves = ImmutableMap.copyOf(curves);
        observers.forEach(curvesObserver -> curvesObserver.onCurvesChange(localCurves));
    }

    public void loadFromMap(Map map){
        curves = convertFromMap(map);
    }

    private void loadFromSettings() {
        loadFromSettings(new SharedSettings<>(settings, curvesSettingsId, this::convertFromMap));
    }

    private void loadFromSettings(SharedSettings> settings) {
        curves = settings.get();
    }

    private ImmutableMap convertFromMap(Map map) {
        if (map == null)
            return ImmutableMap.of();

        ImmutableMap.Builder builder = ImmutableMap.builder();
        for (Map.Entry entry : map.entrySet()) {
            if (!(entry.getKey() instanceof String)) {
                LOGGER.warn("Invalid curve mnemonic: ({}) {}", entry.getKey().getClass(), entry.getKey());
                continue;
            }
            String mnemonic = (String) entry.getKey();

            T curve = this.curveFromEntry.apply(entry.getValue());
            if (curve == null){
                LOGGER.warn("Invalid curve {}: ({}) {}", mnemonic, entry.getValue().getClass(), entry.getValue());
                continue;
            }

            if (mnemonic.isEmpty() || !curve.isValid()) {
                LOGGER.warn("Invalid curve {}: {} ({})", mnemonic, curve, entry.getValue());
                continue;
            }

            builder = builder.put(mnemonic, curve);
        }
        return builder.build();
    }

    public Live.Action registerObserver(Live live, CurvesObserver observer) throws Exception {
        return observers.registerObserver(live, observer);
    }
}