/********************************************************************************
 * Copyright (c) 2015-2018 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.boundary.integrationtest;

import static io.restassured.RestAssured.given;
import static org.assertj.core.api.Assertions.tuple;
import static org.hamcrest.Matchers.equalTo;

import java.util.Arrays;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import javax.ws.rs.core.Response.Status;

import org.assertj.core.api.SoftAssertions;
import org.assertj.core.groups.Tuple;
import org.eclipse.mdm.businessobjects.boundary.ResourceConstants;
import org.eclipse.mdm.protobuf.Mdm;
import org.eclipse.mdm.protobuf.Mdm.AxisType;
import org.eclipse.mdm.protobuf.Mdm.BooleanArray;
import org.eclipse.mdm.protobuf.Mdm.ByteArray;
import org.eclipse.mdm.protobuf.Mdm.ByteStreamArray;
import org.eclipse.mdm.protobuf.Mdm.DateArray;
import org.eclipse.mdm.protobuf.Mdm.DoubleArray;
import org.eclipse.mdm.protobuf.Mdm.DoubleComplex;
import org.eclipse.mdm.protobuf.Mdm.DoubleComplexArray;
import org.eclipse.mdm.protobuf.Mdm.FloatArray;
import org.eclipse.mdm.protobuf.Mdm.FloatComplex;
import org.eclipse.mdm.protobuf.Mdm.FloatComplexArray;
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.MeasuredValuesList;
import org.eclipse.mdm.protobuf.Mdm.ScalarType;
import org.eclipse.mdm.protobuf.Mdm.ShortArray;
import org.eclipse.mdm.protobuf.Mdm.StringArray;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.DataCase;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.ExplicitData;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.ImplicitConstant;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.ImplicitLinear;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.ImplicitSaw;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.RawLinear;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.RawLinearCalibrated;
import org.eclipse.mdm.protobuf.Mdm.WriteRequestList.WriteRequest.RawPolynomial;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.primitives.Booleans;
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.gson.JsonObject;
import com.google.gson.JsonPrimitive;
import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Timestamp;
import com.google.protobuf.util.Timestamps;

import io.restassured.http.ContentType;
import io.restassured.response.ExtractableResponse;

/**
 * Test class for {@ChannelResource}.
 * 
 * @author Johannes Stamm, Peak Solution GmbH Nuernberg
 * @see EntityResourceIntegrationTest
 *
 */
public class ValuesResourceIntegrationTest extends ResourceIntegrationTest {

	public static final EnumSet<ScalarType> scalarTypes = EnumSet.of(ScalarType.STRING, ScalarType.DATE,
			ScalarType.BOOLEAN, ScalarType.BYTE, ScalarType.SHORT, ScalarType.INTEGER, ScalarType.LONG,
			ScalarType.FLOAT, ScalarType.DOUBLE, ScalarType.BYTE_STREAM, ScalarType.FLOAT_COMPLEX,
			ScalarType.DOUBLE_COMPLEX);

