/**
 ********************************************************************************
 * Copyright (c) 2015-2021 Robert Bosch GmbH and others.
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
 * which is available at https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Robert Bosch GmbH - initial API and implementation
 ********************************************************************************
 */

package org.eclipse.app4mc.amalthea.model.util;

import java.math.BigInteger;
import java.util.Collection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.app4mc.amalthea.model.AmaltheaFactory;
import org.eclipse.app4mc.amalthea.model.AmaltheaServices;
import org.eclipse.app4mc.amalthea.model.BigIntegerObject;
import org.eclipse.app4mc.amalthea.model.BooleanObject;
import org.eclipse.app4mc.amalthea.model.ClockStep;
import org.eclipse.app4mc.amalthea.model.Counter;
import org.eclipse.app4mc.amalthea.model.DataRate;
import org.eclipse.app4mc.amalthea.model.DataRateUnit;
import org.eclipse.app4mc.amalthea.model.DataSize;
import org.eclipse.app4mc.amalthea.model.DataSizeUnit;
import org.eclipse.app4mc.amalthea.model.DiscreteValueBoundaries;
import org.eclipse.app4mc.amalthea.model.DiscreteValueConstant;
import org.eclipse.app4mc.amalthea.model.DiscreteValueGaussDistribution;
import org.eclipse.app4mc.amalthea.model.DiscreteValueWeibullEstimatorsDistribution;
import org.eclipse.app4mc.amalthea.model.DoubleObject;
import org.eclipse.app4mc.amalthea.model.ExecutionNeed;
import org.eclipse.app4mc.amalthea.model.FloatObject;
import org.eclipse.app4mc.amalthea.model.Frequency;
import org.eclipse.app4mc.amalthea.model.FrequencyUnit;
import org.eclipse.app4mc.amalthea.model.HwFeature;
import org.eclipse.app4mc.amalthea.model.IDiscreteValueDeviation;
import org.eclipse.app4mc.amalthea.model.IReferable;
import org.eclipse.app4mc.amalthea.model.IntegerObject;
import org.eclipse.app4mc.amalthea.model.ListObject;
import org.eclipse.app4mc.amalthea.model.LongObject;
import org.eclipse.app4mc.amalthea.model.ReferenceObject;
import org.eclipse.app4mc.amalthea.model.StringObject;
import org.eclipse.app4mc.amalthea.model.Time;
import org.eclipse.app4mc.amalthea.model.TimeBoundaries;
import org.eclipse.app4mc.amalthea.model.TimeConstant;
import org.eclipse.app4mc.amalthea.model.TimeGaussDistribution;
import org.eclipse.app4mc.amalthea.model.TimeUnit;
import org.eclipse.app4mc.amalthea.model.TimeWeibullEstimatorsDistribution;
import org.eclipse.app4mc.amalthea.model.TypeDefinition;
import org.eclipse.app4mc.amalthea.model.TypeRef;
import org.eclipse.app4mc.amalthea.model.Value;
import org.eclipse.app4mc.amalthea.model.Voltage;
import org.eclipse.app4mc.amalthea.model.VoltageUnit;

public class FactoryUtil {

	// Suppress default constructor
	private FactoryUtil() {
		throw new IllegalStateException("Utility class");
	}

	/**
	 * Creates a counter (with offset = 0)
	 */
	public static Counter createCounter(long prescaler) {
		return createCounter(prescaler, 0);
	}

	/**
	 * Creates a counter
	 */
	public static Counter createCounter(long prescaler, long offset) {
		Counter counter = AmaltheaFactory.eINSTANCE.createCounter();
		counter.setPrescaler(prescaler);
		counter.setOffset(offset);
		return counter;
	}

	/**
	 * Creates a data size (initialized with zero value and base unit)
	 */
	public static DataSize createDataSize() {
		DataSize size = AmaltheaFactory.eINSTANCE.createDataSize();
		size.setValue(BigInteger.ZERO);
		size.setUnit(DataSizeUnit.BIT);
		return size;
	}

