/**
 * *******************************************************************************
 *  Copyright (c) 2017 Timing-Architects Embedded Systems GmbH and others.
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Timing-Architects Embedded Systems GmbH - initial API and implementation
 *
 * *******************************************************************************
 */
package org.eclipse.app4mc.amalthea.generator.ui;

import java.math.BigInteger;

import org.eclipse.app4mc.amalthea.generator.configuration.ActivationProperties;
import org.eclipse.app4mc.amalthea.generator.configuration.Generation;
import org.eclipse.app4mc.amalthea.generator.configuration.IntegerTimeDistribution;
import org.eclipse.app4mc.amalthea.generator.configuration.PercentageDistribution;
import org.eclipse.app4mc.amalthea.generator.configuration.PeriodicActivation;
import org.eclipse.app4mc.amalthea.generator.configuration.PeriodicTriangleShift;
import org.eclipse.app4mc.amalthea.generator.configuration.RTMGC;
import org.eclipse.app4mc.amalthea.generator.configuration.RTMGCFactory;
import org.eclipse.app4mc.amalthea.generator.configuration.Recurrence;
import org.eclipse.app4mc.amalthea.generator.configuration.SporadicActivation;
import org.eclipse.app4mc.amalthea.generator.configuration.TimeUnit;
import org.eclipse.app4mc.amalthea.generator.configuration.TriangleClock;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.ScrolledComposite;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Spinner;
import org.eclipse.swt.widgets.TabFolder;
import org.eclipse.swt.widgets.TabItem;

public class ActivationsConfigurationHelper implements IConfigurationHelper {
	
	private Spinner periodicProbabilitySpinner;
	private IntegerTimeDistributionGroup periodicOffset;
	private RecurrenceGroup periodicRecurrence;

	private Spinner triangleProbabilitySpinner;
	private IntegerTimeDistributionGroup triangleOffset;
	private RecurrenceGroup triangleRecurrence;
	
	private Spinner sporadicProbabilitySpinner;
	private IntegerTimeDistributionGroup sporadicMin;
	private PercentageDistributionGroup sporadicAvg;
	private PercentageDistributionGroup sporadicMax;

	public void addTabItem(TabFolder parent) {
		TabItem tab = new TabItem(parent, SWT.NONE);
		tab.setText("Activations");
		
		ScrolledComposite sc = new ScrolledComposite(parent, SWT.BORDER | SWT.V_SCROLL);
		
		Composite container = new Composite(sc, SWT.NONE);
		container.setLayout(new GridLayout());
		GridLayout gridLayout = new GridLayout();
	    container.setLayout(gridLayout);
	    gridLayout.numColumns = 2;
		
	    sc.setExpandVertical(true);
	    sc.setExpandHorizontal(true);
		
	    // periodic
	    Label label = new Label(container, SWT.NONE);
	    label.setText("Periodic Activations [%]");
	    label.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
	    periodicProbabilitySpinner = new Spinner(container, SWT.NONE);
	    periodicProbabilitySpinner.setMinimum(0);
	    periodicProbabilitySpinner.setMaximum(100);
	    periodicProbabilitySpinner.setIncrement(1);
	    periodicProbabilitySpinner.setSelection(100);
	    
	    this.periodicOffset = new IntegerTimeDistributionGroup(container, "Offset", 0, 5, 50, TimeUnit.MS);
	    this.periodicRecurrence = new RecurrenceGroup(container, "Recurrence", 1, 10, 1000, TimeUnit.MS);	    
	    
	    // periodic triangle shift
	    label = new Label(container, SWT.NONE);
	    label.setText("");
	    GridData gridData = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridData.horizontalSpan = 2;
		gridData.heightHint = 30;
		label.setLayoutData(gridData);
	    label = new Label(container, SWT.NONE);
	    label.setText("Periodic Triangle Shifts [%]");
	    label.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
	    triangleProbabilitySpinner = new Spinner(container, SWT.NONE);
	    triangleProbabilitySpinner.setMinimum(0);
	    triangleProbabilitySpinner.setMaximum(Integer.MAX_VALUE);
	    triangleProbabilitySpinner.setIncrement(1);
	    triangleProbabilitySpinner.setSelection(0);
	    
	    this.triangleRecurrence = new RecurrenceGroup(container, "Recurrence");
	    this.triangleOffset = new IntegerTimeDistributionGroup(container, "Offset");
	    
	    // sporadic
	    label = new Label(container, SWT.NONE);
	    label.setText("");
	    gridData = new GridData(GridData.FILL, GridData.CENTER, true, false);
		gridData.horizontalSpan = 2;
		gridData.heightHint = 30;
		label.setLayoutData(gridData);
	    label = new Label(container, SWT.NONE);
	    label.setText("Sporadic Activations  [%]");
	    label.setLayoutData(new GridData(GridData.FILL, GridData.CENTER, true, false));
	    sporadicProbabilitySpinner = new Spinner(container, SWT.NONE);
	    sporadicProbabilitySpinner.setMinimum(0);
	    sporadicProbabilitySpinner.setMaximum(Integer.MAX_VALUE);
	    sporadicProbabilitySpinner.setIncrement(1);
	    sporadicProbabilitySpinner.setSelection(0);
	    
	    // min value
	    this.sporadicMin = new IntegerTimeDistributionGroup(container, "Minimum Value");
	    this.sporadicAvg = new PercentageDistributionGroup(container, "Average Distance");
	    this.sporadicMax = new PercentageDistributionGroup(container, "Maximum Distance");
	    
	    sc.setContent(container);
		sc.setMinSize(container.computeSize(SWT.DEFAULT, SWT.DEFAULT));
	    tab.setControl(sc);;
	}