	private static final List<Boolean> SCALARTYPE_BOOLEAN = Booleans.asList(true, false, true);
	private static final ByteString SCALARTYPE_BYTES = ByteString
			.copyFrom(new byte[] { (byte) 0x01, (byte) 0xFF, (byte) 0xF1 });
	private static final List<Integer> SCALARTYPE_SHORTS = Ints.asList(12, 13, 14);
	private static final List<Integer> SCALARTYPE_INTEGER = Ints.asList(12, 13, 14);
	private static final List<Long> SCALARTYPE_LONG = Longs.asList(12L, 13L, 14L);
	private static final List<Float> SCALARTYPE_FLOAT = Floats.asList(12f, 13f, 14f);
	private static final List<Double> SCALARTYPE_DOUBLE = Doubles.asList(12.0, 13.0, 14.0);
	private static final List<FloatComplex> SCALARTYPE_FLOAT_COMPLEX = Arrays.asList(
			FloatComplex.newBuilder().setRe(12f).setIm(11f).build(),
			FloatComplex.newBuilder().setRe(13f).setIm(10f).build(),
			FloatComplex.newBuilder().setRe(14f).setIm(9f).build());
	private static final List<DoubleComplex> SCALARTYPE_DOUBLE_COMPLEX = Arrays.asList(
			DoubleComplex.newBuilder().setRe(12.0).setIm(11.0).build(),
			DoubleComplex.newBuilder().setRe(13.0).setIm(10.0).build(),
			DoubleComplex.newBuilder().setRe(14.0).setIm(9.0).build());
	private static final List<ByteString> SCALARTYPE_BYTE_STREAM = Arrays.asList(
			ByteString.copyFrom(new byte[] { (byte) 12, (byte) 11 }),
			ByteString.copyFrom(new byte[] { (byte) 13, (byte) 10 }),
			ByteString.copyFrom(new byte[] { (byte) 14, (byte) 9 }));
	private static final List<String> SCALARTYPE_STRING = Arrays.asList("one", "two", "three");
	private static final List<Timestamp> SCALARTYPE_DATE = Arrays.asList(Timestamps.fromMillis(1546300800000L),
			Timestamps.fromMillis(1546400800000L), Timestamps.fromMillis(1546500800000L));
	private static final List<Boolean> SCALARTYPE_FLAGS = Booleans.asList(true, true, true);

	private static final String MIMETYPE_APPLICATION_PROTOBUF = "application/protobuf";

	private static final Logger LOGGER = LoggerFactory.getLogger(ValuesResourceIntegrationTest.class);

	private static final int LENGTH = 5;

	private static final List<Integer> INTS = IntStream.range(0, LENGTH)
			.map(i -> (int) (10 * Math.sin((double) i / LENGTH * Math.PI))).boxed().collect(Collectors.toList());

	private static final List<Double> DOUBLES = IntStream.range(0, LENGTH)
			.mapToDouble(i -> 10 * Math.sin((double) i / LENGTH * Math.PI)).boxed().collect(Collectors.toList());

	private static final ExplicitData INT_DATA = ExplicitData.newBuilder()
			.setIntegerArray(IntegerArray.newBuilder().addAllValues(INTS)).build();

	private static final ExplicitData DOUBLE_DATA = ExplicitData.newBuilder()
			.setDoubleArray(DoubleArray.newBuilder().addAllValues(DOUBLES)).build();

	private static List<Boolean> FLAGS;

	@BeforeClass
	public static void prepareTestData() {
		LOGGER.debug("Preparing ValuesResourceIntegrationTest");

		boolean[] flagsArray = new boolean[LENGTH];
		Arrays.fill(flagsArray, true);
		FLAGS = Booleans.asList(flagsArray);

		// prepare test data for creating the parent Measurement
		MeasurementResourceIntegrationTest.prepareTestData();
		MeasurementResourceIntegrationTest.createEntity();
		// prepare test data for creating Quantity
		QuantityResourceIntegrationTest.prepareTestData();
		QuantityResourceIntegrationTest.createEntity();
	}

