/********************************************************************************
 * Copyright (c) 2015-2019 Contributors to the Eclipse Foundation
 *
 * See the NOTICE file(s) distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0.
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 ********************************************************************************/
package org.eclipse.mdm.businessobjects.utils;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Arrays;
import java.util.List;

import org.assertj.core.util.DoubleComparator;
import org.eclipse.mdm.protobuf.Mdm.ByteArray;
import org.eclipse.mdm.protobuf.Mdm.DateArray;
import org.eclipse.mdm.protobuf.Mdm.DoubleArray;
import org.eclipse.mdm.protobuf.Mdm.FloatArray;
import org.eclipse.mdm.protobuf.Mdm.IntegerArray;
import org.eclipse.mdm.protobuf.Mdm.LongArray;
import org.eclipse.mdm.protobuf.Mdm.MeasuredValues;
import org.eclipse.mdm.protobuf.Mdm.PreviewValuesList;
import org.eclipse.mdm.protobuf.Mdm.ScalarType;
import org.eclipse.mdm.protobuf.Mdm.ShortArray;
import org.eclipse.mdm.protobuf.Mdm.StringArray;
import org.junit.Test;

import com.google.common.primitives.Doubles;
import com.google.common.primitives.Floats;
import com.google.common.primitives.Ints;
import com.google.common.primitives.Longs;
import com.google.protobuf.ByteString;
import com.google.protobuf.Timestamp;

public class PreviewHelperTest {

	private static final DoubleComparator COMP = new DoubleComparator(1.0E-6);

	private PreviewHelper helper = new PreviewHelper();

	private final List<String> stringValues = Arrays.asList("one", "two", "three", "four", "five", "six");
	private final MeasuredValues mv6Strings = MeasuredValues.newBuilder()
			.setStringArray(StringArray.newBuilder().addAllValues(stringValues)).setLength(stringValues.size()).build();

	private final ByteString byteValues = ByteString
			.copyFrom(new byte[] { (byte) 1, (byte) 2, (byte) 3, (byte) 1, (byte) 4, (byte) 2 });
	private final MeasuredValues mv6Bytes = MeasuredValues.newBuilder()
			.setByteArray(ByteArray.newBuilder().setValues(byteValues)).setLength(byteValues.size()).build();

	private final List<Integer> shortValues = Ints.asList(1, 2, 3, 1, 4, 2);
	private final MeasuredValues mv6Shorts = MeasuredValues.newBuilder()
			.setShortArray(ShortArray.newBuilder().addAllValues(shortValues)).setLength(shortValues.size()).build();

	private final List<Integer> intValues = Ints.asList(1, 2, 3, 1, 4, 2);
	private final MeasuredValues mv6Ints = MeasuredValues.newBuilder()
			.setIntegerArray(IntegerArray.newBuilder().addAllValues(intValues)).setLength(intValues.size()).build();

	private final List<Long> longValues = Longs.asList(1L, 2L, 3L, 1L, 4L, 2L);
	private final MeasuredValues mv6Longs = MeasuredValues.newBuilder()
			.setLongArray(LongArray.newBuilder().addAllValues(longValues)).setLength(longValues.size()).build();

	private final List<Float> floatValues = Floats.asList(1.0f, 2.0f, 3.0f, 1.1f, 4.4f, 2.2f);
	private final MeasuredValues mv6Floats = MeasuredValues.newBuilder()
			.setFloatArray(FloatArray.newBuilder().addAllValues(floatValues)).setLength(floatValues.size()).build();

	private final List<Double> doubleValues = Doubles.asList(1.0, 2.0, 3.0, 1.1, 4.4, 2.2);
	private final MeasuredValues mv6Doubles = MeasuredValues.newBuilder()
			.setDoubleArray(DoubleArray.newBuilder().addAllValues(doubleValues)).setLength(doubleValues.size()).build();

	@Test
	public void testInvalidNumberOfChunks() {

		assertThatThrownBy(() -> helper.calculatePreview(mv6Doubles, 0)).isInstanceOf(PreviewException.class)
				.hasMessage("Number of chunks requested must be positive!");

		assertThatThrownBy(() -> helper.calculatePreview(mv6Doubles, -1)).isInstanceOf(PreviewException.class)
				.hasMessage("Number of chunks requested must be positive!");
	}

