/**
 * *******************************************************************************
 * Copyright (c) 2019 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 templates.m2m.sw.runnableItem

import com.google.inject.Singleton
import com.inchron.realtime.root.model.Time
import com.inchron.realtime.root.model.TimeDistributionType
import com.inchron.realtime.root.model.TimeUnit
import org.eclipse.app4mc.amalthea.model.Amalthea
import org.eclipse.app4mc.amalthea.model.DiscreteValueBetaDistribution
import org.eclipse.app4mc.amalthea.model.DiscreteValueGaussDistribution
import org.eclipse.app4mc.amalthea.model.DiscreteValueHistogram
import org.eclipse.app4mc.amalthea.model.DiscreteValueUniformDistribution
import org.eclipse.app4mc.amalthea.model.Process
import org.eclipse.app4mc.amalthea.model.Ticks
import org.eclipse.app4mc.amalthea.model.util.DeploymentUtil
import org.eclipse.emf.ecore.util.EcoreUtil
import templates.AbstractAmaltheaInchronTransformer
import org.eclipse.app4mc.amalthea.model.ProcessingUnit

@Singleton
class TicksTransformer extends AbstractAmaltheaInchronTransformer {

	def create inchronModelFactory.createResourceConsumption createResourceConsumption(Process amltTask,
		Ticks amltTicks) {
		it.name = "RC"
		it.timeDistribution = createTicksDistribution(amltTask, amltTicks)
	}

	def create inchronModelFactory.createTimeDistribution createTicksDistribution(Process amltTask, Ticks amltTicks) {

		var amltCores = DeploymentUtil.getAssignedCoreForProcess(amltTask,
			EcoreUtil.getRootContainer(amltTask) as Amalthea);

		//get distribution (extended if provided by the model element)
		var ProcessingUnit amltCore = null
		
		if(amltCores!==null && amltCores.size>0){
			amltCore=amltCores?.get(0)
		}

		var amltDistribution = amltTicks?.extended.get(amltCore?.definition)
		if (amltDistribution === null) {
			amltDistribution = amltTicks.^default
		}
		
		if(amltDistribution===null)
		{
			return
		}
		//transform basic elements
		it.min = createTimeTicks( amltDistribution.lowerBound)
		it.mean =  createTimeTicks(amltDistribution.average)
		it.max =  createTimeTicks(amltDistribution.upperBound)
		it.sigma =  createTimeTicks(0)
		it.type = TimeDistributionType.MAX
		it.alpha = 0
		it.beta = 0
		
		// more sophisticated distributions
		if (amltDistribution instanceof DiscreteValueGaussDistribution) {
			it.type = TimeDistributionType.NORMAL
			it.sigma = createTimeTicks(amltDistribution.sd)
		} else if (amltDistribution instanceof DiscreteValueUniformDistribution) {
			it.type = TimeDistributionType.UNIFORM
		} else if (amltDistribution instanceof DiscreteValueBetaDistribution) {
			//TODO: implement beta distribution transformer
		} else if (amltDistribution instanceof DiscreteValueHistogram) {
			it.type = TimeDistributionType.DISCRETE
			amltDistribution.entries.forEach [ amltEntry | {
				val amltAvg = (amltEntry.upperBound + amltEntry.lowerBound) / 2;
				val amltOccurrences = amltEntry.occurrences
				var inchronDiscreteDistributionEntry = inchronModelFactory.createDiscreteDistributionEntry
				inchronDiscreteDistributionEntry.count = amltOccurrences
				inchronDiscreteDistributionEntry.execTime = createTimeTicks(amltAvg)				
				it.discreteDistribution.add(inchronDiscreteDistributionEntry)
			}]
		}
	}


	def Time createTimeTicks(Double value) {
		var Time time = inchronModelFactory.createTime
		time.value = Math.round(value)
		time.unit = TimeUnit.T
		return time
	}
	
	def Time createTimeTicks(Long value) {
		var Time time = inchronModelFactory.createTime
		time.value = value
		time.unit = TimeUnit.T
		return time
	}
	
	
	def Time createTimeTicks(Integer value) {
		var Time time = inchronModelFactory.createTime
		time.value = value
		time.unit = TimeUnit.T
		return time
	}
	
}