/********************************************************************************
 * 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.api.odsadapter.utils;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoField;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.asam.ods.Blob;
import org.asam.ods.DataType;
import org.asam.ods.NameValueSeqUnit;
import org.asam.ods.TS_Union;
import org.asam.ods.TS_UnionSeq;
import org.asam.ods.TS_Value;
import org.asam.ods.TS_ValueSeq;
import org.asam.ods.T_COMPLEX;
import org.asam.ods.T_DCOMPLEX;
import org.asam.ods.T_ExternalReference;
import org.asam.ods.T_LONGLONG;
import org.eclipse.mdm.api.base.adapter.Attribute;
import org.eclipse.mdm.api.base.model.DoubleComplex;
import org.eclipse.mdm.api.base.model.FileLink;
import org.eclipse.mdm.api.base.model.FloatComplex;
import org.eclipse.mdm.api.base.model.MeasuredValues;
import org.eclipse.mdm.api.base.model.MimeType;
import org.eclipse.mdm.api.base.model.ScalarType;
import org.eclipse.mdm.api.base.model.Value;
import org.eclipse.mdm.api.base.model.ValueType;
import org.eclipse.mdm.api.base.query.Aggregation;
import org.eclipse.mdm.api.base.query.DataAccessException;
import org.eclipse.mdm.api.odsadapter.ReadRequestHandler;
import org.eclipse.mdm.api.odsadapter.query.ODSAttribute;

import com.google.common.collect.Sets;

/**
 * Utility class for value conversions from/to ODS types.
 *
 * @since 1.0.0
 * @author Viktor Stoehr, Gigatronik Ingolstadt GmbH
 */
public final class ODSConverter {

	// ======================================================================
	// Class variables
	// ======================================================================

	private static final Map<Integer, DateTimeFormatter> ODS_DATE_FORMATTERS = new HashMap<>();