	/**
	 * Creates a data size out of a value and a unit
	 */
	public static DataSize createDataSize(long value, DataSizeUnit unit) {
		DataSize size = AmaltheaFactory.eINSTANCE.createDataSize();
		size.setValue(BigInteger.valueOf(value));
		size.setUnit(unit);
		return size;
	}

	/**
	 * Creates a data rate (initialized with zero value and base unit)
	 */
	public static DataRate createDataRate() {
		DataRate rate = AmaltheaFactory.eINSTANCE.createDataRate();
		rate.setValue(BigInteger.ZERO);
		rate.setUnit(DataRateUnit.BIT_PER_SECOND);
		return rate;
	}

	/**
	 * Creates a data rate out of a value and a unit
	 */
	public static DataRate createDataRate(long value, DataRateUnit unit) {
		DataRate rate = AmaltheaFactory.eINSTANCE.createDataRate();
		rate.setValue(BigInteger.valueOf(value));
		rate.setUnit(unit);
		return rate;
	}

	/**
	 * Creates a frequency (initialized with zero value and base unit)
	 */
	public static Frequency createFrequency() {
		Frequency frequency = AmaltheaFactory.eINSTANCE.createFrequency();
		frequency.setUnit(FrequencyUnit.HZ);
		return frequency;
	}

	/**
	 * Creates a frequency out of a value and a unit
	 */
	public static Frequency createFrequency(double value, FrequencyUnit unit) {
		Frequency frequency = AmaltheaFactory.eINSTANCE.createFrequency();
		frequency.setValue(value);
		frequency.setUnit(unit);
		return frequency;
	}

	/**
	 * Creates a voltage (initialized with zero value and base unit)
	 */
	public static Voltage createVoltage() {
		Voltage voltage = AmaltheaFactory.eINSTANCE.createVoltage();
		voltage.setUnit(VoltageUnit.UV);
		return voltage;
	}

	/**
	 * Creates a voltage out of a value and a unit
	 */
	public static Voltage createVoltage(double value, VoltageUnit unit) {
		Voltage voltage = AmaltheaFactory.eINSTANCE.createVoltage();
		voltage.setValue(value);
		voltage.setUnit(unit);
		return voltage;
	}

	/**
	 * Creates a time (initialized with zero value and base unit)
	 */
	public static Time createTime() {
		Time time = AmaltheaFactory.eINSTANCE.createTime();
		time.setValue(BigInteger.ZERO);
		time.setUnit(TimeUnit.PS);
		return time;
	}

	/**
	 * Creates a new time based on a time
	 * @param inputTime
	 * @return New time object
	 */
	public static Time createTime(Time inputTime) {
		Time time = AmaltheaFactory.eINSTANCE.createTime();
		time.setValue(inputTime.getValue());
		time.setUnit(inputTime.getUnit());
		return time;
	}

	/**
	 * Creates a time out of a value and a unit
	 */
	public static Time createTime(long value, TimeUnit unit) {
		Time time = AmaltheaFactory.eINSTANCE.createTime();
		time.setValue(BigInteger.valueOf(value));
		time.setUnit(unit);
		return time;
	}

	/**
	 * Creates a time out of a value and a unit (converted to pico seconds)
	 */
	public static Time createTime(double value, TimeUnit unit) {
		if (unit == TimeUnit._UNDEFINED_)  return null;

		// convert to pico seconds
		int power = AmaltheaServices.TIME_UNIT_LIST.indexOf(unit);
		double factor = Math.pow(1000, power);
		long newValue = Math.round(value * factor);

		return createTime(newValue, TimeUnit.PS);
	}

	/**
	 * Creates a time out of a value and a unit
	 */
	public static Time createTime(BigInteger value, TimeUnit unit) {
		Time time = AmaltheaFactory.eINSTANCE.createTime();
		time.setValue(value);
		time.setUnit(unit);
		return time;
	}