	@Test
	public void testAllDataSeqReps() throws InvalidProtocolBufferException {

		String channelGroupId = createChannelGroup();

		Map<String, DataCase> dataCaseChannelIds = createChannelsForDataCase();

		writeValuesAllSequenceRepresentations(channelGroupId, dataCaseChannelIds);

		// read MeasuredValues
		Mdm.ReadRequest readRequest = Mdm.ReadRequest.newBuilder().setChannelGroupId(channelGroupId).build();

		ExtractableResponse<io.restassured.response.Response> response = given()
				.contentType(MIMETYPE_APPLICATION_PROTOBUF).body(readRequest.toByteArray()).post("/values/read").then()
				.log().ifError().contentType(MIMETYPE_APPLICATION_PROTOBUF).statusCode(200).extract();

		Mdm.MeasuredValuesList mvl = Mdm.MeasuredValuesList.parseFrom(response.asByteArray());

		SoftAssertions softly = new SoftAssertions();
		assertExplicit(softly, mvl);
		assertImplicitConstant(softly, mvl);
		assertImplicitLinear(softly, mvl);
		assertImplicitSaw(softly, mvl);
		assertRawLinear(softly, mvl);
		assertRawPolynomial(softly, mvl);
		assertRawLinearCalibrated(softly, mvl);
		softly.assertAll();

		// read preview values
		int chunkSize = 2;

		Mdm.PreviewRequest previewRequest = Mdm.PreviewRequest.newBuilder()
				.setReadRequest(Mdm.ReadRequest.newBuilder().setChannelGroupId(channelGroupId))
				.setNumberOfChunks(chunkSize).build();

		ExtractableResponse<io.restassured.response.Response> previewResponse = given()
				.contentType(MIMETYPE_APPLICATION_PROTOBUF).body(previewRequest.toByteArray()).post("/values/preview")
				.then().log().ifError().contentType(MIMETYPE_APPLICATION_PROTOBUF).statusCode(200).extract();

		Mdm.PreviewValuesList pvl = Mdm.PreviewValuesList.parseFrom(previewResponse.asByteArray());

		List<String> channelNames = Arrays.asList("Channel_EXPLICIT", "Channel_IMPLICIT_CONSTANT",
				"Channel_IMPLICIT_LINEAR", "Channel_IMPLICIT_SAW", "Channel_RAW_LINEAR",
				"Channel_RAW_LINEAR_CALIBRATED", "Channel_RAW_POLYNOMIAL");

		SoftAssertions softly2 = new SoftAssertions();
		softly2.assertThat(pvl.getAvgList()).extracting(MeasuredValues::getName).containsAll(channelNames);
		softly2.assertThat(pvl.getMinList()).extracting(MeasuredValues::getName).containsAll(channelNames);
		softly2.assertThat(pvl.getMaxList()).extracting(MeasuredValues::getName).containsAll(channelNames);

		softly2.assertThat(pvl.getAvgList()).extracting(mv -> mv.getDoubleArray().getValuesCount())
				.containsOnly(chunkSize);
		softly2.assertThat(pvl.getMinList()).extracting(mv -> mv.getDoubleArray().getValuesCount())
				.containsOnly(chunkSize);
		softly2.assertThat(pvl.getMaxList()).extracting(mv -> mv.getDoubleArray().getValuesCount())
				.containsOnly(chunkSize);
		softly2.assertAll();
	}

