praktikum-holons/src/algorithms/geneticAlgorithm/holegGA/Components/HolegIndividual.java

package algorithms.geneticAlgorithm.holegGA.Components;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

import classes.AbstractCpsObject;
import classes.CpsEdge;
import classes.CpsNode;
import classes.HolonWildCard;
import algorithms.geneticAlgorithm.Components.GAIndividual;
import algorithms.geneticAlgorithm.holegGA.GAEdge;

public class HolegIndividual extends GAIndividual {
	
	public ArrayList<CpsEdge> brokenEdges = new ArrayList<CpsEdge>();
	public ArrayList<GAEdge> additionalEdges = new ArrayList<GAEdge>();
	public ArrayList<GAEdge> originEdges = new ArrayList<GAEdge>();
	public ArrayList<Integer> indexes = new ArrayList<Integer>();
	public ArrayList<Integer> originIndexes = new ArrayList<Integer>();
	public ArrayList<Integer> wildCardIndexes = new ArrayList<Integer>();
	public ArrayList<HolegIndividual> parents = new ArrayList<HolegIndividual>();
	public HashMap<Integer, AbstractCpsObject> indexToObjectMap = new HashMap<Integer, AbstractCpsObject>();
	private HashMap<AbstractCpsObject, Integer> objectToIndexMap = new HashMap<AbstractCpsObject, Integer>();
	public boolean drawn;
	public String id;
	public String log;
	public String backupLog = "Individual Log";
	public int gen;
	public int pos;
	private int lastIndex;
	public double totalEdgeLength;
	
	public HolegIndividual(ArrayList<AbstractCpsObject> originObjects, 
			ArrayList<CpsEdge> originalEdges){

		lastIndex = 0;
		log = "Individual Log";
		drawn = false;
		
		for(AbstractCpsObject abs : originObjects){

			AbstractCpsObject newObj = abs.makeCopy();
			newObj.setPosition(abs.getPosition());
			newObj.setId(abs.getId());
			addObject(newObj);
			originIndexes.add(objectToIndexMap.get(newObj));
			if(newObj instanceof HolonWildCard){
				wildCardIndexes.add(objectToIndexMap.get(newObj));
			}
			
		}
		
		if(originalEdges != null){
			for(CpsEdge e : originalEdges){
				addOriginalEdge(e);
			}
		}
	}
	
	public HolegIndividual(HolegIndividual indi){
		additionalEdges = new ArrayList<GAEdge>();
		additionalEdges.addAll(indi.getAdditionalEdges());
		originEdges = new ArrayList<GAEdge>();
		originEdges.addAll(indi.originEdges);
		indexes = new ArrayList<Integer>();
		indexes.addAll(indi.getIndexes());
		originIndexes = new ArrayList<Integer>();
		originIndexes.addAll(indi.originIndexes);
		parents = new ArrayList<HolegIndividual>();
		
		indexToObjectMap = new HashMap<Integer, AbstractCpsObject>();
		objectToIndexMap = new HashMap<AbstractCpsObject, Integer>();
		Set<Integer> keys = indi.indexToObjectMap.keySet();
		for(Integer i : keys){
			indexToObjectMap.put(i, indi.indexToObjectMap.get(i));
			objectToIndexMap.put(indi.indexToObjectMap.get(i), i);
		}

		lastIndex = indi.lastIndex;
		log = "Individual Log";
		drawn = false;
		
	}
	
	public ArrayList<HolegIndividual> getParents(){
		return parents;
	}
	
	public void setParents(ArrayList<HolegIndividual> parents){
		this.parents = parents;
		for(int i = 0; i < parents.size(); i++){
			addLogEntry("Parent" + i + ": " + parents.get(i).getId());
		}
		backupLog = log;
	}
	
	public void setId(int Gen, int pos){
		if(Gen > 0){
			id = "Generation_" + Gen + " Rank_" + pos;
		}else{
			id = "Generation_Original";
		}
	}
	
	public String getId(){
		return id;
	}
	
	public ArrayList<AbstractCpsObject> getObjects(){
		ArrayList<AbstractCpsObject> objects = new ArrayList<AbstractCpsObject>();
		for(Integer i : indexes){
			objects.add(indexToObjectMap.get(i));
		}
		return objects;
	}
	
	public ArrayList<AbstractCpsObject> getOriginObjects(){
		ArrayList<AbstractCpsObject> originObjects = new ArrayList<AbstractCpsObject>();
		for(Integer i : originIndexes){
			originObjects.add(indexToObjectMap.get(i));
		}
		return originObjects;
	}
	
	public AbstractCpsObject getObjectWithIndex(int index){
		return indexToObjectMap.get(index);
	}
	