	/**
	 * Creates a time out of a value and a unit given as String.
	 */
	public static Time createTime(long value, String unit) {
		return createTime(value, parseTimeUnit(unit));
	}

	/**
	 * Creates a time out of a value and a unit given as String.
	 */
	public static Time createTime(double value, String unit) {
		return createTime(value, parseTimeUnit(unit));
	}

	/**
	 * Creates a time out of a value and a unit given as String.
	 */
	public static Time createTime(BigInteger value, String unit) {
		return createTime(value, parseTimeUnit(unit));
	}

	/**
	 * Creates a Time object parsed from a text representation.
	 * @param timeString	string representation of a time (number followed by time unit s, ms, us, ns or ps)
	 * @return The new Time object
	 *
	 */
	public static Time createTime(String timeString) {
		Pattern p = Pattern.compile("(-?\\d+)(\\.\\d+)?\\s?(s|ms|us|ns|ps)");
		Matcher m = p.matcher(timeString);
		if(m.matches()) {
			String value = m.group(1);
			String fraction = m.group(2);
			String unit = m.group(3);
			if (fraction == null) {
				return createTime(Long.parseLong(value), parseTimeUnit(unit));
			} else {
				return createTime(Double.parseDouble(value + fraction), parseTimeUnit(unit));
			}
		}
		return null;
	}

	private static TimeUnit parseTimeUnit(String input) {
		if (input == null) return TimeUnit.MS;	//default millisecond

		String unit = input.trim().toLowerCase();
		if(unit.equals("ps")) return TimeUnit.PS;
		if(unit.equals("ns")) return TimeUnit.NS;
		if(unit.equals("us")) return TimeUnit.US;
		if(unit.equals("ms")) return TimeUnit.MS;
		if(unit.equals("s")) return TimeUnit.S;

		return null;
	}

	public static ClockStep createClockStep(double freqValue, FrequencyUnit freqUnit, long timeValue, String timeUnit) {
		ClockStep clockStep = AmaltheaFactory.eINSTANCE.createClockStep();
		clockStep.setFrequency(createFrequency(freqValue, freqUnit));
		clockStep.setTime(createTime(timeValue, timeUnit));
		return clockStep;
	}

	/**
	 * Creates a TypeRef object that refers to a type definition
	 */
	public static TypeRef createTypeRef(TypeDefinition typeDefinition) {
		TypeRef refObj = AmaltheaFactory.eINSTANCE.createTypeRef();
		refObj.setTypeDef(typeDefinition);
		return refObj;
	}

	public static DiscreteValueConstant createDiscreteValueConstant(long value) {
		DiscreteValueConstant result = AmaltheaFactory.eINSTANCE.createDiscreteValueConstant();
		result.setValue(value);
		return result;
	}

	public static DiscreteValueBoundaries createDiscreteValueBoundaries(long min, long max) {
		DiscreteValueBoundaries boundaries = AmaltheaFactory.eINSTANCE.createDiscreteValueBoundaries();
		boundaries.setLowerBound(min);
		boundaries.setUpperBound(max);
		return boundaries;
	}

	public static DiscreteValueGaussDistribution createDiscreteValueGaussDistribution(double mean, double sd) {
		DiscreteValueGaussDistribution result = AmaltheaFactory.eINSTANCE.createDiscreteValueGaussDistribution();
		result.setMean(mean);
		result.setSd(sd);
		return result;
	}

	public static DiscreteValueGaussDistribution createDiscreteValueGaussDistribution(double mean, double sd, Long min, Long max) {
		DiscreteValueGaussDistribution result = createDiscreteValueGaussDistribution(mean, sd);
		result.setLowerBound(min);
		result.setUpperBound(max);
		return result;
	}

	public static DiscreteValueWeibullEstimatorsDistribution createWeibullDistribution(long min, double avg, long max, double promille) {
		DiscreteValueWeibullEstimatorsDistribution result = AmaltheaFactory.eINSTANCE.createDiscreteValueWeibullEstimatorsDistribution();
		result.setLowerBound(min);
		result.setAverage(avg);
		result.setUpperBound(max);
		result.setPRemainPromille(promille);
		return result;
	}

