Foundation.java

package de._82grfl1bif.KPI_Visualizer.structures;

import de._82grfl1bif.KPI_Visualizer.helpers.Layout;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.util.Vector;

import javax.management.AttributeNotFoundException;
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Foundation extends Structure{

    private ArrayList<Structure> children = new ArrayList<>();
    private Layout layout;

    public Foundation(int depth, Material material){ //Foundations are uniform Height
        this.width.x = 0;
        this.depth = depth;
        this.material = material;
    }

    public ArrayList<Structure> getChildren() {
        return children;
    }

    public void addChildren(ArrayList<Structure> children) {
        for (Structure s:children) {
            s.setDepth(this.depth);
        }
        this.children.addAll(children);
    }

    public  void removeChildren(){
        this.children = new ArrayList<>();
    }

    public void optimizeLayout(){
        int cWith = 0;
        for (Structure s : children) {
            s.setLocation(location.clone().add(new Vector(1,depth,((cWith)+1))));
            cWith += (s.getWidth().x + 2);
        }
        this.width.x = cWith;
    }

    private static class DepthComparator implements Comparator<Foundation>{
        @Override
        public int compare(Foundation o1, Foundation o2) {
            return Integer.compare(o1.getDepth(), o2.getDepth());
        }
    }

    private static class WidthComparator implements Comparator<Structure>{

        @Override
        public int compare(Structure o1, Structure o2) {
            return Integer.compare(o1.getWidth().x, o2.getWidth().x);
        }
    }

    private boolean baseFoundation = true;

    public void organizeFoundation(){
        if(this.depth == 0 && baseFoundation){ //rootElement prepwork and recursion call
            ArrayList<Foundation> allFoundations = collectAllFoundations();
            baseFoundation = false;
            allFoundations.sort(new DepthComparator());
            Collections.reverse(allFoundations); //higher Depths first
            for (Foundation f:allFoundations) {
                //if(!this.equals(f))
                f.organizeFoundation();
            }
        }else{ //normal Call and recursion
            this.children.sort(new WidthComparator());
            Collections.reverse(this.children); //Widest Building or Foundation first
            this.layout = new Layout(this.children);
            this.layout.createLayout();
            this.width.x = layout.getSize();
        }
    }

    private ArrayList<Foundation> collectAllFoundations(){ //called on the base Foundation
        ArrayList<Foundation> fCollection = new ArrayList<>();
        fCollection.add(this);
        int currentDepth = this.depth;
        int lastDepthAdded = -1;
        while (lastDepthAdded != 0){ //while there are new nextDepths in this Depth.
            for (int i = 0; i < fCollection.size();i++) {
                if (!(fCollection.get(i).getDepth() < currentDepth)){ //if f is not part of a historical depth
                    fCollection.addAll(fCollection.get(i).getNextDepth());
                    lastDepthAdded = fCollection.get(i).getNextDepth().size();
                }
            }
            currentDepth += 1;
        }
        return fCollection;
    }

    private ArrayList<Foundation> getNextDepth(){
        ArrayList<Foundation> result = new ArrayList<>();
        for (Structure s:this.children) {
            if (s.getClass() == Foundation.class){
                result.add((Foundation) s);
            }else {
                s.setDepth(this.depth);
            }
        }
        for (Foundation f:result) {
            f.setDepth((this.depth)+1);
        }
        return result;
    }

    public void correctAllLocations(Location location){
        for (Structure s:this.children) {
            try {
                Point temp = this.layout.getCoordinateOf(s);
                s.setLocation(location.clone().add(temp.x,0,temp.y));
                if (s.getClass() == Foundation.class){
                    Foundation f = (Foundation)s;
                    f.correctAllLocations(f.getLocation());
                }
            } catch (AttributeNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}