	public AbstractCpsObject getObjectAt(int position){
		return indexToObjectMap.get(indexes.get(position));
	}
	
	public ArrayList<Integer> getIndexes(){
		return indexes;
	}
	
	public ArrayList<Integer> getWildcardIndexes(){
		return wildCardIndexes;
	}
	
	public ArrayList<GAEdge> getAdditionalEdges(){
		return additionalEdges;
	}
	
	public ArrayList<GAEdge> getOriginalEdges(){
		return originEdges;
	}
	
	public ArrayList<GAEdge> getAllEdges(){
		ArrayList<GAEdge> allEdges = new ArrayList<GAEdge>();
		allEdges.addAll(additionalEdges);
		allEdges.addAll(originEdges);
		return allEdges;
	}
	
	public void addObject(AbstractCpsObject obj){
		addObjectWithIdx(obj, obj.getId());
		/*
		addObjectWithIdx(obj, lastIndex);
		lastIndex++;
		*/
	}
	
	public void addObjectWithIdx(AbstractCpsObject obj, int index){
		if(!indexToObjectMap.containsKey(index)){
			addIndex(index);
			indexToObjectMap.put(index, obj);
			objectToIndexMap.put(obj, index);
		}else{
			objectToIndexMap.remove(indexToObjectMap.get(index));
			indexToObjectMap.put(index, obj);
			objectToIndexMap.put(obj, index);
		}
		//indexToObjectMap.put(index, obj);
	}
	
	public void removeObject(int index){
		AbstractCpsObject toRemove = indexToObjectMap.get(index);
		HolonWildCard fill = new HolonWildCard("WildCard");
		fill.setId(toRemove.getId());
		fill.setPosition(toRemove.getPosition());
		indexToObjectMap.put(index, fill);
	}
	
	public void addIndex(int index){
		for(int i = 0; i < indexes.size(); i++){
			if(index < indexes.get(i)){
				indexes.add(i, index);
				return;
			}
		}
		indexes.add(index);
		return;
	}
	/*
	 * posA and posB are the indexes of the Endpoints A and B in the list of Objects
	 */
	public void addEdge(int indexA, int indexB){
		if(!edgeExists(indexA, indexB, getAllEdges())){
			
			if(!indexToObjectMap.containsKey(indexA)){
				CpsNode newObjA = new CpsNode("Node");
				addObjectWithIdx(newObjA, indexA);
			}
			if(!indexToObjectMap.containsKey(indexB)){
				CpsNode newObjB = new CpsNode("Node");
				addObjectWithIdx(newObjB, indexB);
			}
			additionalEdges.add(new GAEdge(indexA, indexB, indexToObjectMap.get(indexA), indexToObjectMap.get(indexB)));
		
		}
	}
	
	public void addOriginalEdge(CpsEdge e){
		if(indexToObjectMap.containsKey(e.getA().getId()) && indexToObjectMap.containsKey(e.getB().getId())){
			GAEdge realEdge = new GAEdge(e.getA().getId(), e.getB().getId(),
					indexToObjectMap.get(e.getA().getId()), indexToObjectMap.get(e.getB().getId()));
			
			if(!edgeExists(realEdge.aPos, realEdge.bPos, originEdges)){
				originEdges.add(realEdge);
			}
		}
	}
	
	public void addOriginalEdge(GAEdge e){
		if(!edgeExists(e.aPos, e.bPos, originEdges)){
			originEdges.add(new GAEdge(e.aPos, e.bPos, indexToObjectMap.get(e.aPos), 
					indexToObjectMap.get(e.bPos)));
		}
	}
	
	public boolean edgeExists(int indexA, int indexB, ArrayList<GAEdge> edges){
		for(GAEdge e : edges){
			if((e.aPos == indexA && e.bPos == indexB) || (e.bPos == indexA && e.aPos == indexB)){
				return true;
			}
		}
		return false;
	}
	
	public void addLogEntry(String entry){
		log += "\n" + entry;
	}
	
	public void resetLog(){
		log = backupLog;	
	}
	
	public int getAvailableIndex(){
		for(int i = 0; i <= indexes.size(); i++){
			if(!indexes.contains(i)){
				return i;
			}
		}
		return -1;
	}
	
	
	public void configurateNetwork(){

		for(GAEdge e : getAllEdges()){
			e.setA(indexToObjectMap.get(e.aPos));
			e.setB(indexToObjectMap.get(e.bPos));
			e.revalidateConnection();
		}
	}

	public void setEdgeLength(double doubleValue) {
		totalEdgeLength = doubleValue;
	}

}