praktikum-holons/src/api/AlgorithmFrameworkFlex.java

package api;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.image.BufferedImage;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.math.RoundingMode;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.stream.Collectors;

import javax.swing.BorderFactory;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JFileChooser;
import javax.swing.JFormattedTextField;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JProgressBar;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.text.NumberFormatter;

import classes.AbstractCpsObject;
import classes.CpsUpperNode;
import classes.Flexibility;
import classes.HolonElement;
import classes.HolonObject;
import classes.HolonSwitch;
import ui.controller.Control;
import ui.controller.FlexManager.FlexState;
import ui.controller.FlexManager.FlexWrapper;
import ui.model.DecoratedGroupNode;
import ui.model.DecoratedState;
import ui.model.Model;
import ui.view.Console;

public abstract class AlgorithmFrameworkFlex implements AddOn{
	//Algo
	protected int rounds = 3;
	
	
	
	//Panel
	private JPanel content = new JPanel();
	protected Console console = new Console();
	private JPanel borderPanel = new JPanel();
	
	
	//Settings groupNode
	private boolean useGroupNode = false;
	private DecoratedGroupNode dGroupNode = null;
	
	
	//access
	private ArrayList<AccessWrapper> access;
	LinkedList<List<Boolean>> resetChain = new LinkedList<List<Boolean>>();
	boolean algoUseElements = true, algoUseSwitches = true, algoUseFlexes = true;
	
	//time
	private long startTime;
	
	
	private RunProgressBar runProgressbar = new RunProgressBar();
	
	
	
	//concurrency
	private Thread runThread = new Thread();
	protected boolean cancel = false;

	//holeg interaction
	private Control  control;

	
	//printing
	protected RunDataBase db;
	private RunPrinter printer = new RunPrinter("plott.txt");



	
	
