telemetry/src/main/java/cz/senslog/telemetry/database/validation/UnitTelemetryValidation.java

package cz.senslog.telemetry.database.validation;

import cz.senslog.telemetry.database.domain.Campaign;
import cz.senslog.telemetry.database.domain.Sensor;
import cz.senslog.telemetry.database.domain.UnitTelemetry;
import cz.senslog.telemetry.utils.ComparisonOperators;
import cz.senslog.telemetry.utils.Tuple;
import io.vertx.core.json.JsonObject;

import java.time.OffsetDateTime;
import java.util.*;

import static cz.senslog.telemetry.utils.ComparisonOperators.ofBoundary;
import static java.util.stream.Collectors.*;

public class UnitTelemetryValidation {

    public static boolean isTelemetryWithinCampaign(Campaign campaign, UnitTelemetry telemetry) {
        return ofBoundary(campaign.getFromTime(), campaign.getToTime()).isWithinEqual(telemetry.getTimestamp());
    }

    public static List<UnitTelemetry> telemetriesWithinCampaign(Campaign campaign, List<UnitTelemetry> telemetries) {
        ComparisonOperators.BoundaryComparison campBound = ofBoundary(campaign.getFromTime(), campaign.getToTime());
        OffsetDateTime firstTelTime = telemetries.get(0).getTimestamp();
        OffsetDateTime lastTelTime = telemetries.get(telemetries.size() - 1).getTimestamp();

        if (campBound.isWithinEqual(firstTelTime) && campBound.isWithinEqual(lastTelTime)) {
            return telemetries;
        }

        return telemetries.stream().filter(v -> campBound.isWithinEqual(v.getTimestamp())).collect(toList());
    }

    public static List<UnitTelemetry> telemetriesAccToSensors(Map<Long, List<Sensor>> sensorsByUnitId, List<UnitTelemetry> telemetries) {
        List<UnitTelemetry> newTelemetries = new ArrayList<>(telemetries.size());
        Map<Long, Tuple<Set<String>, Map<String, String>>> sensorSetByUnitId = new HashMap<>(sensorsByUnitId.size());
        for (Map.Entry<Long, List<Sensor>> sensorsEntry : sensorsByUnitId.entrySet()) {
            int sensorsCount = sensorsEntry.getValue().size();
            Set<String> sensorsId = new HashSet<>(sensorsCount);
            Map<String, String> sensorsName = new HashMap<>(sensorsCount);
            for (Sensor sensor : sensorsEntry.getValue()) {
                String sensorId = Long.toString(sensor.getSensorId());
                sensorsId.add(sensorId);
                sensorsName.put(sensor.getName(), sensorId);
            }
            sensorSetByUnitId.put(sensorsEntry.getKey(), Tuple.of(sensorsId, sensorsName));
        }

        for (UnitTelemetry tel : telemetries) {
            Tuple<Set<String>, Map<String, String>> unitSensors = sensorSetByUnitId.get(tel.getUnitId());
            if (unitSensors == null) continue;

            Set<String> sensorIDs = unitSensors.item1();
            Map<String, String> sensorNames = unitSensors.item2();

            JsonObject newObservedValues = JsonObject.of();
            for (Map.Entry<String, Object> observedValue : tel.getObservedValues()) {
                String key = observedValue.getKey();
                if (sensorIDs.contains(key)) {
                    newObservedValues.put(key, observedValue.getValue());
                } else if (sensorNames.containsKey(key)) {
                    newObservedValues.put(sensorNames.get(key), observedValue.getValue());
                }
            }

            if (!newObservedValues.isEmpty()) {
                newTelemetries.add(UnitTelemetry.of(
                        tel.getUnitId(),
                        tel.getTimestamp(),
                        tel.getLocation(),
                        tel.getSpeed(),
                        newObservedValues
                ));
            }
        }
        return newTelemetries;
    }
}