	@Test
	public void testChunkSizeInteger() {
		PreviewValuesList pv = helper.calculatePreview(mv6Doubles, 2).build();
		assertThat(pv.getAvgCount()).isEqualTo(1);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.56666666666);
	}

	@Test
	public void testChunkSizeFloat() {
		PreviewValuesList pv = helper.calculatePreview(mv6Doubles, 4).build();

		assertThat(pv.getMinCount()).isEqualTo(1);
		assertThat(pv.getMaxCount()).isEqualTo(1);
		assertThat(pv.getAvgCount()).isEqualTo(1);

		assertThat(pv.getMin(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0, 3.0,
				1.1, 2.2);
		assertThat(pv.getMax(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0, 3.0,
				4.4, 2.2);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.5, 3.0,
				2.75, 2.2);
	}

	@Test
	public void testChunkSizeFloat2() {
		PreviewValuesList pv = helper.calculatePreview(mv6Doubles, 5).build();

		assertThat(pv.getMinCount()).isEqualTo(1);
		assertThat(pv.getMaxCount()).isEqualTo(1);
		assertThat(pv.getAvgCount()).isEqualTo(1);

		assertThat(pv.getMin(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0, 2.0,
				1.1, 4.4, 2.2);
		assertThat(pv.getMax(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0, 2.0,
				3.0, 4.4, 2.2);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0, 2.0,
				2.05, 4.4, 2.2);
	}

	@Test
	public void testNumberOfChunksEqualsNumberOfValues() {
		PreviewValuesList pv = helper.calculatePreview(mv6Doubles, 6).build();

		assertThat(pv.getMinCount()).isEqualTo(1);
		assertThat(pv.getMaxCount()).isEqualTo(1);
		assertThat(pv.getAvgCount()).isEqualTo(1);

		assertThat(pv.getMin(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).isEqualTo(doubleValues);
		assertThat(pv.getMax(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).isEqualTo(doubleValues);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).isEqualTo(doubleValues);
	}

	@Test
	public void testNumberOfChunksLargerThanNumberOfValues() {
		PreviewValuesList pv = helper.calculatePreview(mv6Doubles, 7).build();

		assertThat(pv.getMinCount()).isEqualTo(1);
		assertThat(pv.getMaxCount()).isEqualTo(1);
		assertThat(pv.getAvgCount()).isEqualTo(1);

		assertThat(pv.getMin(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).isEqualTo(doubleValues);
		assertThat(pv.getMax(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).isEqualTo(doubleValues);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).isEqualTo(doubleValues);
	}

	@Test
	public void testMultipleChannels() {
		PreviewValuesList pv = helper.calculatePreview(
				Arrays.asList(mv6Bytes, mv6Shorts, mv6Ints, mv6Longs, mv6Floats, mv6Doubles, mv6Strings), 2);

		assertThat(pv.getMinCount()).isEqualTo(7);
		assertThat(pv.getMaxCount()).isEqualTo(7);
		assertThat(pv.getAvgCount()).isEqualTo(7);

		assertThat(pv.getMin(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0,
				1.0);
		assertThat(pv.getMax(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				4.0);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.33333333333);

		assertThat(pv.getMin(1).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0,
				1.0);
		assertThat(pv.getMax(1).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				4.0);
		assertThat(pv.getAvg(1).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.33333333333);

		assertThat(pv.getMin(2).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0,
				1.0);
		assertThat(pv.getMax(2).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				4.0);
		assertThat(pv.getAvg(2).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.33333333333);

		assertThat(pv.getMin(3).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0,
				1.0);
		assertThat(pv.getMax(3).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				4.0);
		assertThat(pv.getAvg(3).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.33333333333);

		assertThat(pv.getMin(4).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0,
				1.1);
		assertThat(pv.getMax(4).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				4.4);
		assertThat(pv.getAvg(4).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.56666666666);

		assertThat(pv.getMin(5).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(1.0,
				1.1);
		assertThat(pv.getMax(5).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				4.4);
		assertThat(pv.getAvg(5).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				2.56666666666);

		assertThat(pv.getMin(6)).isEqualTo(MeasuredValues.newBuilder().setScalarType(ScalarType.DOUBLE).build());
		assertThat(pv.getMax(6)).isEqualTo(MeasuredValues.newBuilder().setScalarType(ScalarType.DOUBLE).build());
		assertThat(pv.getAvg(6)).isEqualTo(MeasuredValues.newBuilder().setScalarType(ScalarType.DOUBLE).build());
	}

	@Test
	public void testFlags() {
		MeasuredValues mv6IntsWithFlags = mv6Ints.toBuilder()
				.addAllFlags(Arrays.asList(false, true, true, true, false, false)).build();

		// 1, 2, 3, 1, 4, 2
		PreviewValuesList pv = helper.calculatePreview(mv6IntsWithFlags, 2).build();
		assertThat(pv.getAvgCount()).isEqualTo(1);
		assertThat(pv.getAvg(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.5,
				1.0);
		assertThat(pv.getMin(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(2.0,
				1.0);
		assertThat(pv.getMax(0).getDoubleArray().getValuesList()).usingElementComparator(COMP).containsExactly(3.0,
				1.0);
	}

	@Test
	public void testTimestamps() {

		final List<Timestamp> dateValues = Arrays.asList(toTimestamp("2019-02-01T06:30:00.500"),
				toTimestamp("2019-02-02T06:30:00.500"), toTimestamp("2019-02-03T06:30:00.500"),
				toTimestamp("2019-04-01T06:10:00.100"), toTimestamp("2019-04-01T07:40:00.200"),
				toTimestamp("2019-04-01T09:10:00.300"));
		final MeasuredValues mv6Dates = MeasuredValues.newBuilder()
				.setDateArray(DateArray.newBuilder().addAllValues(dateValues)).setLength(dateValues.size()).build();

		PreviewValuesList pv = helper.calculatePreview(mv6Dates, 2).build();
		assertThat(pv.getAvgCount()).isEqualTo(1);
		assertThat(pv.getMin(0).getDateArray().getValuesList()).containsExactly(toTimestamp("2019-02-01T06:30:00.500"),
				toTimestamp("2019-04-01T06:10:00.100"));
		assertThat(pv.getMax(0).getDateArray().getValuesList()).containsExactly(toTimestamp("2019-02-03T06:30:00.500"),
				toTimestamp("2019-04-01T09:10:00.300"));
		assertThat(pv.getAvg(0).getDateArray().getValuesList()).containsExactly(toTimestamp("2019-02-02T06:30:00.500"),
				toTimestamp("2019-04-01T07:40:00.200"));
	}

	@Test
	public void testTimestampFlags() {
		final List<Timestamp> dateValues = Arrays.asList(toTimestamp("2019-02-01T06:30:00.500"),
				toTimestamp("2019-02-02T06:30:00.500"), toTimestamp("2019-02-03T06:30:00.500"),
				toTimestamp("2019-04-01T06:10:00.100"), toTimestamp("2019-04-01T07:40:00.200"),
				toTimestamp("2019-04-01T09:10:00.300"));
		final MeasuredValues mv6Dates = MeasuredValues.newBuilder()
				.setDateArray(DateArray.newBuilder().addAllValues(dateValues)).setLength(dateValues.size())
				.addAllFlags(Arrays.asList(false, true, true, true, false, false)).build();

		PreviewValuesList pv = helper.calculatePreview(mv6Dates, 2).build();
		assertThat(pv.getAvgCount()).isEqualTo(1);
		assertThat(pv.getMin(0).getDateArray().getValuesList()).containsExactly(toTimestamp("2019-02-02T06:30:00.500"),
				toTimestamp("2019-04-01T06:10:00.100"));
		assertThat(pv.getMax(0).getDateArray().getValuesList()).containsExactly(toTimestamp("2019-02-03T06:30:00.500"),
				toTimestamp("2019-04-01T06:10:00.100"));
		assertThat(pv.getAvg(0).getDateArray().getValuesList()).containsExactly(toTimestamp("2019-02-02T18:30:00.500"),
				toTimestamp("2019-04-01T06:10:00.100"));
	}

	private Timestamp toTimestamp(String datetime) {
		Instant instant = LocalDateTime.parse(datetime).toInstant(ZoneOffset.UTC);

		return Timestamp.newBuilder().setSeconds(instant.getEpochSecond()).setNanos(instant.getNano()).build();
	}
}