package algorithms.geneticAlgorithm.holegGA.Components;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

import classes.AbstractCpsObject;
import classes.CpsEdge;
import classes.CpsNode;
import classes.HolonBattery;
import classes.HolonObject;
import classes.HolonSwitch;
import classes.HolonWildCard;
import algorithms.geneticAlgorithm.Components.GAIndividualFactory;
import algorithms.geneticAlgorithm.holegGA.GAEdge;

public class HolegFactory implements GAIndividualFactory<HolegIndividual> {

	ArrayList<AbstractCpsObject> objectSpace;
	public ArrayList<AbstractCpsObject> originalObjects;
	public ArrayList<CpsEdge> originalEdges;
	public int maxObjects;
	public int maxConnections;
	Random rng;
	public boolean editEdges;
	
	public HolegFactory(ArrayList<AbstractCpsObject> objects, int maxObjects, int maxConnections){
		objectSpace = objects;
		this.maxObjects = maxObjects;
		this.maxConnections = maxConnections;
		rng = new Random();
		originalObjects = new ArrayList<AbstractCpsObject>();
		originalEdges = new ArrayList<CpsEdge>();
		editEdges = false;
	}
	
	@Override
	public HolegIndividual createRandomIndividual() {
		HolegIndividual hI = new HolegIndividual(originalObjects, originalEdges);
		
		/*
		if(maxObjects > 0){
			createObjects(hI);
		}
		*/
		setWildCards(hI);
		if(editEdges){
			editEdges(hI);
		}
		if(maxConnections > 0){
			createEdges(hI);
		}
		return hI;
	}

	private void setWildCards(HolegIndividual hI) {
		int setAmount = rng.nextInt(hI.getWildcardIndexes().size() + 1);
		ArrayList<Integer> list = new ArrayList<Integer>();
		list.addAll(hI.getWildcardIndexes());
		Collections.shuffle(list);
		int spaceIdx = 0;
		if(objectSpace.size() > 0){
			for(int i = 0; i < setAmount; i++){
				AbstractCpsObject wildCard = hI.indexToObjectMap.get(list.get(i));
				spaceIdx = rng.nextInt(objectSpace.size());
				AbstractCpsObject newObj = objectSpace.get(spaceIdx).makeCopy();
				newObj.setPosition(wildCard.getPosition());
				newObj.setId(wildCard.getId());
				hI.addObjectWithIdx(newObj, newObj.getId());
			}
		}
	}
	
	private void editEdges(HolegIndividual hI) {
		if(hI.getOriginalEdges().size() > 0 && hI.getIndexes().size() > 2){
			int editAmount = rng.nextInt(hI.getOriginalEdges().size());
			for(int i = 0; i < editAmount; i++){
				int edgeIdx = rng.nextInt(hI.getOriginalEdges().size());
				GAEdge toChange = hI.getOriginalEdges().get(edgeIdx);
				HolegMutation.changeSingleEdge(hI, toChange, true);
			}
		}
	}

	public void createObjects(HolegIndividual hI){
	
		int objCount = rng.nextInt(maxObjects) + 1;
		
		for(int i = 0; i < objCount; i++){
			
			
			AbstractCpsObject newObj = null;
			if(!editEdges){
				AbstractCpsObject absObj = objectSpace.get(rng.nextInt(objectSpace.size()));
				if(absObj instanceof HolonObject){
					newObj = new HolonObject(absObj);
				}else if(absObj instanceof HolonSwitch){
					newObj = new HolonSwitch(absObj);
				}else if(absObj instanceof HolonBattery){
					newObj = new HolonBattery(absObj);
				}else if(absObj instanceof HolonWildCard){
					newObj = new HolonWildCard(absObj);
				}else if(absObj == null){
					newObj = new CpsNode("Node");
				}
			}else{
				newObj = new CpsNode("Node");
			}
			
			//hI.holonObjects.add(newObj);
			hI.addObject(newObj);
		}
	}
	
	public void createEdges(HolegIndividual hI){
		if(hI.getIndexes().size() > 1){
			int edgeCount = rng.nextInt(maxConnections + 1);
			ArrayList<Integer> list = new ArrayList<Integer>();
	    
			for (int i = 0; i < hI.getIndexes().size(); i++) {
				list.add(hI.getIndexes().get(i));
			}
	   
			if(edgeCount >= hI.getAllEdges().size()){
				edgeCount -= hI.getAllEdges().size();
			}else{
				edgeCount = 0;
			}
			for(int i = 0; i < edgeCount; i++){
				Collections.shuffle(list);
				int aPos = list.get(0);
				int bPos = list.get(1);
				hI.addEdge(aPos, bPos);
			}
		}

	}

}