praktikum-holons/src/holeg/ui/controller/Control.java

package holeg.ui.controller;

import holeg.model.*;
import holeg.preferences.ImagePreference;
import holeg.preferences.PreferenceKeys;
import holeg.serialize.CategoryAdapter;
import holeg.ui.model.GuiSettings;
import holeg.ui.model.IdCounter;
import holeg.ui.model.UndoHistory;
import holeg.ui.view.category.Category;
import holeg.utility.events.Action;
import holeg.utility.events.Event;
import holeg.utility.math.vector.Vec2i;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
import java.util.logging.Logger;
import java.util.prefs.Preferences;
import java.util.spi.AbstractResourceBundleProvider;
import java.util.stream.Collectors;

import static holeg.serialize.ModelDeserializer.gson;


/**
 * The Class represents the controller.
 */
public class Control {
    private static final Logger log = Logger.getLogger(Control.class.getName());
    private static final Preferences prefs = Preferences.userNodeForPackage(Control.class);
    private final CanvasController canvasController;
    private final SimulationManager simulationManager;
    public Event OnCategoryChanged = new Event();
    public Event OnSelectionChanged = new Event();
    public Event OnCanvasUpdate = new Event();
    public Action<Boolean> OnGuiSetEnabled = new Action<>();
    public Action<GroupNode> OnShowGroupNode = new Action<>();
    public Action<GroupNode> OnRemoveGroupNode = new Action<>();
    public Event OnModelChanged = new Event();
    private Model model;

    public Control(Model model) {
        this.model = model;
        this.canvasController = new CanvasController(this);
        this.simulationManager = new SimulationManager(this);
        OnCanvasUpdate.addListener(() -> UndoHistory.addSave(saveModelToJsonString()));
        UndoHistory.addSave(saveModelToJsonString());
    }






    /* Operations for Categories and Objects */

    /**
     * init default category and objects.
     */
    public void resetCategories() {
        GuiSettings.getCategories().clear();
        initCategories();
        saveCategories();
    }

    /**
     * Add new Holon Object to a Category.
     */
    public void addObject(Category cat, String obj, List<HolonElement> list, String img) {
        addNewHolonObject(cat, obj, list, img);
        OnCategoryChanged.broadcast();
        saveCategories();
    }


    public void deleteCategory(Category category) {
        GuiSettings.getCategories().remove(category);
        OnCategoryChanged.broadcast();
        saveCategories();
    }

    /**
     * removes a selectedObject from selection.
     */
    public void removeObjectsFromSelection(Collection<AbstractCanvasObject> objects) {
        if (GuiSettings.getSelectedObjects().removeAll(objects)) {
            OnSelectionChanged.broadcast();
        }
    }

    /**
     * removes a selectedObject from selection.
     *
     * @param obj
     */
    public void removeObjectFromSelection(AbstractCanvasObject obj) {
        if (GuiSettings.getSelectedObjects().remove(obj)) {
            OnSelectionChanged.broadcast();
        }
    }

    public void addObjectToSelection(AbstractCanvasObject obj) {
        if (GuiSettings.getSelectedObjects().add(obj)) {
            OnSelectionChanged.broadcast();
        }
    }

    public void addObjectsToSelection(Collection<AbstractCanvasObject> objects) {
        if (GuiSettings.getSelectedObjects().addAll(objects)) {
            OnSelectionChanged.broadcast();
        }

    }


    public void setSelection(Collection<AbstractCanvasObject> objects) {
        GuiSettings.getSelectedObjects().clear();
        addObjectsToSelection(objects);
    }

    public void clearSelection() {
        if (!GuiSettings.getSelectedObjects().isEmpty()) {
            GuiSettings.getSelectedObjects().clear();
            OnSelectionChanged.broadcast();
        }
    }

    public void addObjectOnCanvas(GroupNode node, AbstractCanvasObject object) {
        canvasController.addObject(node, object);
        updateStateForIteration(model.getCurrentIteration());
    }


    /**
     * Deletes an CpsObject on the Canvas and its connections.
     *
     * @param obj AbstractCpsObject
     */
    public void deleteObject(AbstractCanvasObject obj) {
        canvasController.deleteObject(obj);
        if (obj instanceof GroupNode groupnode) {
            canvasController.deleteAllObjectsInGroupNode(groupnode);
        }
        calculateStateForCurrentIteration();
        OnCanvasUpdate.broadcast();
    }

    public void deleteCanvasObjects(Collection<AbstractCanvasObject> objects) {
        canvasController.deleteObjects(objects);
        calculateStateForCurrentIteration();
        OnCanvasUpdate.broadcast();
    }

    /**
     * Replaces {@code toBeReplaced} by {@code by} on the canvas
     *
     * @param toBeReplaced the object that will be replaced
     * @param by           the object that will replace it
     */
    public void replaceCanvasObject(AbstractCanvasObject toBeReplaced, AbstractCanvasObject by) {
        canvasController.replaceObject(toBeReplaced, by);
        OnCanvasUpdate.broadcast();
    }