	public static TimeConstant createTimeConstant(Time value) {
		TimeConstant result = AmaltheaFactory.eINSTANCE.createTimeConstant();
		result.setValue(value);
		return result;
	}

	public static TimeBoundaries createTimeBoundaries(Time min, Time max) {
		TimeBoundaries boundaries = AmaltheaFactory.eINSTANCE.createTimeBoundaries();
		boundaries.setLowerBound(min);
		boundaries.setUpperBound(max);
		return boundaries;
	}

	public static TimeGaussDistribution createTimeGaussDistribution(Time mean, Time sd) {
		TimeGaussDistribution result = AmaltheaFactory.eINSTANCE.createTimeGaussDistribution();
		result.setMean(mean);
		result.setSd(sd);
		return result;
	}

	public static TimeGaussDistribution createTimeGaussDistribution(Time mean, Time sd, Time min, Time max) {
		TimeGaussDistribution result = createTimeGaussDistribution(mean, sd);
		result.setLowerBound(min);
		result.setUpperBound(max);
		return result;
	}

	public static TimeWeibullEstimatorsDistribution createWeibullDistribution(Time min, Time avg, Time max, double promille) {
		TimeWeibullEstimatorsDistribution result = AmaltheaFactory.eINSTANCE.createTimeWeibullEstimatorsDistribution();
		result.setLowerBound(min);
		result.setAverage(avg);
		result.setUpperBound(max);
		result.setPRemainPromille(promille);
		return result;
	}

	/**
	 * Creates ExecutionNeed for a featureCategoryName, need set.
	 */
	public static ExecutionNeed createExecutionNeed(String featureCategory, IDiscreteValueDeviation usages) {
		ExecutionNeed exeNeed = AmaltheaFactory.eINSTANCE.createExecutionNeed();
		exeNeed.getNeeds().put(featureCategory, usages);
		return exeNeed;
	}

	/**
	 * Creates ExecutionNeed for a feature, need set.
	 */
	public static ExecutionNeed createExecutionNeed(HwFeature feature, IDiscreteValueDeviation usages) {
		ExecutionNeed exeNeed = AmaltheaFactory.eINSTANCE.createExecutionNeed();
		exeNeed.getNeeds().put(feature.getContainingCategory().getName(), usages);
		return exeNeed;
	}

	public static DiscreteValueConstant createLatency(long value) {
		return createDiscreteValueConstant(value);
	}

	public static StringObject createStringObject(String value) {
		StringObject valueObject = AmaltheaFactory.eINSTANCE.createStringObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static ReferenceObject createReferenceObject(IReferable value) {
		ReferenceObject valueObject = AmaltheaFactory.eINSTANCE.createReferenceObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static IntegerObject createIntegerObject(int value) {
		IntegerObject valueObject = AmaltheaFactory.eINSTANCE.createIntegerObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static LongObject createLongObject(long value) {
		LongObject valueObject = AmaltheaFactory.eINSTANCE.createLongObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static BigIntegerObject createBigIntegerObject(BigInteger value) {
		BigIntegerObject valueObject = AmaltheaFactory.eINSTANCE.createBigIntegerObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static FloatObject createFloatObject(float value) {
		FloatObject valueObject = AmaltheaFactory.eINSTANCE.createFloatObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static DoubleObject createDoubleObject(double value) {
		DoubleObject valueObject = AmaltheaFactory.eINSTANCE.createDoubleObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static BooleanObject createBooleanObject(boolean value) {
		BooleanObject valueObject = AmaltheaFactory.eINSTANCE.createBooleanObject();
		valueObject.setValue(value);
		return valueObject;
	}

	public static ListObject createListObject(Collection<? extends Value> values) {
		ListObject valueObject = AmaltheaFactory.eINSTANCE.createListObject();
		valueObject.getValues().addAll(values);
		return valueObject;
	}

}