package items;

import org.jgrapht.Graph;
import org.jgrapht.event.ConnectedComponentTraversalEvent;
import org.jgrapht.event.EdgeTraversalEvent;
import org.jgrapht.event.TraversalListener;
import org.jgrapht.event.VertexTraversalEvent;
import org.jgrapht.graph.DefaultDirectedWeightedGraph;
import org.jgrapht.graph.DefaultWeightedEdge;
import org.jgrapht.graph.EdgeReversedGraph;
import org.jgrapht.traverse.DepthFirstIterator;
import org.jgrapht.traverse.GraphIterator;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Utils {
    public static Map<Item, Integer> getRawOnly(Map<Item, Integer> totals) {
        Map<Item, Integer> raws = new HashMap<>();
        for (Item item : totals.keySet().stream().filter(Item::isRaw).collect(Collectors.toList())) {
            raws.put(item, totals.get(item));
        }
        return raws;
    }

    public static <E extends Number> Map<String, E> shorten(Map<Item, E> totals) {
        Map<String, E> shortend = new HashMap<>();
        totals.forEach((item, e) -> shortend.put(item.getName(), e));
        return shortend;
    }

    public static String dotID(Item item) {
        String name = item.getName() + "_" + item.sum + "__" + (String.valueOf(item.getProductionRate()).replace(".", "_"));
        name = name.replace(" ", "").replace(".", "");
        return name;
    }

    public static void fixSums(Item target, Graph<Item, DefaultWeightedEdge> graph) {
        System.err.println(target);
        EdgeReversedGraph<Item, DefaultWeightedEdge> inverse = new EdgeReversedGraph<>(graph);

        GraphIterator<Item, DefaultWeightedEdge> iterator = new DepthFirstIterator<>(inverse, target);
        iterator.addTraversalListener(new TraversalListener<Item, DefaultWeightedEdge>() {
            @Override
            public void connectedComponentFinished(ConnectedComponentTraversalEvent e) {
                System.out.println("\tconnectedComponentFinished: " + e);
            }

            @Override
            public void connectedComponentStarted(ConnectedComponentTraversalEvent e) {
                System.out.println("\tconnectedComponentStarted: " + e);

            }

            @Override
            public void edgeTraversed(EdgeTraversalEvent<DefaultWeightedEdge> e) {
                System.out.println("\tedgeTraversed: " + e + "---> " + e.getEdge());

            }

            @Override
            public void vertexTraversed(VertexTraversalEvent<Item> e) {
                System.out.println("\tvertexTraversed: " + e + "---> " + e.getVertex().getName());

            }

            @Override
            public void vertexFinished(VertexTraversalEvent<Item> e) {
                System.out.println("\tvertexFinished: " + e);

            }
        });
        while (iterator.hasNext()) {
            Item i = iterator.next();
            System.out.println(i.getName());
        }
    }

    public static Graph<Item, ProductionEdge> merge(Graph<Item, ProductionEdge> graph0, Graph<Item, ProductionEdge> graph1) {
        Graph<Item, ProductionEdge> result = new DefaultDirectedWeightedGraph<>(ProductionEdge.class);

        graph0.vertexSet().forEach(result::addVertex);
        graph0.edgeSet().forEach(productionEdge -> result.addEdge(graph0.getEdgeSource(productionEdge), graph0.getEdgeTarget(productionEdge), productionEdge));

        graph1.vertexSet().forEach(result::addVertex);
        graph1.edgeSet().forEach(productionEdge -> {
            List<ProductionEdge> collect = result.edgeSet().stream().filter(productionEdge1 -> productionEdge1.hasTarget(productionEdge.getTarget())).collect(Collectors.toList());
            collect.forEach(edge -> {
                Item src = result.getEdgeSource(edge);
                Item target = result.getEdgeTarget(edge);
                Item target2 = graph1.getEdgeTarget(productionEdge);
                if (target != target2) {
                    result.addEdge(src, target2, productionEdge);
                } else {
                    result.removeEdge(edge);
                    result.addEdge(src, target, edge);
                }
            });
            if (collect.isEmpty()) {
                result.addEdge(graph1.getEdgeSource(productionEdge), graph1.getEdgeTarget(productionEdge), productionEdge);
            }
        });
        return result;
    }
}