/********************************************************************************
 * 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 org.asam.ods.AggrFunc;
import org.asam.ods.DataType;
import org.asam.ods.SelOpcode;
import org.asam.ods.SelOperator;
import org.eclipse.mdm.api.base.adapter.RelationType;
import org.eclipse.mdm.api.base.model.ContextType;
import org.eclipse.mdm.api.base.model.ValueType;
import org.eclipse.mdm.api.base.query.Aggregation;
import org.eclipse.mdm.api.base.query.BooleanOperator;
import org.eclipse.mdm.api.base.query.BracketOperator;
import org.eclipse.mdm.api.base.query.ComparisonOperator;
import org.eclipse.mdm.api.base.query.JoinType;

import com.google.common.collect.ImmutableBiMap;

/**
 * Utility class provides bidirectional mappings for ODS types
 *
 * @author Viktor Stoehr, Gigatronik Ingolstadt GmbH
 * @since 1.0.0
 */
public abstract class ODSUtils {
	/**
	 * Maps {@link RelationType} to the corresponding ODS {@link RelationType}.
	 */
	public static final ImmutableBiMap<RelationType, org.asam.ods.RelationType> RELATIONSHIPS = ImmutableBiMap.<RelationType, org.asam.ods.RelationType>builder()
			.put(RelationType.FATHER_CHILD, org.asam.ods.RelationType.FATHER_CHILD)
			.put(RelationType.INFO, org.asam.ods.RelationType.INFO)
			.put(RelationType.INHERITANCE, org.asam.ods.RelationType.INHERITANCE).build();

	/**
	 * Maps {@link Aggregation} to the corresponding ODS {@link AggrFunc}.
	 */
	public static final ImmutableBiMap<Aggregation, AggrFunc> AGGREGATIONS = ImmutableBiMap
			.<Aggregation, AggrFunc>builder().put(Aggregation.NONE, AggrFunc.NONE)
			.put(Aggregation.COUNT, AggrFunc.COUNT).put(Aggregation.DISTINCT_COUNT, AggrFunc.DCOUNT)
			.put(Aggregation.MINIMUM, AggrFunc.MIN).put(Aggregation.MAXIMUM, AggrFunc.MAX)
			.put(Aggregation.AVERAGE, AggrFunc.AVG).put(Aggregation.DEVIATION, AggrFunc.STDDEV)
			.put(Aggregation.SUM, AggrFunc.SUM).put(Aggregation.DISTINCT, AggrFunc.DISTINCT).build();

	/**
	 * Maps {@link ContextType} to the corresponding ODS {@link String}.
	 */
	public static final ImmutableBiMap<ContextType, String> CONTEXTTYPES = ImmutableBiMap.<ContextType, String>builder()
			.put(ContextType.UNITUNDERTEST, "UnitUnderTest").put(ContextType.TESTSEQUENCE, "TestSequence")
			.put(ContextType.TESTEQUIPMENT, "TestEquipment").build();

	/**
	 * Maps {@link ComparisonOperator} to the corresponding ODS {@link SelOpcode}.
	 */
	public static final ImmutableBiMap<ComparisonOperator, SelOpcode> OPERATIONS = ImmutableBiMap
			.<ComparisonOperator, SelOpcode>builder().put(ComparisonOperator.LIKE, SelOpcode.LIKE)
			.put(ComparisonOperator.CASE_INSENSITIVE_LIKE, SelOpcode.CI_LIKE)
			.put(ComparisonOperator.NOT_LIKE, SelOpcode.NOTLIKE)
			.put(ComparisonOperator.CASE_INSENSITIVE_NOT_LIKE, SelOpcode.CI_NOTLIKE)
			.put(ComparisonOperator.EQUAL, SelOpcode.EQ).put(ComparisonOperator.CASE_INSENSITIVE_EQUAL, SelOpcode.CI_EQ)
			.put(ComparisonOperator.NOT_EQUAL, SelOpcode.NEQ)
			.put(ComparisonOperator.CASE_INSENSITIVE_NOT_EQUAL, SelOpcode.CI_NEQ)
			.put(ComparisonOperator.GREATER_THAN, SelOpcode.GT)
			.put(ComparisonOperator.CASE_INSENSITIVE_GREATER_THAN, SelOpcode.CI_GT)
			.put(ComparisonOperator.GREATER_THAN_OR_EQUAL, SelOpcode.GTE)
			.put(ComparisonOperator.CASE_INSENSITIVE_GREATER_THAN_OR_EQUAL, SelOpcode.CI_GTE)
			.put(ComparisonOperator.LESS_THAN, SelOpcode.LT)
			.put(ComparisonOperator.CASE_INSENSITIVE_LESS_THAN, SelOpcode.CI_LT)
			.put(ComparisonOperator.LESS_THAN_OR_EQUAL, SelOpcode.LTE)
			.put(ComparisonOperator.CASE_INSENSITIVE_LESS_THAN_OR_EQUAL, SelOpcode.CI_LTE)
			.put(ComparisonOperator.IS_NULL, SelOpcode.IS_NULL)
			.put(ComparisonOperator.IS_NOT_NULL, SelOpcode.IS_NOT_NULL).put(ComparisonOperator.IN_SET, SelOpcode.INSET)
			.put(ComparisonOperator.CASE_INSENSITIVE_IN_SET, SelOpcode.CI_INSET)
			.put(ComparisonOperator.NOT_IN_SET, SelOpcode.NOTINSET)
			.put(ComparisonOperator.CASE_INSENSITIVE_NOT_IN_SET, SelOpcode.CI_NOTINSET)
			.put(ComparisonOperator.BETWEEN, SelOpcode.BETWEEN).build();