	@Test
	public void testAllScalarTypes() throws InvalidProtocolBufferException {

		String channelGroupId = createChannelGroup();

		Map<String, ScalarType> scalarTypeChannelIds = createChannelsForScalarTypes();

		writeValuesAllScalarTypes(channelGroupId, scalarTypeChannelIds);

		// read MeasuredValues
		Mdm.ReadRequest readRequest = Mdm.ReadRequest.newBuilder().setChannelGroupId(channelGroupId).build();

		ExtractableResponse<io.restassured.response.Response> response = given()
				.contentType(MIMETYPE_APPLICATION_PROTOBUF).body(readRequest.toByteArray()).post("/values/read").then()
				.log().ifError().contentType(MIMETYPE_APPLICATION_PROTOBUF).statusCode(200).extract();

		Mdm.MeasuredValuesList mvl = Mdm.MeasuredValuesList.parseFrom(response.asByteArray());

		SoftAssertions softly = new SoftAssertions();
		assertBoolean(softly, mvl);
		assertByte(softly, mvl);
		assertShort(softly, mvl);
		assertInteger(softly, mvl);
		assertLong(softly, mvl);
		assertFloat(softly, mvl);
		assertDouble(softly, mvl);
		assertFloatComplex(softly, mvl);
		assertDoubleComplex(softly, mvl);
		assertByteStream(softly, mvl);
		assertString(softly, mvl);
		assertDate(softly, mvl);
		softly.assertAll();

		// read preview values
		int chunkSize = 2;

		Mdm.PreviewRequest previewRequest = Mdm.PreviewRequest.newBuilder()
				.setReadRequest(Mdm.ReadRequest.newBuilder().setChannelGroupId(channelGroupId))
				.setNumberOfChunks(chunkSize).build();

		ExtractableResponse<io.restassured.response.Response> previewResponse = given()
				.contentType(MIMETYPE_APPLICATION_PROTOBUF).body(previewRequest.toByteArray()).post("/values/preview")
				.then().log().ifError().contentType(MIMETYPE_APPLICATION_PROTOBUF).statusCode(200).extract();

		Mdm.PreviewValuesList pvl = Mdm.PreviewValuesList.parseFrom(previewResponse.asByteArray());

		Tuple[] previewChannelNames = new Tuple[] { tuple("Channel_BYTE", 2), tuple("Channel_SHORT", 2),
				tuple("Channel_INTEGER", 2), tuple("Channel_LONG", 2), tuple("Channel_FLOAT", 2),
				tuple("Channel_DOUBLE", 2), tuple("Channel_FLOAT_COMPLEX", 0), tuple("Channel_DOUBLE_COMPLEX", 0),
				tuple("Channel_BOOLEAN", 0), tuple("Channel_STRING", 0), tuple("Channel_BYTE_STREAM", 0),
				tuple("Channel_DATE", 0) };

		SoftAssertions softly2 = new SoftAssertions();
		softly2.assertThat(pvl.getAvgList()).extracting(mv -> tuple(mv.getName(), mv.getDoubleArray().getValuesCount()))
				.containsOnly(previewChannelNames);
		softly2.assertThat(pvl.getMinList()).extracting(mv -> tuple(mv.getName(), mv.getDoubleArray().getValuesCount()))
				.containsOnly(previewChannelNames);
		softly2.assertThat(pvl.getMaxList()).extracting(mv -> tuple(mv.getName(), mv.getDoubleArray().getValuesCount()))
				.containsOnly(previewChannelNames);

		// Date will return a DateArray instead of a DoubleArray
		softly2.assertThat(pvl.getAvgList()).extracting(mv -> tuple(mv.getName(), mv.getDateArray().getValuesCount()))
				.contains(tuple("Channel_DATE", 2));
		softly2.assertThat(pvl.getMinList()).extracting(mv -> tuple(mv.getName(), mv.getDateArray().getValuesCount()))
				.contains(tuple("Channel_DATE", 2));
		softly2.assertThat(pvl.getMaxList()).extracting(mv -> tuple(mv.getName(), mv.getDateArray().getValuesCount()))
				.contains(tuple("Channel_DATE", 2));

		softly2.assertAll();
	}

	private void writeValuesAllSequenceRepresentations(String channelGroupId, Map<String, DataCase> channelIds) {
		// write MeasuredValues
		WriteRequestList.Builder writeRequestList = WriteRequestList.newBuilder();

		for (Map.Entry<String, DataCase> entry : channelIds.entrySet()) {
			WriteRequest.Builder builder = WriteRequest.newBuilder().setChannelGroupId(channelGroupId)
					.setChannelId(entry.getKey()).setAxisTypeValue(AxisType.XY_AXIS_VALUE).setIndependent(false);
			switch (entry.getValue()) {
			case EXPLICIT:
				builder.setExplicit(INT_DATA);
				break;
			case IMPLICIT_CONSTANT:
				builder.setImplicitConstant(
						ImplicitConstant.newBuilder().setScalarType(ScalarType.INTEGER).setOffset(12));
				break;
			case IMPLICIT_LINEAR:
				builder.setImplicitLinear(
						ImplicitLinear.newBuilder().setScalarType(ScalarType.INTEGER).setStart(1).setIncrement(1));
				break;
			case IMPLICIT_SAW:
				builder.setImplicitSaw(ImplicitSaw.newBuilder().setScalarType(ScalarType.INTEGER).setStart(1)
						.setIncrement(1).setStop(5));
				break;
			case RAW_LINEAR:
				builder.setRawLinear(RawLinear.newBuilder().setScalarType(ScalarType.DOUBLE).setFactor(2).setOffset(10)
						.setValues(DOUBLE_DATA));
				break;
			case RAW_LINEAR_CALIBRATED:
				builder.setRawLinearCalibrated(RawLinearCalibrated.newBuilder().setScalarType(ScalarType.DOUBLE)
						.setOffset(1).setFactor(2).setCalibration(3).setValues(DOUBLE_DATA));
				break;
			case RAW_POLYNOMIAL:
				builder.setRawPolynomial(RawPolynomial.newBuilder().setScalarType(ScalarType.DOUBLE).addCoefficients(1)
						.addCoefficients(2).addCoefficients(3).setValues(DOUBLE_DATA));
				break;
			default:
				break;
			}

			writeRequestList.addValues(builder);
		}

		given().contentType(MIMETYPE_APPLICATION_PROTOBUF).body(writeRequestList.build().toByteArray())
				.post("/values/write").then().log().ifError().assertThat()
				.statusCode(Status.NO_CONTENT.getStatusCode());
	}

