[NP] WeatherStation

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.Comparator;
import java.util.Date;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.function.Predicate;

public class WeatherStationTest {
    public static void main(String[] args) throws ParseException {
        Scanner scanner = new Scanner(System.in);
        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss");
        int n = scanner.nextInt();
        scanner.nextLine();
        WeatherStation ws = new WeatherStation(n);
        while (true) {
            String line = scanner.nextLine();
            if (line.equals("=====")) {
                break;
            }
            String[] parts = line.split(" ");
            float temp = Float.parseFloat(parts[0]);
            float wind = Float.parseFloat(parts[1]);
            float hum = Float.parseFloat(parts[2]);
            float vis = Float.parseFloat(parts[3]);
            line = scanner.nextLine();
            LocalDateTime date = LocalDateTime.parse(line, timeFormatter);
            ws.addMeasurement(temp, wind, hum, vis, date);
        }
        String line = scanner.nextLine();
        LocalDateTime from = LocalDateTime.parse(line, timeFormatter);
        line = scanner.nextLine();
        LocalDateTime to = LocalDateTime.parse(line, timeFormatter);
        scanner.close();
        System.out.println(ws.total());
        try {
            ws.status(from, to);
        } catch (RuntimeException e) {
            System.out.println(e);
        }
    }
}

class WeatherStation {

    TreeSet<Measurement> measurements;
    int days;

    WeatherStation(int days) {
        this.days = days;
        measurements = new TreeSet<>();
    }

    public void addMeasurement(float temperature, float wind, float humidity, float visibility, LocalDateTime date) {
        Measurement measurement = new Measurement(temperature, wind, humidity, visibility, date);
        if (!measurements.add(measurement)) {
            return;
        }

        Predicate<Measurement> isOld = m -> m.date.minusDays(days).isAfter(date);

        measurements.removeIf(isOld);
    }

    public int total() {
        return measurements.size();
    }

    public void status(LocalDateTime from, LocalDateTime to) {
        /* Apparently this is wrong.. */
        //Predicate<Measurement> isInRange = (measurement -> measurement.date.isAfter(from) && measurement.date.isBefore(to));
        Predicate<Measurement> isInRange = measurement -> !(measurement.date.isBefore(from) || measurement.date.isAfter(to));
        measurements.stream()
                .filter(isInRange)
                .forEach(System.out::println);

        double avgTemperature = measurements.stream()
                .filter(isInRange)
                .mapToDouble(Measurement::getTemperature)
                .average()
                .orElse(0);

        System.out.printf("Average temperature: %.2f\n", avgTemperature);
    }

    public double avgTemperature() {
        return measurements.stream()
                .mapToDouble(Measurement::getTemperature)
                .average()
                .orElse(0);
    }

}

class Measurement implements Comparable<Measurement> {
    float temperature;
    float wind;
    float humidity;
    float visibility;
    LocalDateTime date;

    public Measurement(float temperature, float wind, float humidity, float visibility, LocalDateTime date) {
        this.temperature = temperature;
        this.wind = wind;
        this.humidity = humidity;
        this.visibility = visibility;
        this.date = date;
    }

    public float getTemperature() {
        return temperature;
    }

    @Override
    public int compareTo(Measurement that) {
        /* 2.5 minutes = 120 sec + 30 sec = 150 sec */
        long span = Math.abs(that.date.until(this.date, ChronoUnit.SECONDS));
        if (span < 150) {
            return 0;
        }
        return this.date.compareTo(that.date);
    }

    @Override
    public String toString() {
        //DateTimeFormatter dtf = DateTimeFormatter.ofPattern("E L ");
        //dtf.format(
        return String.format("%.1f %.1f km/h %.1f%% %.1f km %s", temperature,
                wind, humidity, visibility, date);
    }
}