	public AlgorithmFrameworkFlex(){
		content.setLayout(new BorderLayout());
		JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT,
				createOptionPanel() , console);
		splitPane.setResizeWeight(0.0);
		content.add(splitPane, BorderLayout.CENTER);
		content.setPreferredSize(new Dimension(800,800));
	}
	
	
	
	
	
	
	private JPanel createOptionPanel() {
		JPanel optionPanel = new JPanel(new BorderLayout());
		JScrollPane scrollPane = new JScrollPane(createParameterPanel());
		scrollPane.setBorder(BorderFactory.createTitledBorder("Parameter"));
		optionPanel.add(scrollPane,  BorderLayout.CENTER);
		optionPanel.add(createButtonPanel(), BorderLayout.PAGE_END);
		return optionPanel;
	}
	
	private Component createParameterPanel() {
		JPanel parameterPanel = new JPanel(null);
		parameterPanel.setPreferredSize(new Dimension(510,300));
		borderPanel.setLayout(new BoxLayout(borderPanel, BoxLayout.PAGE_AXIS));
		addIntParameter("Rounds", rounds, intInput -> rounds = intInput, 1);
		JScrollPane scrollPane = new JScrollPane(borderPanel);
		scrollPane.setBounds(10, 0, 450, 292);
		scrollPane.setBorder(BorderFactory.createEmptyBorder());
		parameterPanel.add(scrollPane);	
		
		
		
		JButton selectGroupNodeButton = new JButton("Select GroupNode");
		selectGroupNodeButton.setBounds(500, 0, 185, 30);
		selectGroupNodeButton.addActionListener(actionEvent -> selectGroupNode());
		parameterPanel.add(selectGroupNodeButton);	
		JProgressBar progressBar = runProgressbar.getJProgressBar();
		progressBar.setBounds(500, 35, 185, 20);
		progressBar.setStringPainted(true);
		parameterPanel.add(progressBar);
		
		JCheckBox useElements = new JCheckBox("Elements");
		useElements.setSelected(algoUseElements);
		useElements.setBounds(500, 70, 185, 20);
		useElements.addActionListener(actionEvent -> algoUseElements = useElements.isSelected());
		parameterPanel.add(useElements);
		
		JCheckBox useSwitches = new JCheckBox("Switches");
		useSwitches.setSelected(algoUseSwitches);
		useSwitches.setBounds(500, 90, 185, 20);
		useSwitches.addActionListener(actionEvent -> algoUseSwitches = useSwitches.isSelected());
		parameterPanel.add(useSwitches);
		
		
		JCheckBox useFlexes = new JCheckBox("Flexibilities");
		useFlexes.setSelected(algoUseFlexes);
		useFlexes.setBounds(500, 110, 185, 20);
		useFlexes.addActionListener(actionEvent -> algoUseFlexes = useFlexes.isSelected());
		parameterPanel.add(useFlexes);
		return parameterPanel;
	}
	private JPanel createButtonPanel() {
		JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		
		JButton resetButton =  new JButton("Reset");
		resetButton.setToolTipText("Resets the State to before the Algorithm has runed.");
		resetButton.addActionListener(actionEvent -> reset());
		buttonPanel.add(resetButton);
		
		JButton cancelButton =  new JButton("Cancel Run");
		cancelButton.addActionListener(actionEvent -> cancel());
		buttonPanel.add(cancelButton);
		
		JButton plottButton =  new JButton("Plott");
		plottButton.addActionListener(actionEvent -> plott());
		buttonPanel.add(plottButton);
		
		JButton fitnessButton =  new JButton("Fitness");
		fitnessButton.setToolTipText("Fitness for the current state.");
		fitnessButton.addActionListener(actionEvent -> fitness());
		buttonPanel.add(fitnessButton);
		
		JButton runButton =  new JButton("Run");
		runButton.addActionListener(actionEvent -> {
			Runnable task = () -> run();
			runThread = new Thread(task);
			runThread.start();
		});
		buttonPanel.add(runButton);
		
		
		
		return buttonPanel;
	}
	
	
	
	//ParameterImports
	
	//int
	protected void addIntParameter(String parameterName, int parameterValue, IntConsumer setter) {
		this.addIntParameter(parameterName, parameterValue, setter, Integer.MIN_VALUE, Integer.MAX_VALUE);
	}
	
	protected void addIntParameter(String parameterName, int parameterValue, IntConsumer setter, int parameterMinValue) {
		this.addIntParameter(parameterName, parameterValue, setter, parameterMinValue, Integer.MAX_VALUE);
	}
	
	protected void addIntParameter(String parameterName, int parameterValue, IntConsumer setter, int parameterMinValue, int parameterMaxValue) {
		JPanel singleParameterPanel = new JPanel();
		singleParameterPanel.setLayout(new BoxLayout(singleParameterPanel, BoxLayout.LINE_AXIS));
		singleParameterPanel.setAlignmentX(0.0f);
		singleParameterPanel.add(new JLabel(parameterName + ": "));
		singleParameterPanel.add(Box.createHorizontalGlue());
		NumberFormat format = NumberFormat.getIntegerInstance();
		format.setGroupingUsed(false);
		format.setParseIntegerOnly(true);
		NumberFormatter integerFormatter = new NumberFormatter(format);
		integerFormatter.setMinimum(parameterMinValue);
		integerFormatter.setMaximum(parameterMaxValue);
		integerFormatter.setCommitsOnValidEdit(true);
		JFormattedTextField singleParameterTextField = new  JFormattedTextField(integerFormatter);
		singleParameterTextField.setValue(parameterValue);
		String minValue = (parameterMinValue == Integer.MIN_VALUE)?"Integer.MIN_VALUE":String.valueOf(parameterMinValue);
		String maxValue = (parameterMaxValue == Integer.MAX_VALUE)?"Integer.MAX_VALUE":String.valueOf(parameterMaxValue);
		singleParameterTextField.setToolTipText("Only integer \u2208 [" + minValue + "," + maxValue + "]");
		singleParameterTextField.addPropertyChangeListener(actionEvent -> setter.accept(Integer.parseInt(singleParameterTextField.getValue().toString())));
		singleParameterTextField.setMaximumSize(new Dimension(200, 30));
		singleParameterTextField.setPreferredSize(new Dimension(200, 30));
		singleParameterPanel.add(singleParameterTextField);
		borderPanel.add(singleParameterPanel);
	}
	
	
	//double
	protected void addDoubleParameter(String parameterName, double parameterValue, DoubleConsumer setter) {
		this.addDoubleParameter(parameterName, parameterValue, setter, Double.MIN_VALUE, Double.MAX_VALUE);
	}
	
	
	protected void addDoubleParameter(String parameterName, double parameterValue, DoubleConsumer setter, double parameterMinValue) {
		this.addDoubleParameter(parameterName, parameterValue, setter, parameterMinValue, Double.MAX_VALUE);
	}
	
	
	protected void addDoubleParameter(String parameterName, double parameterValue, DoubleConsumer setter, double parameterMinValue, double parameterMaxValue) {
		JPanel singleParameterPanel = new JPanel();
		singleParameterPanel.setLayout(new BoxLayout(singleParameterPanel, BoxLayout.LINE_AXIS));
		singleParameterPanel.setAlignmentX(0.0f);
		singleParameterPanel.add(new JLabel(parameterName + ": "));
		singleParameterPanel.add(Box.createHorizontalGlue());
		NumberFormat doubleFormat = NumberFormat.getNumberInstance(Locale.US);
		doubleFormat.setMinimumFractionDigits(1);
		doubleFormat.setMaximumFractionDigits(10);
		doubleFormat.setRoundingMode(RoundingMode.HALF_UP);
		NumberFormatter doubleFormatter = new NumberFormatter(doubleFormat);
		doubleFormatter.setMinimum(parameterMinValue);
		doubleFormatter.setMaximum(parameterMaxValue);
		JFormattedTextField singleParameterTextField = new  JFormattedTextField(doubleFormatter);
		singleParameterTextField.setValue(parameterValue);
		String minValue = (parameterMinValue == Double.MIN_VALUE)?"Double.MIN_VALUE":String.valueOf(parameterMinValue);
		String maxValue = (parameterMaxValue == Double.MAX_VALUE)?"Double.MAX_VALUE":String.valueOf(parameterMaxValue);
		singleParameterTextField.setToolTipText("Only double \u2208 [" + minValue + "," + maxValue + "]");
		singleParameterTextField.addPropertyChangeListener(actionEvent -> setter.accept(Double.parseDouble(singleParameterTextField.getValue().toString())));
		singleParameterTextField.setMaximumSize(new Dimension(200, 30));
		singleParameterTextField.setPreferredSize(new Dimension(200, 30));
		singleParameterPanel.add(singleParameterTextField);
		borderPanel.add(singleParameterPanel);
	}
	//boolean
	protected void addBooleanParameter(String parameterName, boolean parameterValue, Consumer<Boolean> setter){
		JPanel singleParameterPanel = new JPanel();
		singleParameterPanel.setLayout(new BoxLayout(singleParameterPanel, BoxLayout.LINE_AXIS));
		singleParameterPanel.setAlignmentX(0.0f);
		singleParameterPanel.add(new JLabel(parameterName + ": "));
		singleParameterPanel.add(Box.createHorizontalGlue());
		JCheckBox useGroupNodeCheckBox = new JCheckBox();
		useGroupNodeCheckBox.setSelected(parameterValue);
		useGroupNodeCheckBox.addActionListener(actionEvent -> setter.accept(useGroupNodeCheckBox.isSelected()));
		singleParameterPanel.add(useGroupNodeCheckBox);
		borderPanel.add(singleParameterPanel);
	}
	

	private void startTimer(){
		startTime = System.currentTimeMillis();
	}
	private void printElapsedTime(){
		long elapsedMilliSeconds = System.currentTimeMillis() - startTime;
		console.println("Execution Time of Algo in Milliseconds:" + elapsedMilliSeconds);
	}
	
	private void plott() {
		if(db!=null) {
			console.println("Plott..");
			printer.print("");
		}else {
			console.println("No run inistialized.");
		}
	}
	
	
	private void cancel() {
		if(runThread.isAlive()) {
			console.println("Cancel run.");
			cancel = true;
			runProgressbar.stop();
		} else {
			console.println("Nothing to cancel.");
		}
	}
	
	
	private void fitness() {
		if(runThread.isAlive()) {
			console.println("Run have to be cancelled First.");
			return;
		}
		double currentFitness = evaluatePosition(extractPositionAndAccess());
		resetChain.removeLast();
		console.println("Actual Fitnessvalue: " + currentFitness);
	}
	
	
	private void selectGroupNode() {
		Object[] possibilities = control.getSimManager().getActualVisualRepresentationalState().getCreatedGroupNodes().values().stream().map(aCps -> new Handle<DecoratedGroupNode>(aCps)).toArray();
		@SuppressWarnings("unchecked")
		Handle<DecoratedGroupNode> selected = (Handle<DecoratedGroupNode>) JOptionPane.showInputDialog(content, "Select GroupNode:", "GroupNode?",  JOptionPane.OK_OPTION,new ImageIcon(new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB)) , possibilities, "");
		if(selected != null) {
			console.println("Selected: " + selected);
			dGroupNode = selected.object;
		}
	}
	
	protected double evaluatePosition(List<Boolean> positionToEvaluate) {
		runProgressbar.step();
		control.getSimManager().resetFlexManagerForTimeStep(control.getModel().getCurIteration());
		setState(positionToEvaluate);
		control.calculateStateOnlyForCurrentTimeStep();
		DecoratedState actualstate = control.getSimManager().getActualDecorState();
		return evaluateState(actualstate);
	}

	protected abstract double evaluateState(DecoratedState actualstate);

	
	private void run() {
		cancel = false;
		control.guiDisable(true);
		executeAlgoWithParameter();
		updateVisual();
		control.guiDisable(false);
	}
	
	private void executeAlgoWithParameter(){
		runProgressbar.start();
		int actualIteration = control.getModel().getCurIteration();
		console.println("TimeStep:" + actualIteration);
		startTimer();
		Individual runBest = new Individual();
		runBest.fitness = Double.MAX_VALUE;
		db = new RunDataBase();
		for(int r = 0; r < rounds; r++)
		{		
			Individual  roundBest = executeAlgo();
			if(cancel)return;
			resetState();
			if(roundBest.fitness < runBest.fitness) runBest = roundBest;
		}
		printElapsedTime();
		control.getSimManager().resetFlexManagerForTimeStep(control.getModel().getCurIteration());
		setState(runBest.position);
		updateVisual();
		console.println("AlgoResult:" + runBest.fitness);
		runProgressbar.stop();
	}
	
	
	protected abstract Individual executeAlgo();






	private void reset() {
		if(runThread.isAlive()) {
			console.println("Run have to be cancelled First.");
			return;
		}
		if(!resetChain.isEmpty()) {
			console.println("Resetting..");
			setState(resetChain.getFirst());
			resetChain.clear();
			control.resetSimulation();
			control.setCurIteration(0);
			updateVisual();
		}else {
			console.println("No run inistialized.");
		}
	}


	/**
	 * To let the User See the current state without touching the Canvas.
	 */
	private void updateVisual() {
		control.calculateStateAndVisualForCurrentTimeStep();
	}
	/**
	 * Sets the Model back to its original State before the LAST run.
	 */
	private void resetState() {
		control.getSimManager().resetFlexManagerForTimeStep(control.getModel().getCurIteration());
		setState(resetChain.getLast());
	}


	/**
	 * Sets the State out of the given position for calculation or to show the user.
	 * @param position
	 */
	private void setState(List<Boolean> position) {
		int i = 0;
		for(Boolean bool: position) {
			access.get(i++).setState(bool);
		}
		
}


	/**
	 * Method to get the current Position alias a ListOf Booleans for aktive settings on the Objects on the Canvas.
	 * Also initialize the Access Hashmap to swap faster positions.
	 * @param model
	 * @return
	 */
	protected List<Boolean> extractPositionAndAccess() {
		Model model = control.getModel();
		access= new ArrayList<AccessWrapper>();
		List<Boolean> initialState = new ArrayList<Boolean>();
		rollOutNodes((useGroupNode && (dGroupNode != null))? dGroupNode.getModel().getNodes() :model.getObjectsOnCanvas(), initialState, model.getCurIteration());			
		resetChain.add(initialState);
		if(algoUseFlexes) {			
			for(FlexWrapper flex :control.getSimManager().getActualFlexManager().getAllFlexWrapperWithState(FlexState.OFFERED)){
				access.add(new AccessWrapper(flex.getFlex()));
				initialState.add(false);
			}
		}
		console.println(access.stream().map(Object::toString).collect(Collectors.joining(", ")));
		return initialState;
	}
	
	/**
	 * Method to extract the Informations recursively out of the Model.
	 * @param nodes
	 * @param positionToInit
	 * @param timeStep
	 */
	private void rollOutNodes(List<AbstractCpsObject> nodes, List<Boolean> positionToInit, int timeStep) {
		for(AbstractCpsObject aCps : nodes) {
			if (aCps instanceof HolonObject && algoUseElements) {
				for (HolonElement hE : ((HolonObject) aCps).getElements()) {
					positionToInit.add(hE.isActive());
					access.add(new AccessWrapper(hE));
				}
			}
			else if (aCps instanceof HolonSwitch&& algoUseSwitches) {
				HolonSwitch sw = (HolonSwitch) aCps;
				positionToInit.add(sw.getState(timeStep));
				access.add(new AccessWrapper(sw));
			}
			else if(aCps instanceof CpsUpperNode) {
				rollOutNodes(((CpsUpperNode)aCps).getNodes(), positionToInit ,timeStep );
			}
		}
	}
	
	
	
	
	
	

	
	@Override
	public JPanel getPanel() {
		return content;
	}

	@Override
	public void setController(Control control) {
		this.control = control;
	}
	
	
	
	private class RunProgressBar{
		//progressbar
		private JProgressBar progressBar = new JProgressBar();
		private int count = 0;
		private boolean isActive = false;
		public void step() {
			if(isActive) progressBar.setValue(count++);
			progressBar.setMaximum(getProgressBarMaxCount());
		}
		public void start() {
			isActive = true;
			progressBar.setValue(0);
		}
		public void stop() {
			isActive = false;
		}
		public JProgressBar getJProgressBar(){
			return progressBar;
		}
	}
	
	protected abstract int getProgressBarMaxCount();
	
	
	
	
	public class RunDataBase{
		List<List<Double>> allRuns = new ArrayList<List<Double>>();
		public void insertNewRun(List<Double> newRun){
			allRuns.add(newRun);
		}
		
	}
	
	
	
	public class RunPrinter{
		//Fields
		private JFileChooser fileChooser = new JFileChooser();
		private boolean append = false;
		//Constructor
		public RunPrinter(String filename) {
			this(filename, false);
		}
		
		public RunPrinter(String filename,  boolean append){
			this.append = append;
			fileChooser.setCurrentDirectory(new File(System.getProperty("user.dir")));
			setFilename(filename);
		}
		//public methods
		public void enableAppend(boolean enable) {
			append = enable;
		}
		public void setFilename(String filename) {
			fileChooser.setSelectedFile(new File(filename));
		}
		public void print(String info) {
			File file = fileChooser.getSelectedFile();
			try {
				file.createNewFile();
				BufferedWriter out = new BufferedWriter(new OutputStreamWriter(
					    new FileOutputStream(file, append), "UTF-8"));
				printToStream(out, info);
				out.close();
			} catch (IOException e) {
				System.out.println(e.getMessage());
			}
		}
		//private methods
		private void printToStream(BufferedWriter out, String info) throws IOException {	
			out.write(info);
			out.newLine();
			if(db != null)
			out.write(db.allRuns.stream().map(list -> list.stream().map(Object::toString).collect(Collectors.joining(","))).collect(Collectors.joining(System.lineSeparator())));
		}
	}
		
	
	/**
	 * A Wrapper Class for Access HolonElement and HolonSwitch in one Element and not have to split the List.
	 */
	private class AccessWrapper {
		public static final int HOLONELEMENT = 0;
		public static final int SWITCH = 1;
		public static final int FLEXIBILITY = 2;
		private int type;
		private HolonSwitch hSwitch;
		private HolonElement hElement;
		private Flexibility flex;
		public AccessWrapper(HolonSwitch hSwitch){
			type = SWITCH;
			this.hSwitch = hSwitch;
		}
		public AccessWrapper(HolonElement hElement){
			type = HOLONELEMENT;
			this.hElement = hElement;
		}
		
		public AccessWrapper(Flexibility flex){
			type = FLEXIBILITY;
			this.flex = flex;
		}
		
		public void setState(boolean state) {
			switch(type) {
				case HOLONELEMENT:
					hElement.setActive(state);
					break;
				case SWITCH:
					hSwitch.setManualMode(true);
					hSwitch.setManualState(state);
					break;
				case FLEXIBILITY:
					if(state) {
//						if(control.getSimManager() == null) console.println("control.getSimManager() == null");
//						if(control.getSimManager().getActualFlexManager() == null) console.println("control.getSimManager().getActualFlexManager() == null");
						control.getSimManager().getActualFlexManager().orderFlex(flex);
					}
					break;
				default:
				
			}
		}
		
		public String typeString() {
			switch(type) {
				case HOLONELEMENT:
					return "HOLONELEMENT";
				case SWITCH:
					return "SWITCH";
				case FLEXIBILITY:
					return "FLEXIBILITY";
				default:
					return "unknown";
			}
		}
		
		public String toString() {
			return "[" +  typeString() + "]";
		}
	}
	
	
	
	
	/**
	* To create Random and maybe switch the random generation in the future.
	*/
	protected static class Random{
		private static java.util.Random random = new java.util.Random();
		/**
		 * True or false
		 * @return the random boolean.
		 */
		public static boolean nextBoolean(){
			return random.nextBoolean();
		}
		/**
		 * Between 0.0(inclusive) and 1.0 (exclusive)
		 * @return the random double.
		 */
		public static double nextDouble() {
			return random.nextDouble();
		}
		
		/**
		 * Random Int in Range [min;max[ with UniformDistirbution
		 * @param min
		 * @param max
		 * @return
		 */
		public static int nextIntegerInRange(int min, int max) {
			return min + random.nextInt(max - min);
		}
	}
	
	private   class  Handle<T>{
		public T object;
		Handle(T object){
			this.object = object;
		}
		public String toString() {
			return object.toString();
		}
	}
	public class Individual {
		public double fitness;
		public  List<Boolean> position;
		
		public Individual(){};
		/**
		 *  Copy Constructor
		 */
		public Individual(Individual c){
			position = c.position.stream().collect(Collectors.toList());
			fitness = c.fitness;
		}
	}
}