    /**
     * Add an edge to the Canvas.
     *
     * @param edge the edge
     */
    public boolean addEdgeOnCanvas(Edge edge) {
        if (doesEdgeExist(edge)) {
            return false;
        }
        canvasController.addEdgeOnCanvas(edge);
        OnCanvasUpdate.broadcast();
        return true;
    }

    public boolean doesEdgeExist(Edge edge){
        boolean connectsToSelf = edge.getA() == edge.getB();
        return !connectsToSelf && model.getEdgesOnCanvas().stream().anyMatch(e -> (e.getA() == edge.getA() && e.getB() == edge.getB())
                || (e.getB() == edge.getA() && e.getA() == edge.getB()));
    }


    /**
     * Add an edge to the Canvas.
     *
     * @param edge the edge
     */
    public void addEdgeOnCanvasOrRemoveExisting(Edge edge) {
        boolean connectsToSelf = edge.getA() == edge.getB();
        if(connectsToSelf){
            return;
        }
        Optional<Edge> edgeToRemove = model.getEdgesOnCanvas().stream().filter(e -> (e.getA() == edge.getA() && e.getB() == edge.getB())
                || (e.getB() == edge.getA() && e.getA() == edge.getB())).findAny();
        edgeToRemove.ifPresentOrElse(canvasController::removeEdgesOnCanvas, () -> canvasController.addEdgeOnCanvas(edge));
        updateStateForCurrentIteration();
    }



    public void calculateStateForCurrentIteration() {
        simulationManager.calculateStateForIteration(model.getCurrentIteration());
    }
    public void updateStateForCurrentIteration() {
        simulationManager.calculateStateForIteration(model.getCurrentIteration());
        OnCanvasUpdate.broadcast();
    }

    /**
     * calculates the flow of the edges and the supply for objects.
     *
     * @param x current Iteration
     */
    public void updateStateForIteration(int x) {
        simulationManager.calculateStateForIteration(x);
        OnCanvasUpdate.broadcast();
    }

    /**
     * resets the whole State of the simulation including a reset of all Edges to
     * the default "is working" state
     */
    public void resetSimulation() {
        model.reset();
    }



    /**
     * Getter for Model.
     *
     * @return the Model
     */
    public Model getModel() {
        return model;
    }


    /**
     * Copy all Selected Objects.
     */
    public void copy() {
        GuiSettings.getClipboardObjects().clear();
        GuiSettings.getClipboardObjects().addAll(GuiSettings.getSelectedObjects());
        GuiSettings.getClipboardEdges().clear();
        GuiSettings.getClipboardEdges().addAll(getEdgesBetweenObjects(GuiSettings.getSelectedObjects()));
    }

    private List<Edge> getEdgesBetweenObjects(Collection<AbstractCanvasObject> selectedObjects) {
        return model.getEdgesOnCanvas().stream()
                .filter(edge -> selectedObjects.containsAll(Arrays.asList(edge.getA(), edge.getB()))).toList();
    }

    public void paste(GroupNode groupNode, Vec2i offset) {
        if (GuiSettings.getClipboardObjects().isEmpty()) {
            return;
        }
        HashMap<AbstractCanvasObject, AbstractCanvasObject> oldToNew = new HashMap<>();
        Collection<AbstractCanvasObject> copies = GuiSettings.getClipboardObjects().stream().map(obj -> {
            AbstractCanvasObject copy = obj.copy();
            oldToNew.put(obj, copy);
            return copy;
        }).toList();
        copies.forEach(obj -> {
            obj.getPosition().addAssign(offset);
            obj.getPosition().clampX(0, GuiSettings.canvasSize.getX());
            obj.getPosition().clampY(0, GuiSettings.canvasSize.getY());
        });
        groupNode.addAll(copies);
        Collection<Edge> copyEdges =  GuiSettings.getClipboardEdges().stream().map(
                edge -> new Edge(oldToNew.get(edge.getA()), oldToNew.get(edge.getB()), edge.maxCapacity)).toList();
        model.getEdgesOnCanvas().addAll(copyEdges);
        updateStateForCurrentIteration();
        OnSelectionChanged.broadcast();
    }

    public void cut() {
        copy();
        deleteCanvasObjects(GuiSettings.getSelectedObjects());
        clearSelection();
    }


    public void guiSetEnabled(boolean state) {
        OnGuiSetEnabled.broadcast(state);
    }


    /**
     * init default category and objects.
     */
    private void initCategories() {
        Category energy = createCategoryWithName("Energy");
        Category building = createCategoryWithName("Building");
        Category component = createCategoryWithName("Component");
        HolonObject powerPlant = addNewHolonObject(energy, "Power Plant", new ArrayList<>(),
                ImagePreference.Canvas.DefaultObject.PowerPlant);
        HolonObject house = addNewHolonObject(building, "House", new ArrayList<>(), ImagePreference.Canvas.DefaultObject.House);
        HolonSwitch sw = new HolonSwitch("Switch");
        component.getObjects().add(sw);
        powerPlant.add(new HolonElement(null, "Power", 10000));
        energy.getObjects().add(powerPlant);

        house.add(new HolonElement(null, "TV", -250));
        house.add(new HolonElement(null, "TV", -250));
        house.add(new HolonElement(null, "Fridge", -500));
        house.add(new HolonElement(null, "Radio", -100));
        house.add(new HolonElement(null, "PC", -250));
        house.add(new HolonElement(null, "PC", -250));
        house.add(new HolonElement(null, "PC", -250));
        house.add(new HolonElement(null, "Light", -50));
        house.add(new HolonElement(null, "Light", -50));
        house.add(new HolonElement(null, "Light", -50));
        house.add(new HolonElement(null, "Light", -50));
        house.add(new HolonElement(null, "Light", -50));
        house.add(new HolonElement(null, "Solar Panel", 300));
        building.getObjects().add(house);
        OnCategoryChanged.broadcast();
    }