	private void writeValuesAllScalarTypes(String channelGroupId, Map<String, ScalarType> channelIds) {
		WriteRequestList.Builder writeRequestList = WriteRequestList.newBuilder();

		for (Entry<String, ScalarType> entry : channelIds.entrySet()) {
			WriteRequest.Builder builder = WriteRequest.newBuilder().setChannelGroupId(channelGroupId)
					.setChannelId(entry.getKey()).setAxisTypeValue(AxisType.XY_AXIS_VALUE).setIndependent(false);
			switch (entry.getValue()) {
			case STRING:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setStringArray(StringArray.newBuilder().addAllValues(SCALARTYPE_STRING)));
				break;
			case DATE:
				builder = builder.setExplicit(
						ExplicitData.newBuilder().setDateArray(DateArray.newBuilder().addAllValues(SCALARTYPE_DATE)));
				break;
			case BOOLEAN:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setBooleanArray(BooleanArray.newBuilder().addAllValues(SCALARTYPE_BOOLEAN)));
				break;
			case BYTE:
				builder = builder.setExplicit(
						ExplicitData.newBuilder().setByteArray(ByteArray.newBuilder().setValues(SCALARTYPE_BYTES)));
				break;
			case SHORT:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setShortArray(ShortArray.newBuilder().addAllValues(SCALARTYPE_SHORTS)));
				break;
			case INTEGER:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setIntegerArray(IntegerArray.newBuilder().addAllValues(SCALARTYPE_INTEGER)));
				break;
			case LONG:
				builder = builder.setExplicit(
						ExplicitData.newBuilder().setLongArray(LongArray.newBuilder().addAllValues(SCALARTYPE_LONG)));
				break;
			case FLOAT:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setFloatArray(FloatArray.newBuilder().addAllValues(SCALARTYPE_FLOAT)));
				break;
			case DOUBLE:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setDoubleArray(DoubleArray.newBuilder().addAllValues(SCALARTYPE_DOUBLE)));
				break;
			case BYTE_STREAM:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setByteStreamArray(ByteStreamArray.newBuilder().addAllValues(SCALARTYPE_BYTE_STREAM)));
				break;
			case FLOAT_COMPLEX:
				builder = builder.setExplicit(ExplicitData.newBuilder()
						.setFloatComplexArray(FloatComplexArray.newBuilder().addAllValues(SCALARTYPE_FLOAT_COMPLEX)));
				break;
			case DOUBLE_COMPLEX:
				builder = builder.setExplicit(ExplicitData.newBuilder().setDoubleComplexArray(
						DoubleComplexArray.newBuilder().addAllValues(SCALARTYPE_DOUBLE_COMPLEX)));
				break;
			default:
				throw new RuntimeException("The ScalarType " + entry.getValue() + " is not supported!");
			}

			writeRequestList.addValues(builder);
		}

		given().contentType(MIMETYPE_APPLICATION_PROTOBUF).body(writeRequestList.build().toByteArray())
				.post("/values/write").then().log().ifError().assertThat()
				.statusCode(Status.NO_CONTENT.getStatusCode());
	}

	private void assertBoolean(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_BOOLEAN".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_BOOLEAN")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_BOOLEAN.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.BOOLEAN)
						.setBooleanArray(BooleanArray.newBuilder().addAllValues(SCALARTYPE_BOOLEAN))
						.addAllFlags(SCALARTYPE_FLAGS).build());

	}

	private void assertByte(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_BYTE".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv).contains(Mdm.MeasuredValues.newBuilder().setName("Channel_BYTE")
				.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
				.setLength(SCALARTYPE_BYTES.size()).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.BYTE)
				.setByteArray(ByteArray.newBuilder().setValues(SCALARTYPE_BYTES)).addAllFlags(SCALARTYPE_FLAGS)
				.build());

	}

	private void assertShort(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_SHORT".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_SHORT")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_SHORTS.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.SHORT)
						.setShortArray(ShortArray.newBuilder().addAllValues(SCALARTYPE_SHORTS))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertInteger(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_INTEGER".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_INTEGER")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_INTEGER.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.INTEGER)
						.setIntegerArray(IntegerArray.newBuilder().addAllValues(SCALARTYPE_INTEGER))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertLong(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_LONG".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv).contains(Mdm.MeasuredValues.newBuilder().setName("Channel_LONG")
				.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
				.setLength(SCALARTYPE_LONG.size()).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.LONG)
				.setLongArray(LongArray.newBuilder().addAllValues(SCALARTYPE_LONG)).addAllFlags(SCALARTYPE_FLAGS)
				.build());
	}

	private void assertFloat(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_FLOAT".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_FLOAT")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_FLOAT.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.FLOAT)
						.setFloatArray(FloatArray.newBuilder().addAllValues(SCALARTYPE_FLOAT))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertDouble(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_DOUBLE".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_DOUBLE")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_DOUBLE.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.DOUBLE)
						.setDoubleArray(DoubleArray.newBuilder().addAllValues(SCALARTYPE_DOUBLE))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertFloatComplex(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_FLOAT_COMPLEX".equals(m.getName())).findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_FLOAT_COMPLEX")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_FLOAT.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.FLOAT_COMPLEX)
						.setFloatComplexArray(FloatComplexArray.newBuilder().addAllValues(SCALARTYPE_FLOAT_COMPLEX))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertDoubleComplex(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_DOUBLE_COMPLEX".equals(m.getName())).findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_DOUBLE_COMPLEX")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_DOUBLE.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.DOUBLE_COMPLEX)
						.setDoubleComplexArray(DoubleComplexArray.newBuilder().addAllValues(SCALARTYPE_DOUBLE_COMPLEX))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertByteStream(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_BYTE_STREAM".equals(m.getName())).findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_BYTE_STREAM")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_DOUBLE.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.BYTE_STREAM)
						.setByteStreamArray(ByteStreamArray.newBuilder().addAllValues(SCALARTYPE_BYTE_STREAM))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertString(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_STRING".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_STRING")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(SCALARTYPE_STRING.size()).setAxisType(Mdm.AxisType.XY_AXIS)
						.setScalarType(Mdm.ScalarType.STRING)
						.setStringArray(StringArray.newBuilder().addAllValues(SCALARTYPE_STRING))
						.addAllFlags(SCALARTYPE_FLAGS).build());
	}

	private void assertDate(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_DATE".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv).contains(Mdm.MeasuredValues.newBuilder().setName("Channel_DATE")
				.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
				.setLength(SCALARTYPE_DATE.size()).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.DATE)
				.setDateArray(DateArray.newBuilder().addAllValues(SCALARTYPE_DATE)).addAllFlags(SCALARTYPE_FLAGS)
				.build());
	}

	private void assertExplicit(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_EXPLICIT".equals(m.getName()))
				.findFirst();

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_EXPLICIT")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(LENGTH).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.INTEGER)
						.setIntegerArray(IntegerArray.newBuilder().addAllValues(INTS)).addAllFlags(FLAGS).build());

	}

	private void assertImplicitConstant(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_IMPLICIT_CONSTANT".equals(m.getName())).findFirst();

		List<Integer> constantValues = IntStream.range(0, LENGTH).map(i -> 12).boxed().collect(Collectors.toList());

		softly.assertThat(mv).contains(Mdm.MeasuredValues.newBuilder().setName("Channel_IMPLICIT_CONSTANT")
				.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME)).setLength(LENGTH)
				.setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.INTEGER)
				.setIntegerArray(IntegerArray.newBuilder().addAllValues(constantValues)).addAllFlags(FLAGS).build());

	}

	private void assertImplicitLinear(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_IMPLICIT_LINEAR".equals(m.getName())).findFirst();

		List<Integer> linearValues = IntStream.range(0, LENGTH).map(i -> i + 1).boxed().collect(Collectors.toList());

		softly.assertThat(mv).contains(Mdm.MeasuredValues.newBuilder().setName("Channel_IMPLICIT_LINEAR")
				.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME)).setLength(LENGTH)
				.setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.INTEGER)
				.setIntegerArray(IntegerArray.newBuilder().addAllValues(linearValues)).addAllFlags(FLAGS).build());

	}

	private void assertImplicitSaw(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_IMPLICIT_SAW".equals(m.getName())).findFirst();

		List<Integer> sawValues = IntStream.range(0, LENGTH).map(i -> i % 4 + 1).boxed().collect(Collectors.toList());

		softly.assertThat(mv)
				.contains(Mdm.MeasuredValues.newBuilder().setName("Channel_IMPLICIT_SAW")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(LENGTH).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.INTEGER)
						.setIntegerArray(IntegerArray.newBuilder().addAllValues(sawValues)).addAllFlags(FLAGS).build());

	}

	private void assertRawLinear(SoftAssertions softly, MeasuredValuesList mvl) throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream().filter(m -> "Channel_RAW_LINEAR".equals(m.getName()))
				.findFirst();

		List<Double> rawLinearValues = DOUBLES.stream().mapToDouble(d -> 2 * d + 10).boxed()
				.collect(Collectors.toList());

		softly.assertThat(mv).contains(Mdm.MeasuredValues.newBuilder().setName("Channel_RAW_LINEAR")
				.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME)).setLength(LENGTH)
				.setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.DOUBLE)
				.setDoubleArray(DoubleArray.newBuilder().addAllValues(rawLinearValues)).addAllFlags(FLAGS).build());
	}

	private void assertRawLinearCalibrated(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_RAW_LINEAR_CALIBRATED".equals(m.getName())).findFirst();

		List<Double> rawLinCalValues = DOUBLES.stream().mapToDouble(d -> (1 + 2 * d) * 3).boxed()
				.collect(Collectors.toList());

		softly.assertThat(mv.get())
				.isEqualToIgnoringGivenFields(Mdm.MeasuredValues.newBuilder().setName("Channel_RAW_LINEAR_CALIBRATED")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(LENGTH).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.DOUBLE)
						.setDoubleArray(DoubleArray.newBuilder().addAllValues(rawLinCalValues)).addAllFlags(FLAGS)
						.build(), "values", "values_", "memoizedIsInitialized");

		softly.assertThat(mv.get().getDoubleArray().getValuesList()).usingElementComparator(DOUBLE_COMP)
				.isEqualTo(rawLinCalValues);
	}

	private void assertRawPolynomial(SoftAssertions softly, MeasuredValuesList mvl)
			throws InvalidProtocolBufferException {

		Optional<MeasuredValues> mv = mvl.getValuesList().stream()
				.filter(m -> "Channel_RAW_POLYNOMIAL".equals(m.getName())).findFirst();

		List<Double> rawPolynomialValues = DOUBLES.stream().mapToDouble(d -> 1 + 2 * d + 3 * d * d).boxed()
				.collect(Collectors.toList());

		softly.assertThat(mv.get())
				.isEqualToIgnoringGivenFields(Mdm.MeasuredValues.newBuilder().setName("Channel_RAW_POLYNOMIAL")
						.setUnit(getTestDataValue(UnitResourceIntegrationTest.class, TESTDATA_ENTITY_NAME))
						.setLength(LENGTH).setAxisType(Mdm.AxisType.XY_AXIS).setScalarType(Mdm.ScalarType.DOUBLE)
						.setDoubleArray(DoubleArray.newBuilder().addAllValues(rawPolynomialValues)).addAllFlags(FLAGS)
						.build(), "values", "values_", "memoizedIsInitialized");

		softly.assertThat(mv.get().getDoubleArray().getValuesList()).usingElementComparator(DOUBLE_COMP)
				.isEqualTo(rawPolynomialValues);
	}

	private static Map<String, DataCase> createChannelsForDataCase() {
		// Create channels
		Map<String, DataCase> channelIds = new HashMap<>();
		for (DataCase dataCase : WriteRequest.DataCase.values()) {
			if (dataCase == DataCase.DATA_NOT_SET) {
				continue;
			}
			JsonObject json = new JsonObject();
			json.add(ResourceConstants.ENTITYATTRIBUTE_NAME, new JsonPrimitive("Channel_" + dataCase.name()));
			json.add("Measurement",
					new JsonPrimitive(getTestDataValue(MeasurementResourceIntegrationTest.class, TESTDATA_ENTITY_ID)));
			json.add("Quantity",
					new JsonPrimitive(getTestDataValue(QuantityResourceIntegrationTest.class, TESTDATA_ENTITY_ID)));

			ExtractableResponse<io.restassured.response.Response> response = given().contentType(ContentType.JSON)
					.body(json.toString()).post("/channels").then().log().ifError().contentType(ContentType.JSON)
					.extract();

			LOGGER.debug("Channel created " + response.asString());
			channelIds.put(response.path("data.first().id"), dataCase);
		}
		return channelIds;
	}

	private static Map<String, ScalarType> createChannelsForScalarTypes() {
		Map<String, ScalarType> channelIds = new HashMap<>();
		for (ScalarType scalarType : scalarTypes) {
			JsonObject json = new JsonObject();
			json.add(ResourceConstants.ENTITYATTRIBUTE_NAME, new JsonPrimitive("Channel_" + scalarType.name()));
			json.add("Measurement",
					new JsonPrimitive(getTestDataValue(MeasurementResourceIntegrationTest.class, TESTDATA_ENTITY_ID)));
			json.add("Quantity",
					new JsonPrimitive(getTestDataValue(QuantityResourceIntegrationTest.class, TESTDATA_ENTITY_ID)));

			ExtractableResponse<io.restassured.response.Response> response = given().contentType(ContentType.JSON)
					.body(json.toString()).post("/channels").then().log().ifError().contentType(ContentType.JSON)
					.extract();

			LOGGER.debug("Channel created " + response.asString());
			channelIds.put(response.path("data.first().id"), scalarType);
		}
		return channelIds;
	}

	private static String createChannelGroup() {
		// Create channelGroup
		JsonObject json = new JsonObject();
		json.add(ResourceConstants.ENTITYATTRIBUTE_NAME, new JsonPrimitive("ChannelGroup1"));
		json.add(TESTDATA_NUMBER_OF_VALUES, new JsonPrimitive(LENGTH));
		json.add("Measurement",
				new JsonPrimitive(getTestDataValue(MeasurementResourceIntegrationTest.class, TESTDATA_ENTITY_ID)));

		ExtractableResponse<io.restassured.response.Response> response = given().contentType(ContentType.JSON)
				.body(json.toString()).post("/channelgroups").then().log().ifError().contentType(ContentType.JSON)
				// do not check for name equality as that might be created randomly
				.and().body("data.first().type", equalTo("ChannelGroup")).extract();

		LOGGER.debug("ChannelGroup created " + response.asString());

		return response.path("data.first().id");
	}

	private static Comparator<Double> DOUBLE_COMP = new Comparator<Double>() {

		private double precision = 1E-6;

		@Override
		public int compare(Double o1, Double o2) {
			double diff = Math.abs(o1.doubleValue() - o2.doubleValue());
			if (diff <= precision)
				return 0;
			return diff < 0.0 ? -1 : 1;
		}

	};

	@AfterClass
	public static void tearDownAfterClass() {
		// call tearDownAfterClass() of parent entity
		QuantityResourceIntegrationTest.tearDownAfterClass();
		MeasurementResourceIntegrationTest.tearDownAfterClass();
	}
}