	public void loadConfiguration(RTMGC rtmgc) {
		if(null != rtmgc) {
			Generation generation = rtmgc.getGeneration();
			if(null != generation) {
				ActivationProperties activations = generation.getActivations();
				if(null != activations) {
					PeriodicActivation periodic = activations.getPeriodicActivation();
					if(null != periodic) {
						this.periodicProbabilitySpinner.setSelection(periodic.getAppearanceProbability().intValue());
						IntegerTimeDistribution offset = periodic.getOffset();
						this.periodicOffset.set(offset);
						Recurrence recurrence = periodic.getRecurrence();
						this.periodicRecurrence.set(recurrence);
					}
					PeriodicTriangleShift triangle = activations.getPeriodicTriangleShift();
					if(null != triangle) {
						this.triangleProbabilitySpinner.setSelection(triangle.getAppearanceProbability().intValue());
						IntegerTimeDistribution offset = triangle.getOffset();
						this.triangleOffset.set(offset);
						Recurrence recurrence = triangle.getRecurrence();
						this.triangleRecurrence.set(recurrence);

						TriangleClock clock = triangle.getClock();
						if(null != clock) {
							//TODO:
						}
					}
					SporadicActivation sporadic = activations.getSporadicActivation();
					if(null != sporadic) {
						this.sporadicProbabilitySpinner.setSelection(sporadic.getAppearanceProbability().intValue());
						IntegerTimeDistribution min = sporadic.getMinValue();
						this.sporadicMin.set(min);
						PercentageDistribution avg = sporadic.getAvgValueDistance();
						this.sporadicAvg.set(avg);
						PercentageDistribution max = sporadic.getMaxValueDistance();
						this.sporadicMax.set(max);
					}
				}
			}
		}
	}
	
	/*
	 * Update configuration values with the values from the UI widgets
	 */
	public void updateConfiguration(RTMGC rtmgc) {
		if(null != rtmgc) {
			Generation generation = rtmgc.getGeneration();
			if(null == generation) {
				generation = RTMGCFactory.eINSTANCE.createGeneration();
				rtmgc.setGeneration(generation);
			}
			ActivationProperties activations = generation.getActivations();
			if(null == activations) {
				activations = RTMGCFactory.eINSTANCE.createActivationProperties();
				generation.setActivations(activations);
			}
			updatePeriodic(activations);
			updateTriangle(activations);
			updateSporadic(activations);
		}
	}
	
	private void updatePeriodic(ActivationProperties activations) {
		PeriodicActivation periodic = activations.getPeriodicActivation();
		if(null == periodic) {
			periodic = RTMGCFactory.eINSTANCE.createPeriodicActivation();
			activations.setPeriodicActivation(periodic);
		}
		periodic.setAppearanceProbability(BigInteger.valueOf(this.periodicProbabilitySpinner.getSelection()));
		IntegerTimeDistribution offset = this.periodicOffset.get();
		periodic.setOffset(offset);
		Recurrence recurrence = this.periodicRecurrence.get();
		periodic.setRecurrence(recurrence);
	}
		
	private void updateTriangle(ActivationProperties activations) {
		PeriodicTriangleShift triangle = activations.getPeriodicTriangleShift();
		if(null == triangle) {
			triangle = RTMGCFactory.eINSTANCE.createPeriodicTriangleShift();
			activations.setPeriodicTriangleShift(triangle);
		}
		triangle.setAppearanceProbability(BigInteger.valueOf(this.triangleProbabilitySpinner.getSelection()));
		IntegerTimeDistribution offset = this.triangleOffset.get();
		triangle.setOffset(offset);
		Recurrence recurrence = this.triangleRecurrence.get();
		triangle.setRecurrence(recurrence);
		
		TriangleClock clock = triangle.getClock();
		if(null == clock) {
			//TODO:
		}
	}
	
	private void updateSporadic(final ActivationProperties activations) {
		SporadicActivation sporadic = activations.getSporadicActivation();
		if(null == sporadic) {
			sporadic = RTMGCFactory.eINSTANCE.createSporadicActivation();
			activations.setSporadicActivation(sporadic);
		}
		sporadic.setAppearanceProbability(BigInteger.valueOf(this.sporadicProbabilitySpinner.getSelection()));
		IntegerTimeDistribution min = this.sporadicMin.get();
		sporadic.setMinValue(min);
		PercentageDistribution avg = this.sporadicAvg.get();
		sporadic.setAvgValueDistance(avg);
		PercentageDistribution max = this.sporadicMax.get();
		sporadic.setMaxValueDistance(max);
	}

	@Override
	public boolean isValid() {
		return true;
	}
}