	/**
	 * Maps {@link BooleanOperator} to the corresponding ODS {@link SelOperator}.
	 */
	public static final ImmutableBiMap<BooleanOperator, SelOperator> OPERATORS = ImmutableBiMap
			.<BooleanOperator, SelOperator>builder().put(BooleanOperator.AND, SelOperator.AND)
			.put(BooleanOperator.OR, SelOperator.OR).put(BooleanOperator.NOT, SelOperator.NOT).build();

	/**
	 * Maps {@link BracketOperator} to the corresponding ODS {@link SelOperator}.
	 */
	public static final ImmutableBiMap<BracketOperator, SelOperator> BRACKETOPERATORS = ImmutableBiMap
			.<BracketOperator, SelOperator>builder().put(BracketOperator.OPEN, SelOperator.OPEN)
			.put(BracketOperator.CLOSE, SelOperator.CLOSE).build();

	/**
	 * Maps {@link ValueType} to the corresponding ODS {@link DataType}.
	 */
	public static final ImmutableBiMap<ValueType<?>, DataType> VALUETYPES = ImmutableBiMap
			.<ValueType<?>, DataType>builder().put(ValueType.UNKNOWN, DataType.DT_UNKNOWN)
			.put(ValueType.STRING, DataType.DT_STRING).put(ValueType.STRING_SEQUENCE, DataType.DS_STRING)
			.put(ValueType.DATE, DataType.DT_DATE).put(ValueType.DATE_SEQUENCE, DataType.DS_DATE)
			.put(ValueType.BOOLEAN, DataType.DT_BOOLEAN).put(ValueType.BOOLEAN_SEQUENCE, DataType.DS_BOOLEAN)
			.put(ValueType.BYTE, DataType.DT_BYTE).put(ValueType.BYTE_SEQUENCE, DataType.DS_BYTE)
			.put(ValueType.SHORT, DataType.DT_SHORT).put(ValueType.SHORT_SEQUENCE, DataType.DS_SHORT)
			.put(ValueType.INTEGER, DataType.DT_LONG).put(ValueType.INTEGER_SEQUENCE, DataType.DS_LONG)
			.put(ValueType.LONG, DataType.DT_LONGLONG).put(ValueType.LONG_SEQUENCE, DataType.DS_LONGLONG)
			.put(ValueType.FLOAT, DataType.DT_FLOAT).put(ValueType.FLOAT_SEQUENCE, DataType.DS_FLOAT)
			.put(ValueType.DOUBLE, DataType.DT_DOUBLE).put(ValueType.DOUBLE_SEQUENCE, DataType.DS_DOUBLE)
			.put(ValueType.BYTE_STREAM, DataType.DT_BYTESTR).put(ValueType.BYTE_STREAM_SEQUENCE, DataType.DS_BYTESTR)
			.put(ValueType.FLOAT_COMPLEX, DataType.DT_COMPLEX)
			.put(ValueType.FLOAT_COMPLEX_SEQUENCE, DataType.DS_COMPLEX)
			.put(ValueType.DOUBLE_COMPLEX, DataType.DT_DCOMPLEX)
			.put(ValueType.DOUBLE_COMPLEX_SEQUENCE, DataType.DS_DCOMPLEX).put(ValueType.ENUMERATION, DataType.DT_ENUM)
			.put(ValueType.ENUMERATION_SEQUENCE, DataType.DS_ENUM)
			.put(ValueType.FILE_LINK, DataType.DT_EXTERNALREFERENCE)
			.put(ValueType.FILE_LINK_SEQUENCE, DataType.DS_EXTERNALREFERENCE).put(ValueType.BLOB, DataType.DT_BLOB)
			.build();

	/**
	 * Maps {@link JoinType} to the corresponding ODS {@link org.asam.ods.JoinType}.
	 */
	public static final ImmutableBiMap<JoinType, org.asam.ods.JoinType> JOINS = ImmutableBiMap.<JoinType, org.asam.ods.JoinType>builder()
			.put(JoinType.INNER, org.asam.ods.JoinType.JTDEFAULT).put(JoinType.OUTER, org.asam.ods.JoinType.JTOUTER)
			.build();

	public static boolean isValidID(String instanceID) {
		return instanceID != null && !instanceID.isEmpty() && !"0".equals(instanceID);
	}
}