	static {
		ODS_DATE_FORMATTERS.put(4,
				new DateTimeFormatterBuilder().appendPattern("yyyy").parseDefaulting(ChronoField.MONTH_OF_YEAR, 1)
						.parseDefaulting(ChronoField.DAY_OF_MONTH, 1).toFormatter());
		ODS_DATE_FORMATTERS.put(6, new DateTimeFormatterBuilder().appendPattern("yyyyMM")
				.parseDefaulting(ChronoField.DAY_OF_MONTH, 1).toFormatter());
		ODS_DATE_FORMATTERS.put(8, DateTimeFormatter.ofPattern("yyyyMMdd"));
		ODS_DATE_FORMATTERS.put(10, DateTimeFormatter.ofPattern("yyyyMMddHH"));
		ODS_DATE_FORMATTERS.put(12, DateTimeFormatter.ofPattern("yyyyMMddHHmm"));
		ODS_DATE_FORMATTERS.put(14, DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
		/*
		 * JDK-8031085: DateTimeFormatter won't parse dates with custom format
		 * "yyyyMMddHHmmssSSS"
		 * 
		 * @see http://bugs.java.com/bugdatabase/view_bug.do?bug_id=8031085
		 */
		ODS_DATE_FORMATTERS.put(17, new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss")
				.appendValue(ChronoField.MILLI_OF_SECOND, 3).toFormatter());
	}

	// ======================================================================
	// Constructors
	// ======================================================================

	/**
	 * Constructor.
	 */
	private ODSConverter() {
	}

	// ======================================================================
	// Conversion methods
	// ======================================================================

	/**
	 * Converts given {@link TS_ValueSeq} to {@link Value}s.
	 *
	 * @param attribute   The {@link Attribute}.
	 * @param aggregation The {@link Aggregation} used when the values were
	 *                    obtained.
	 * @param unit        The unit name.
	 * @param odsValueSeq The {@code TS_ValueSeq}.
	 * @return The converted {@code Value}s are returned.
	 * @throws DataAccessException Thrown on conversion errors.
	 */
	public static List<Value> fromODSValueSeq(Attribute attribute, Aggregation aggregation, String unit,
			TS_ValueSeq odsValueSeq) throws DataAccessException {
		DataType dataType = odsValueSeq.u.discriminator();
		short[] flags = odsValueSeq.flag;
		List<Value> values = new ArrayList<>(flags.length);

		if (((ODSAttribute) attribute).isIdAttribute() && Sets
				.immutableEnumSet(Aggregation.MINIMUM, Aggregation.MAXIMUM, Aggregation.DISTINCT, Aggregation.NONE)
				.contains(aggregation)) {
			if (DataType.DT_LONGLONG == dataType) {
				T_LONGLONG[] odsValues = odsValueSeq.u.longlongVal();
				for (int i = 0; i < flags.length; i++) {
					values.add(createValue(attribute, aggregation, DataType.DT_STRING, unit, flags[i] == 15,
							Long.toString(fromODSLong(odsValues[i]))));
				}
				return values;
			} else if (DataType.DS_LONGLONG == dataType) {
				T_LONGLONG[][] odsValues = odsValueSeq.u.longlongSeq();
				for (int i = 0; i < flags.length; i++) {
					values.add(createValue(attribute, aggregation, DataType.DS_STRING, unit, flags[i] == 15,
							toString(odsValues[i])));
				}
				return values;
			} else if (DataType.DT_LONG == dataType) {
				int[] odsValues = odsValueSeq.u.longVal();
				for (int i = 0; i < flags.length; i++) {
					values.add(createValue(attribute, aggregation, DataType.DT_STRING, unit, flags[i] == 15,
							Integer.toString(odsValues[i])));
				}
				return values;
			} else if (DataType.DS_LONG == dataType) {
				int[][] odsValues = odsValueSeq.u.longSeq();
				for (int i = 0; i < flags.length; i++) {
					values.add(createValue(attribute, aggregation, DataType.DS_STRING, unit, flags[i] == 15,
							toString(odsValues[i])));
				}
				return values;
			}
		}

		if (DataType.DT_STRING == dataType) {
			String[] odsValues = odsValueSeq.u.stringVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_STRING == dataType) {
			String[][] odsValues = odsValueSeq.u.stringSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_DATE == dataType) {
			String[] odsValues = odsValueSeq.u.dateVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(
						createValue(attribute, aggregation, dataType, unit, flags[i] == 15, fromODSDate(odsValues[i])));
			}
		} else if (DataType.DS_DATE == dataType) {
			String[][] odsValues = odsValueSeq.u.dateSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSDateSeq(odsValues[i])));
			}
		} else if (DataType.DT_BOOLEAN == dataType) {
			boolean[] odsValues = odsValueSeq.u.booleanVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_BOOLEAN == dataType) {
			boolean[][] odsValues = odsValueSeq.u.booleanSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_BYTE == dataType) {
			byte[] odsValues = odsValueSeq.u.byteVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_BYTE == dataType) {
			byte[][] odsValues = odsValueSeq.u.byteSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_SHORT == dataType) {
			short[] odsValues = odsValueSeq.u.shortVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_SHORT == dataType) {
			short[][] odsValues = odsValueSeq.u.shortSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_LONG == dataType) {
			int[] odsValues = odsValueSeq.u.longVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_LONG == dataType) {
			int[][] odsValues = odsValueSeq.u.longSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_LONGLONG == dataType) {
			T_LONGLONG[] odsValues = odsValueSeq.u.longlongVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(
						createValue(attribute, aggregation, dataType, unit, flags[i] == 15, fromODSLong(odsValues[i])));
			}
		} else if (DataType.DS_LONGLONG == dataType) {
			T_LONGLONG[][] odsValues = odsValueSeq.u.longlongSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSLongSeq(odsValues[i])));
			}
		} else if (DataType.DT_FLOAT == dataType) {
			float[] odsValues = odsValueSeq.u.floatVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_FLOAT == dataType) {
			float[][] odsValues = odsValueSeq.u.floatSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_DOUBLE == dataType) {
			double[] odsValues = odsValueSeq.u.doubleVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_DOUBLE == dataType) {
			double[][] odsValues = odsValueSeq.u.doubleSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_BYTESTR == dataType) {
			byte[][] odsValues = odsValueSeq.u.bytestrVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DS_BYTESTR == dataType) {
			byte[][][] odsValues = odsValueSeq.u.bytestrSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15, odsValues[i]));
			}
		} else if (DataType.DT_COMPLEX == dataType) {
			T_COMPLEX[] odsValues = odsValueSeq.u.complexVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSFloatComplex(odsValues[i])));
			}
		} else if (DataType.DS_COMPLEX == dataType) {
			T_COMPLEX[][] odsValues = odsValueSeq.u.complexSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSFloatComplexSeq(odsValues[i])));
			}
		} else if (DataType.DT_DCOMPLEX == dataType) {
			T_DCOMPLEX[] odsValues = odsValueSeq.u.dcomplexVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSDoubleComplex(odsValues[i])));
			}
		} else if (DataType.DS_DCOMPLEX == dataType) {
			T_DCOMPLEX[][] odsValues = odsValueSeq.u.dcomplexSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSDoubleComplexSeq(odsValues[i])));
			}
		} else if (DataType.DT_ENUM == dataType) {
			int[] odsValues = odsValueSeq.u.enumVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						ODSEnumerations.fromODSEnum(attribute.getEnumObj(), odsValues[i])));
			}
		} else if (DataType.DS_ENUM == dataType) {
			int[][] odsValues = odsValueSeq.u.enumSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						ODSEnumerations.fromODSEnumSeq(attribute.getEnumObj(), odsValues[i])));
			}
		} else if (DataType.DT_EXTERNALREFERENCE == dataType) {
			T_ExternalReference[] odsValues = odsValueSeq.u.extRefVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSExternalReference(odsValues[i])));
			}
		} else if (DataType.DS_EXTERNALREFERENCE == dataType) {
			T_ExternalReference[][] odsValues = odsValueSeq.u.extRefSeq();
			for (int i = 0; i < flags.length; i++) {
				values.add(createValue(attribute, aggregation, dataType, unit, flags[i] == 15,
						fromODSExternalReferenceSeq(odsValues[i])));
			}
		} else if (DataType.DT_BLOB == dataType) {
			Blob[] odsValues = odsValueSeq.u.blobVal();
			for (int i = 0; i < flags.length; i++) {
				values.add(
						createValue(attribute, aggregation, dataType, unit, flags[i] == 15, fromODSBlob(odsValues[i])));
			}
		} else {
			throw new DataAccessException("Conversion for ODS data type '" + dataType.toString() + "' does not exist.");
		}

		return values;
	}

	/**
	 * Creates a {@link Value} from the input.
	 * 
	 * @param attribute   The {@link Attribute}
	 * @param aggregation The {@link Aggregation} used when the input values were
	 *                    obtained
	 * @param dataType    The {@link DataType} associated with the input value,
	 *                    evaluated only if aggregation != {@code Aggregation.NONE},
	 *                    otherwise that of the attribute is used
	 * @param unit        The unit of the input value
	 * @param valid       The validity flag of the input value
	 * @param input       The input value
	 * @return The {@link Value} created.
	 */
	private static Value createValue(Attribute attribute, Aggregation aggregation, DataType dataType, String unit,
			boolean valid, Object input) {
		if (Aggregation.NONE == aggregation) {
			return attribute.createValue(unit, valid, input);
		} else {
			ValueType<?> valueType = ODSUtils.VALUETYPES.inverse().get(dataType);
			if (valueType.isEnumerationType() && attribute.getValueType().isEnumerationType()
					&& Sets.immutableEnumSet(Aggregation.MINIMUM, Aggregation.MAXIMUM, Aggregation.DISTINCT)
							.contains(aggregation)) {
				return valueType.create(getColumnName(attribute, aggregation), unit, valid, input,
						attribute.getEnumObj().getName());
			} else {
				return valueType.create(getColumnName(attribute, aggregation), unit, valid, input);
			}
		}
	}

	/**
	 * Returns the name of the attribute with its applied aggregation as returned by
	 * the ODS Server, for example: MAXIMUM(sortIndex)
	 * 
	 * @param attribute
	 * @param aggregation
	 * @return the name of the attribute with the applied aggragation
	 */
	public static String getColumnName(Attribute attribute, Aggregation aggregation) {
		return String.format("%s(%s)", aggregation.name(), attribute.getName());
	}

	private static String[] toString(int[] odsValues) {
		return IntStream.of(odsValues).mapToObj(Integer::toString).toArray(String[]::new);
	}

	private static String[] toString(T_LONGLONG[] odsValues) {
		return Stream.of(odsValues).map(l -> Long.toString(fromODSLong(l))).toArray(String[]::new);
	}

	/**
	 * Converts given {@link Value}s to {@link TS_ValueSeq}.
	 *
	 * @param values The {@code Value}s.
	 * @return The converted {@code TS_ValueSeq} is returned.
	 * @throws DataAccessException Thrown on conversion errors.
	 */
	public static TS_ValueSeq toODSValueSeq(Attribute attribute, List<Value> values) throws DataAccessException {
		int size = values == null ? 0 : values.size();
		short[] flags = new short[size];

		TS_ValueSeq odsValueSeq = new TS_ValueSeq(new TS_UnionSeq(), flags);
		if (values == null || size < 1) {
			odsValueSeq.u._default();
			return odsValueSeq;
		}

		ValueType<?> type = values.get(0).getValueType();
		if (ValueType.STRING == type) {
			String[] odsValues = new String[size];
			for (int i = 0; i < size; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			if (((ODSAttribute) attribute).isIdAttribute()) {
				odsValueSeq.u.longlongVal(toLongLong(odsValues));
			} else {
				odsValueSeq.u.stringVal(odsValues);
			}
		} else if (ValueType.STRING_SEQUENCE == type) {
			String[][] odsValues = new String[size][];
			for (int i = 0; i < size; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			if (((ODSAttribute) attribute).isIdAttribute()) {
				odsValueSeq.u.longlongSeq(toLongLongSeq(odsValues));
			} else {
				odsValueSeq.u.stringSeq(odsValues);
			}

		} else if (ValueType.DATE == type) {
			String[] odsValues = new String[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSDate(value.extract());
			}
			odsValueSeq.u.dateVal(odsValues);
		} else if (ValueType.DATE_SEQUENCE == type) {
			String[][] odsValues = new String[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSDateSeq(value.extract());
			}
			odsValueSeq.u.dateSeq(odsValues);
		} else if (ValueType.BOOLEAN == type) {
			boolean[] odsValues = new boolean[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.booleanVal(odsValues);
		} else if (ValueType.BOOLEAN_SEQUENCE == type) {
			boolean[][] odsValues = new boolean[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.booleanSeq(odsValues);
		} else if (ValueType.BYTE == type) {
			byte[] odsValues = new byte[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.byteVal(odsValues);
		} else if (ValueType.BYTE_SEQUENCE == type) {
			byte[][] odsValues = new byte[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.byteSeq(odsValues);
		} else if (ValueType.SHORT == type) {
			short[] odsValues = new short[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.shortVal(odsValues);
		} else if (ValueType.SHORT_SEQUENCE == type) {
			short[][] odsValues = new short[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.shortSeq(odsValues);
		} else if (ValueType.INTEGER == type) {
			int[] odsValues = new int[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.longVal(odsValues);
		} else if (ValueType.INTEGER_SEQUENCE == type) {
			int[][] odsValues = new int[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.longSeq(odsValues);
		} else if (ValueType.LONG == type) {
			T_LONGLONG[] odsValues = new T_LONGLONG[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSLong(value.extract());
			}
			odsValueSeq.u.longlongVal(odsValues);
		} else if (ValueType.LONG_SEQUENCE == type) {
			T_LONGLONG[][] odsValues = new T_LONGLONG[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSLongSeq(value.extract());
			}
			odsValueSeq.u.longlongSeq(odsValues);
		} else if (ValueType.FLOAT == type) {
			float[] odsValues = new float[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.floatVal(odsValues);
		} else if (ValueType.FLOAT_SEQUENCE == type) {
			float[][] odsValues = new float[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.floatSeq(odsValues);
		} else if (ValueType.DOUBLE == type) {
			double[] odsValues = new double[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.doubleVal(odsValues);
		} else if (ValueType.DOUBLE_SEQUENCE == type) {
			double[][] odsValues = new double[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.doubleSeq(odsValues);
		} else if (ValueType.BYTE_STREAM == type) {
			byte[][] odsValues = new byte[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.bytestrVal(odsValues);
		} else if (ValueType.BYTE_STREAM_SEQUENCE == type) {
			byte[][][] odsValues = new byte[size][][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = value.extract();
			}
			odsValueSeq.u.bytestrSeq(odsValues);
		} else if (ValueType.FLOAT_COMPLEX == type) {
			T_COMPLEX[] odsValues = new T_COMPLEX[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSFloatComplex(value.extract());
			}
			odsValueSeq.u.complexVal(odsValues);
		} else if (ValueType.FLOAT_COMPLEX_SEQUENCE == type) {
			T_COMPLEX[][] odsValues = new T_COMPLEX[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSFloatComplexSeq(value.extract());
			}
			odsValueSeq.u.complexSeq(odsValues);
		} else if (ValueType.DOUBLE_COMPLEX == type) {
			T_DCOMPLEX[] odsValues = new T_DCOMPLEX[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSDoubleComplex(value.extract());
			}
			odsValueSeq.u.dcomplexVal(odsValues);
		} else if (ValueType.DOUBLE_COMPLEX_SEQUENCE == type) {
			T_DCOMPLEX[][] odsValues = new T_DCOMPLEX[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSDoubleComplexSeq(value.extract());
			}
			odsValueSeq.u.dcomplexSeq(odsValues);
		} else if (ValueType.ENUMERATION == type) {
			int[] odsValues = new int[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = ODSEnumerations.toODSEnum(value.extract());
			}
			odsValueSeq.u.enumVal(odsValues);
		} else if (ValueType.ENUMERATION_SEQUENCE == type) {
			int[][] odsValues = new int[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = ODSEnumerations.toODSEnumSeq(value.extract());
			}
			odsValueSeq.u.enumSeq(odsValues);
		} else if (ValueType.FILE_LINK == type) {
			T_ExternalReference[] odsValues = new T_ExternalReference[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSExternalReference(value.extract());
			}
			odsValueSeq.u.extRefVal(odsValues);
		} else if (ValueType.FILE_LINK_SEQUENCE == type) {
			T_ExternalReference[][] odsValues = new T_ExternalReference[size][];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSExternalReferenceSeq(value.extract());
			}
			odsValueSeq.u.extRefSeq(odsValues);
		} else if (ValueType.BLOB == type) {
			Blob[] odsValues = new Blob[size];
			for (int i = 0; i < flags.length; i++) {
				Value value = values.get(i);
				flags[i] = toODSValidFlag(value.isValid());
				odsValues[i] = toODSBlob(value.extract());
			}
			odsValueSeq.u.blobVal(odsValues);
		} else {
			throw new DataAccessException("Mapping for value type '" + type + "' does not exist.");
		}

		return odsValueSeq;
	}

	/**
	 * Converts given two dimensional String array to two dimensional
	 * {@link T_LONGLONG} array.
	 * 
	 * @param value The String array.
	 * @return The converted {@link T_LONGLONG} array.
	 */
	private static T_LONGLONG[][] toLongLongSeq(String[][] value) {

		return Stream.of(value).map(ODSConverter::toLongLong).toArray(T_LONGLONG[][]::new);
	}

	/**
	 * Converts given String array to {@link T_LONGLONG} array.
	 * 
	 * @param value The String array.
	 * @return The converted {@link T_LONGLONG} array.
	 */
	private static T_LONGLONG[] toLongLong(String[] value) {
		return Stream.of(value).map(s -> toODSID(s)).toArray(T_LONGLONG[]::new);
	}

	/**
	 * Converts given {@link NameValueSeqUnit[]} to {@link MeasuredValues}s.
	 *
	 * @param odsMeasuredValuesSeq The {@code NameValueSeqUnit}s.
	 * @return The converted {@code MeasuredValues}s are returned.
	 * @throws DataAccessException Thrown on conversion errors.
	 */
	public static List<MeasuredValues> fromODSMeasuredValuesSeq(NameValueSeqUnit[] odsMeasuredValuesSeq,
			ReadRequestHandler.ColumnAttributes[] columnAttributesArray) throws DataAccessException {
		List<MeasuredValues> measuredValues = new ArrayList<>(odsMeasuredValuesSeq.length);

		Map<String, ReadRequestHandler.ColumnAttributes> mapColumnAttributes = new HashMap<>();
		if (null != columnAttributesArray) {
			Arrays.stream(columnAttributesArray).forEach(ca -> mapColumnAttributes.put(ca.getName(), ca));
		}

		for (NameValueSeqUnit odsMeasuredValues : odsMeasuredValuesSeq) {
			measuredValues
					.add(fromODSMeasuredValues(odsMeasuredValues, mapColumnAttributes.get(odsMeasuredValues.valName)));
		}

		return measuredValues;
	}

	/**
	 * Converts given {@link NameValueSeqUnit} to {@link MeasuredValues}.
	 *
	 * @param odsMeasuredValues The {@code NameValueSeqUnit}.
	 * @return The converted {@code MeasuredValues} is returned.
	 * @throws DataAccessException Thrown on conversion errors.
	 */
	private static MeasuredValues fromODSMeasuredValues(NameValueSeqUnit odsMeasuredValues,
			ReadRequestHandler.ColumnAttributes columnAttributes) throws DataAccessException {
		TS_ValueSeq odsValueSeq = odsMeasuredValues.value;
		DataType dataType = odsValueSeq.u.discriminator();
		ScalarType scalarType;
		Object values;

		if (DataType.DT_STRING == dataType) {
			scalarType = ScalarType.STRING;
			values = odsValueSeq.u.stringVal();
		} else if (DataType.DT_DATE == dataType) {
			scalarType = ScalarType.DATE;
			values = fromODSDateSeq(odsValueSeq.u.dateVal());
		} else if (DataType.DT_BOOLEAN == dataType) {
			scalarType = ScalarType.BOOLEAN;
			values = odsValueSeq.u.booleanVal();
		} else if (DataType.DT_BYTE == dataType) {
			scalarType = ScalarType.BYTE;
			values = odsValueSeq.u.byteVal();
		} else if (DataType.DT_SHORT == dataType) {
			scalarType = ScalarType.SHORT;
			values = odsValueSeq.u.shortVal();
		} else if (DataType.DT_LONG == dataType) {
			scalarType = ScalarType.INTEGER;
			values = odsValueSeq.u.longVal();
		} else if (DataType.DT_LONGLONG == dataType) {
			scalarType = ScalarType.LONG;
			values = fromODSLongSeq(odsValueSeq.u.longlongVal());
		} else if (DataType.DT_FLOAT == dataType) {
			scalarType = ScalarType.FLOAT;
			values = odsValueSeq.u.floatVal();
		} else if (DataType.DT_DOUBLE == dataType) {
			scalarType = ScalarType.DOUBLE;
			values = odsValueSeq.u.doubleVal();
		} else if (DataType.DT_BYTESTR == dataType) {
			scalarType = ScalarType.BYTE_STREAM;
			values = odsValueSeq.u.bytestrVal();
		} else if (DataType.DT_COMPLEX == dataType) {
			scalarType = ScalarType.FLOAT_COMPLEX;
			values = fromODSFloatComplexSeq(odsValueSeq.u.complexVal());
		} else if (DataType.DT_DCOMPLEX == dataType) {
			scalarType = ScalarType.DOUBLE_COMPLEX;
			values = fromODSDoubleComplexSeq(odsValueSeq.u.dcomplexVal());
		} else if (DataType.DT_EXTERNALREFERENCE == dataType) {
			scalarType = ScalarType.FILE_LINK;
			values = fromODSExternalReferenceSeq(odsValueSeq.u.extRefVal());
		} else {
			throw new DataAccessException(
					"Conversion for ODS measured points of type '" + dataType.toString() + "' does not exist.");
		}

		if (null == columnAttributes) {
			columnAttributes = new ReadRequestHandler.ColumnAttributes("", null, new double[0], false, null);
		}

		return scalarType.createMeasuredValues(odsMeasuredValues.valName, odsMeasuredValues.unit,
				columnAttributes.getSequenceRepresentation(), columnAttributes.getGenerationParameters(),
				columnAttributes.isIndependentColumn(), columnAttributes.getAxisType(), values,
				fromODSValidFlagSeq(odsValueSeq.flag));
	}

	/**
	 * Converts given {@link Value} to {@link TS_Value}.
	 *
	 * @param value The {@code Value}.
	 * @return The converted {@code TS_Value} is returned.
	 * @throws DataAccessException Thrown on conversion errors.
	 */
	public static TS_Value toODSValue(Attribute attribute, Value value) throws DataAccessException {
		TS_Value odsValue = new TS_Value(new TS_Union(), toODSValidFlag(value.isValid()));
		ValueType<?> type = value.getValueType();

		if (ValueType.STRING == type) {
			if (((ODSAttribute) attribute).isIdAttribute()) {
				odsValue.u.longlongVal(ODSConverter.toODSID(value.extract()));
			} else {
				odsValue.u.stringVal(value.extract());
			}
		} else if (ValueType.STRING_SEQUENCE == type) {
			if (((ODSAttribute) attribute).isIdAttribute()) {
				odsValue.u.longlongSeq(
						Stream.of((String[]) value.extract()).map(ODSConverter::toODSID).toArray(T_LONGLONG[]::new));
			} else {
				odsValue.u.stringSeq(value.extract());
			}
		} else if (ValueType.DATE == type) {
			odsValue.u.dateVal(toODSDate(value.extract()));
		} else if (ValueType.DATE_SEQUENCE == type) {
			odsValue.u.dateSeq(toODSDateSeq(value.extract()));
		} else if (ValueType.BOOLEAN == type) {
			odsValue.u.booleanVal(value.extract());
		} else if (ValueType.BOOLEAN_SEQUENCE == type) {
			odsValue.u.booleanVal(value.extract());
		} else if (ValueType.BYTE == type) {
			odsValue.u.byteVal(value.extract());
		} else if (ValueType.BYTE_SEQUENCE == type) {
			odsValue.u.byteSeq(value.extract());
		} else if (ValueType.SHORT == type) {
			odsValue.u.shortVal(value.extract());
		} else if (ValueType.SHORT_SEQUENCE == type) {
			odsValue.u.shortSeq(value.extract());
		} else if (ValueType.INTEGER == type) {
			odsValue.u.longVal(value.extract());
		} else if (ValueType.INTEGER_SEQUENCE == type) {
			odsValue.u.longSeq(value.extract());
		} else if (ValueType.LONG == type) {
			odsValue.u.longlongVal(toODSLong(value.extract()));
		} else if (ValueType.LONG_SEQUENCE == type) {
			odsValue.u.longlongSeq(toODSLongSeq(value.extract()));
		} else if (ValueType.FLOAT == type) {
			odsValue.u.floatVal(value.extract());
		} else if (ValueType.FLOAT_SEQUENCE == type) {
			odsValue.u.floatSeq(value.extract());
		} else if (ValueType.DOUBLE == type) {
			odsValue.u.doubleVal(value.extract());
		} else if (ValueType.DOUBLE_SEQUENCE == type) {
			odsValue.u.doubleSeq(value.extract());
		} else if (ValueType.BYTE_STREAM == type) {
			odsValue.u.bytestrVal(value.extract());
		} else if (ValueType.BYTE_STREAM_SEQUENCE == type) {
			odsValue.u.bytestrSeq(value.extract());
		} else if (ValueType.FLOAT_COMPLEX == type) {
			odsValue.u.complexVal(toODSFloatComplex(value.extract()));
		} else if (ValueType.FLOAT_COMPLEX_SEQUENCE == type) {
			odsValue.u.complexSeq(toODSFloatComplexSeq(value.extract()));
		} else if (ValueType.DOUBLE_COMPLEX == type) {
			odsValue.u.dcomplexVal(toODSDoubleComplex(value.extract()));
		} else if (ValueType.DOUBLE_COMPLEX_SEQUENCE == type) {
			odsValue.u.dcomplexSeq(toODSDoubleComplexSeq(value.extract()));
		} else if (ValueType.ENUMERATION == type) {
			odsValue.u.enumVal(ODSEnumerations.toODSEnum(value.extract()));
		} else if (ValueType.ENUMERATION_SEQUENCE == type) {
			odsValue.u.enumSeq(ODSEnumerations.toODSEnumSeq(value.extract()));
		} else if (ValueType.FILE_LINK == type) {
			odsValue.u.extRefVal(toODSExternalReference(value.extract()));
		} else if (ValueType.FILE_LINK_SEQUENCE == type) {
			odsValue.u.extRefSeq(toODSExternalReferenceSeq(value.extract()));
		} else if (ValueType.BLOB == type) {
			odsValue.u.blobVal(toODSBlob(value.extract()));
		} else {
			throw new DataAccessException("Mapping for value type '" + type + "' does not exist.");
		}

		return odsValue;
	}

	/**
	 * Converts given {@link short[]} to {@link boolean[]}.
	 *
	 * @param input The {@code short}s.
	 * @return The converted {@code boolean}s are returned.
	 */
	private static boolean[] fromODSValidFlagSeq(short[] input) {
		boolean[] result = new boolean[input.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = fromODSValidFlag(input[i]);
		}

		return result;
	}

	/**
	 * Converts given {@link short} to {@link boolean}.
	 *
	 * @param input The {@code short}.
	 * @return The converted {@code boolean} is returned.
	 */
	private static boolean fromODSValidFlag(short input) {
		return input == 15;
	}

	/**
	 * Converts given {@link boolean[]} to {@link short[]}.
	 *
	 * @param input The {@code boolean}s.
	 * @return The converted {@code short}s are returned.
	 */
	public static short[] toODSValidFlagSeq(boolean[] input) {
		short[] result = new short[input.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = toODSValidFlag(input[i]);
		}

		return result;
	}

	/**
	 * Converts given {@link boolean} to {@link short}.
	 *
	 * @param input The {@code boolean}.
	 * @return The converted {@code short} is returned.
	 */
	public static short toODSValidFlag(boolean input) {
		return (short) (input ? 15 : 0);
	}

	/**
	 * Converts given {@link T_LONGLONG[]} to {@link long[]}.
	 *
	 * @param input The {@code T_LONGLONG}s.
	 * @return The converted {@code long}s are returned.
	 */
	private static long[] fromODSLongSeq(T_LONGLONG[] input) {
		long[] result = new long[input.length];
		for (int i = 0; i < result.length; i++) {
			result[i] = fromODSLong(input[i]);
		}

		return result;
	}

	/**
	 * Converts given {@link T_LONGLONG} to {@link long}.
	 *
	 * @param input The {@code T_LONGLONG}.
	 * @return The converted {@code long} is returned.
	 */
	public static long fromODSLong(T_LONGLONG input) {
		T_LONGLONG value = input == null ? new T_LONGLONG() : input;
		return (value.high + (value.low >= 0 ? 0 : 1)) * 0x100000000L + value.low;
	}

	/**
	 * Converts given {@link long[]} to {@link T_LONGLONG[]}.
	 *
	 * @param input The {@code long}s.
	 * @return The converted {@code T_LONGLONG}s are returned.
	 */
	private static T_LONGLONG[] toODSLongSeq(long[] input) {
		List<T_LONGLONG> result = new ArrayList<>(input.length);
		for (long value : input) {
			result.add(toODSLong(value));
		}

		return result.toArray(new T_LONGLONG[result.size()]);
	}

	/**
	 * Converts given {@link long} to {@link T_LONGLONG}.
	 *
	 * @param input The {@code long}.
	 * @return The converted {@code T_LONGLONG} is returned.
	 */
	public static T_LONGLONG toODSLong(long input) {
		return new T_LONGLONG((int) (input >> 32 & 0xffffffffL), (int) (input & 0xffffffffL));
	}

	/**
	 * Converts a given MDM ID string to {@link T_LONGLONG}.
	 * 
	 * @param input The MDM ID string.
	 * @return The converted {@code T_LONGLONG} is returned.
	 */
	public static T_LONGLONG toODSID(String input) {
		try {
			return toODSLong(Long.valueOf(input));
		} catch (NumberFormatException e) {
			return new T_LONGLONG();
		}
	}

	/**
	 * Converts given {@link String[]} to {@link LocalDateTime[]}.
	 *
	 * @param input The {@code String}s.
	 * @return The converted {@code LocalDateTime}s are returned.
	 */
	private static LocalDateTime[] fromODSDateSeq(String[] input) {
		List<LocalDateTime> result = new ArrayList<>();
		if (input != null) {
			for (String value : input) {
				result.add(fromODSDate(value));
			}
		}

		return result.toArray(new LocalDateTime[result.size()]);
	}

	/**
	 * Converts given {@link String} to {@link LocalDateTime}.
	 *
	 * @param input The {@code T_COMPLEX}.
	 * @return The converted {@code String} is returned.
	 */
	private static LocalDateTime fromODSDate(String input) {
		if (input == null || input.isEmpty()) {
			return null;
		}

		DateTimeFormatter formatter = ODS_DATE_FORMATTERS.get(input.length());
		if (formatter == null) {
			throw new IllegalArgumentException("Invalid ODS date: " + input);
		}

		try {
			if (input.length() <= 8) {
				// Java does not accept a bare date as DateTime, so we are using LocalDate
				// instead of LocalDateTime
				return LocalDate.parse(input, formatter).atStartOfDay();
			} else {
				return LocalDateTime.parse(input, formatter);
			}
		} catch (DateTimeParseException e) {
			throw new IllegalArgumentException("Invalid ODS date: " + input, e);
		}
	}

	/**
	 * Converts given {@link LocalDateTime[]} to {@link String[]}.
	 *
	 * @param input The {@code LocalDateTime}s.
	 * @return The converted {@code String}s are returned.
	 */
	private static String[] toODSDateSeq(LocalDateTime[] input) {
		List<String> result = new ArrayList<>(input.length);
		for (LocalDateTime value : input) {
			result.add(toODSDate(value));
		}

		return result.toArray(new String[result.size()]);
	}

	/**
	 * Converts given {@link LocalDateTime} to {@link String}.
	 *
	 * @param input The {@code LocalDateTime}.
	 * @return The converted {@code String} is returned.
	 */
	private static String toODSDate(LocalDateTime input) {
		return input == null ? "" : input.format(ODS_DATE_FORMATTERS.get(14));
	}

	/**
	 * Converts given {@link T_COMPLEX[]} to {@link FloatComplex[]}.
	 *
	 * @param input The {@code T_COMPLEX}s.
	 * @return The converted {@code FloatComplex}s are returned.
	 */
	private static FloatComplex[] fromODSFloatComplexSeq(T_COMPLEX[] input) {
		List<FloatComplex> result = new ArrayList<>();
		if (input != null) {
			for (T_COMPLEX value : input) {
				result.add(fromODSFloatComplex(value));
			}
		}

		return result.toArray(new FloatComplex[result.size()]);
	}

	/**
	 * Converts given {@link T_COMPLEX} to {@link FloatComplex}.
	 *
	 * @param input The {@code T_COMPLEX}.
	 * @return The converted {@code FloatComplex} is returned.
	 */
	private static FloatComplex fromODSFloatComplex(T_COMPLEX input) {
		return input == null ? null : new FloatComplex(input.r, input.i);
	}

	/**
	 * Converts given {@link FloatComplex[]} to {@link T_COMPLEX[]}.
	 *
	 * @param input The {@code FloatComplex}s.
	 * @return The converted {@code T_COMPLEX}s are returned.
	 */
	private static T_COMPLEX[] toODSFloatComplexSeq(FloatComplex[] input) {
		List<T_COMPLEX> result = new ArrayList<>(input.length);
		for (FloatComplex value : input) {
			result.add(toODSFloatComplex(value));
		}

		return result.toArray(new T_COMPLEX[result.size()]);
	}

	/**
	 * Converts given {@link FloatComplex} to {@link T_COMPLEX}.
	 *
	 * @param input The {@code FloatComplex}.
	 * @return The converted {@code T_COMPLEX} is returned.
	 */
	private static T_COMPLEX toODSFloatComplex(FloatComplex input) {
		return input == null ? null : new T_COMPLEX(input.real(), input.imaginary());
	}

	/**
	 * Converts given {@link T_DCOMPLEX[]} to {@link DoubleComplex[]}.
	 *
	 * @param input The {@code T_DCOMPLEX}s.
	 * @return The converted {@code DoubleComplex}s are returned.
	 */
	private static DoubleComplex[] fromODSDoubleComplexSeq(T_DCOMPLEX[] input) {
		List<DoubleComplex> result = new ArrayList<>();
		if (input != null) {
			for (T_DCOMPLEX value : input) {
				result.add(fromODSDoubleComplex(value));
			}
		}

		return result.toArray(new DoubleComplex[result.size()]);
	}

	/**
	 * Converts given {@link T_DCOMPLEX} to {@link DoubleComplex}.
	 *
	 * @param input The {@code T_DCOMPLEX}.
	 * @return The converted {@code DoubleComplex} is returned.
	 */
	private static DoubleComplex fromODSDoubleComplex(T_DCOMPLEX input) {
		return input == null ? null : new DoubleComplex(input.r, input.i);
	}

	/**
	 * Converts given {@link DoubleComplex[]} to {@link T_DCOMPLEX[]}.
	 *
	 * @param input The {@code DoubleComplex}s.
	 * @return The converted {@code T_DCOMPLEX}s are returned.
	 */
	private static T_DCOMPLEX[] toODSDoubleComplexSeq(DoubleComplex[] input) {
		List<T_DCOMPLEX> result = new ArrayList<>(input.length);
		for (DoubleComplex value : input) {
			result.add(toODSDoubleComplex(value));
		}

		return result.toArray(new T_DCOMPLEX[result.size()]);
	}

	/**
	 * Converts given {@link DoubleComplex} to {@link T_DCOMPLEX}.
	 *
	 * @param input The {@code DoubleComplex}.
	 * @return The converted {@code T_DCOMPLEX} is returned.
	 */
	private static T_DCOMPLEX toODSDoubleComplex(DoubleComplex input) {
		return input == null ? null : new T_DCOMPLEX(input.real(), input.imaginary());
	}

	/**
	 * Converts given {@link T_ExternalReference[]} to {@link FileLink[]}.
	 *
	 * @param input The {@code T_ExternalReference}s.
	 * @return The converted {@code FileLink}s are returned.
	 */
	private static FileLink[] fromODSExternalReferenceSeq(T_ExternalReference[] input) {
		List<FileLink> result = new ArrayList<>();
		if (input != null) {
			for (T_ExternalReference value : input) {
				result.add(fromODSExternalReference(value));
			}
		}

		return result.toArray(new FileLink[result.size()]);
	}

	/**
	 * Converts given {@link T_ExternalReference} to {@link FileLink}.
	 *
	 * @param input The {@code T_ExternalReference}.
	 * @return The converted {@code FileLink} is returned.
	 */
	private static FileLink fromODSExternalReference(T_ExternalReference input) {
		if (input == null) {
			return null;
		}
		return FileLink.newRemote(input.location, new MimeType(input.mimeType), input.description);
	}

	/**
	 * Converts given {@link FileLink[]} to {@link T_ExternalReference[]}.
	 *
	 * @param input The {@code FileLink}s.
	 * @return The converted {@code T_ExternalReference}s are returned.
	 */
	private static T_ExternalReference[] toODSExternalReferenceSeq(FileLink[] input) {
		List<T_ExternalReference> result = new ArrayList<>(input.length);
		for (FileLink value : input) {
			result.add(toODSExternalReference(value));
		}

		return result.toArray(new T_ExternalReference[result.size()]);
	}

	/**
	 * Converts given {@link FileLink} to {@link T_ExternalReference}.
	 *
	 * @param input The {@code FileLink}.
	 * @return The converted {@code T_ExternalReference} is returned.
	 */
	private static T_ExternalReference toODSExternalReference(FileLink input) {
		if (input == null) {
			return new T_ExternalReference("", "", "");
		}
		String remotePath = input.isRemote() ? input.getRemotePath() : "";
		return new T_ExternalReference(input.getDescription(), input.getMimeType().toString(), remotePath);
	}

	/**
	 * Converts given {@link Blob} to {@link Object}.
	 *
	 * @param input The {@code Blob}
	 * @return The converted {@code Object} is returned.
	 */
	private static Object fromODSBlob(Blob input) {
		throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
	}

	/**
	 * Converts given object to {@link Blob}.
	 *
	 * @param input The object.
	 * @return The converted {@code Blob} is returned.
	 */
	private static Blob toODSBlob(Object input) {
		throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
	}

}