    public Category createCategoryWithName(String categoryName) {
        Optional<Category> category = findCategoryWithName(categoryName);
        if (category.isEmpty()) {
            Category cat = new Category(categoryName);
            GuiSettings.getCategories().add(cat);
            OnCategoryChanged.broadcast();
            return cat;
        } else {
            return category.get();
        }

    }



    /**
     * Add Object into a Category.
     *
     * @param category Category
     * @param object   Object
     */
    public void addObject(Category category, AbstractCanvasObject object) {
        int i = 0;
        while (category.findObjectWithName(object.getName()).isPresent()) {
            if (object.getName().contains("_"))
                object.setName(object.getName().substring(0, object.getName().indexOf('_')));
            object.setName(object.getName() + "_" + i);
            i++;
        }
        category.getObjects().add(object);
    }

    /**
     * Add new Holon Object to a Category.
     *
     * @param category Category
     * @param object   New Object Name
     * @param list     Array of Elements
     * @param image    the image Path
     */
    public HolonObject addNewHolonObject(Category category, String object, List<HolonElement> list, String image) {
        HolonObject obj = new HolonObject(object);
        obj.setImagePath(image);
        obj.clearElements();
        obj.add(list);
        addObject(category, obj);
        return obj;
    }


    public Optional<Category> findCategoryWithName(String categoryName) {
        return GuiSettings.getCategories().stream().filter(cat -> cat.getName().equals(categoryName)).findAny();
    }

    public void loadFile(File file) {
        log.info("load" + file);
        try {
            FileReader reader = new FileReader(file);
            Model model = gson.fromJson(reader, Model.class);
            reader.close();
            this.model = model;
            calculateStateForCurrentIteration();
            OnModelChanged.broadcast();
        } catch (IOException e) {
            log.warning(e.getLocalizedMessage());
        }
        clearSelection();
        GuiSettings.setActualSaveFile(file);
    }
    public void loadModelFromJsonString(String json){
        this.model = gson.fromJson(json, Model.class);
        calculateStateForCurrentIteration();
        OnModelChanged.broadcast();
    }

    public String saveModelToJsonString(){
        return gson.toJson(model);
    }



    public void toggleSelectedObjects(Collection<AbstractCanvasObject> objects) {
        Set<AbstractCanvasObject> intersection = new HashSet<>(objects);
        intersection.retainAll(GuiSettings.getSelectedObjects());
        GuiSettings.getSelectedObjects().addAll(objects);
        GuiSettings.getSelectedObjects().removeAll(intersection);
        OnSelectionChanged.broadcast();
    }


    public void saveFile(File file) {
        log.info("save" + file);
        try {
            FileWriter writer = new FileWriter(file);
            gson.toJson(model, writer);
            writer.close();
        } catch (IOException e) {
            log.warning(e.getLocalizedMessage());
        }
        GuiSettings.setActualSaveFile(file);
    }

    public void group() {
        canvasController.group(GuiSettings.getSelectedObjects());
        clearSelection();
        OnCanvasUpdate.broadcast();
    }

    public void ungroup() {
        canvasController.ungroup(GuiSettings.getSelectedObjects());
        clearSelection();
        OnCanvasUpdate.broadcast();
    }


    public void undo(){
        UndoHistory.undo().ifPresent(this::loadModelFromJsonString);
    }
    public void redo(){
        UndoHistory.redo().ifPresent(this::loadModelFromJsonString);
    }






    public void clearModel() {
        model.clear();
        clearSelection();
        model.setCurrentIteration(0);
        IdCounter.reset();
        calculateStateForCurrentIteration();
        OnModelChanged.broadcast();
        GuiSettings.setActualSaveFile(null);
    }

    public void showGroupNode(GroupNode groupNode) {
        OnShowGroupNode.broadcast(groupNode);
        clearSelection();
    }


    public void loadCategory(){
        String json = prefs.get(PreferenceKeys.Category.DefaultCategory, "Init");
        if(json.equals("Init")){
            initCategories();
            return;
        }
        GuiSettings.getCategories().clear();
        GuiSettings.getCategories().addAll(CategoryAdapter.Gson.fromJson(json, CategoryAdapter.CategorySet));
        OnCategoryChanged.broadcast();

    }
    public void saveCategories(){
        String json = CategoryAdapter.Gson.toJson(GuiSettings.getCategories());
        prefs.put(PreferenceKeys.Category.DefaultCategory, json);
    }
}