etienneH code review remarks part 2

Author: ghazwarhili

src/main/java/org/gridsuite/network/map/dto/definition/extension/BusbarSectionFinderTraverser.java

@@ -7,6 +7,7 @@
 package org.gridsuite.network.map.dto.definition.extension;
 
 import com.powsybl.iidm.network.*;
+import com.powsybl.iidm.network.extensions.BusbarSectionPosition;
 
 import java.util.*;
 
@@ -20,15 +21,15 @@ private BusbarSectionFinderTraverser() {
         throw new UnsupportedOperationException();
     }
 
-    private record NodePath(int node, List<SwitchInfo> pathSwitches, SwitchInfo lastSwitch) { }
+    private record NodePath(int startNode, List<SwitchInfo> traversedSwitches, SwitchInfo lastSwitch) { }
 
     public record SwitchInfo(String id, SwitchKind kind, boolean isOpen) { }
 
-    public record BusbarSectionResult(String busbarSectionId, int depth, SwitchInfo lastSwitch) { }
+    public record BusbarSectionResult(String busbarSectionId, int depth, SwitchInfo lastSwitch, int busbarIndex, int sectionIndex) { }
 
     public static String findBusbarSectionId(Terminal terminal) {
         BusbarSectionResult result = getBusbarSectionResult(terminal);
-        return result != null ? result.busbarSectionId() : null;
+        return result != null ? result.busbarSectionId() : terminal.getVoltageLevel().getNodeBreakerView().getBusbarSections().iterator().next().getId();
     }
 
     public static BusbarSectionResult getBusbarSectionResult(Terminal terminal) {
@@ -44,67 +45,81 @@ public static BusbarSectionResult getBusbarSectionResult(Terminal terminal) {
     private static BusbarSectionResult selectBestBusbar(List<BusbarSectionResult> results) {
         List<BusbarSectionResult> withoutSwitch = results.stream().filter(r -> r.lastSwitch() == null).toList();
         if (!withoutSwitch.isEmpty()) {
-            return withoutSwitch.stream().min(Comparator.comparingInt(BusbarSectionResult::depth)).orElse(null);
+            return withoutSwitch.stream().min(Comparator.comparingInt(BusbarSectionResult::depth)
+                    .thenComparingInt(BusbarSectionResult::busbarIndex)
+                    .thenComparingInt(BusbarSectionResult::sectionIndex)).orElse(null);
         }
         List<BusbarSectionResult> withClosedSwitch = results.stream().filter(r -> r.lastSwitch() != null && !r.lastSwitch().isOpen()).toList();
         if (!withClosedSwitch.isEmpty()) {
-            return withClosedSwitch.stream().min(Comparator.comparingInt(BusbarSectionResult::depth)).orElse(null);
+            return withClosedSwitch.stream().min(Comparator.comparingInt(BusbarSectionResult::depth)
+                    .thenComparingInt(BusbarSectionResult::busbarIndex)
+                    .thenComparingInt(BusbarSectionResult::sectionIndex)).orElse(null);
         }
         List<BusbarSectionResult> withOpenSwitch = results.stream().filter(r -> r.lastSwitch() != null && r.lastSwitch().isOpen()).toList();
         if (!withOpenSwitch.isEmpty()) {
-            return withOpenSwitch.stream().min(Comparator.comparingInt(BusbarSectionResult::depth)).orElse(null);
+            return withOpenSwitch.stream().min(Comparator.comparingInt(BusbarSectionResult::depth)
+                    .thenComparingInt(BusbarSectionResult::busbarIndex)
+                    .thenComparingInt(BusbarSectionResult::sectionIndex)).orElse(null);
         }
         return results.getFirst();
     }
 
     private static List<BusbarSectionResult> searchAllBusbars(VoltageLevel.NodeBreakerView view, int startNode) {
         List<BusbarSectionResult> results = new ArrayList<>();
         Set<Integer> visited = new HashSet<>();
-        Queue<NodePath> queue = new LinkedList<>();
-        queue.offer(new NodePath(startNode, new ArrayList<>(), null));
-        while (!queue.isEmpty()) {
-            NodePath currentNodePath = queue.poll();
-            if (!hasNotBeenVisited(currentNodePath.node(), visited)) {
+        Queue<NodePath> nodePathsToVisit = new LinkedList<>();
+        nodePathsToVisit.offer(new NodePath(startNode, new ArrayList<>(), null));
+        while (!nodePathsToVisit.isEmpty()) {
+            NodePath currentNodePath = nodePathsToVisit.poll();
+            if (hasBeenVisited(currentNodePath.startNode(), visited)) {
                 continue;
             }
-            visited.add(currentNodePath.node());
-            Optional<BusbarSectionResult> busbarSectionResult = tryCreateBusbarResult(view, currentNodePath);
+            visited.add(currentNodePath.startNode());
+            Optional<BusbarSectionResult> busbarSectionResult = findBusbarSectionAtNode(view, currentNodePath);
             if (busbarSectionResult.isPresent()) {
                 results.add(busbarSectionResult.get());
             } else {
-                exploreAdjacentNodes(view, currentNodePath, visited, queue);
+                exploreAdjacentNodes(view, currentNodePath, visited, nodePathsToVisit);
             }
         }
         return results;
     }
 
-    private static boolean hasNotBeenVisited(int node, Set<Integer> visited) {
-        return !visited.contains(node);
+    private static boolean hasBeenVisited(int node, Set<Integer> visited) {
+        return visited.contains(node);
     }
 
-    private static Optional<BusbarSectionResult> tryCreateBusbarResult(VoltageLevel.NodeBreakerView view, NodePath currentNodePath) {
-        Optional<Terminal> nodeTerminal = view.getOptionalTerminal(currentNodePath.node());
+    private static Optional<BusbarSectionResult> findBusbarSectionAtNode(VoltageLevel.NodeBreakerView view, NodePath currentNodePath) {
+        Optional<Terminal> nodeTerminal = view.getOptionalTerminal(currentNodePath.startNode());
         if (nodeTerminal.isEmpty()) {
             return Optional.empty();
         }
-        Terminal term = nodeTerminal.get();
-        if (term.getConnectable().getType() == IdentifiableType.BUSBAR_SECTION) {
-            String busbarSectionId = term.getConnectable().getId();
-            int depth = currentNodePath.pathSwitches().size();
+        Terminal terminal = nodeTerminal.get();
+        if (terminal.getConnectable().getType() == IdentifiableType.BUSBAR_SECTION) {
+            String busbarSectionId = terminal.getConnectable().getId();
+            int depth = currentNodePath.traversedSwitches().size();
             SwitchInfo lastSwitch = currentNodePath.lastSwitch();
-            return Optional.of(new BusbarSectionResult(busbarSectionId, depth, lastSwitch));
+            BusbarSection busbarSection = (BusbarSection) terminal.getConnectable();
+            int busbarIndex = 1;
+            int sectionIndex = 1;
+            var busbarSectionPosition = busbarSection.getExtension(BusbarSectionPosition.class);
+            if (busbarSectionPosition != null) {
+                busbarIndex = busbarSectionPosition.getBusbarIndex();
+                sectionIndex = busbarSectionPosition.getSectionIndex();
+            }
+            return Optional.of(new BusbarSectionResult(busbarSectionId, depth, lastSwitch, busbarIndex, sectionIndex));
         }
         return Optional.empty();
     }
 
-    private static void exploreAdjacentNodes(VoltageLevel.NodeBreakerView view, NodePath currentNodePath, Set<Integer> visited, Queue<NodePath> queue) {
+    private static void exploreAdjacentNodes(VoltageLevel.NodeBreakerView view, NodePath currentNodePath, Set<Integer> visited, Queue<NodePath> nodePathsToVisit) {
         view.getSwitchStream().forEach(sw -> {
             int node1 = view.getNode1(sw.getId());
             int node2 = view.getNode2(sw.getId());
-            Optional<Integer> nextNode = getNextNodeIfAdjacent(currentNodePath.node(), node1, node2);
+            Optional<Integer> nextNode = getNextNodeIfAdjacent(currentNodePath.startNode(), node1, node2);
             if (nextNode.isPresent() && !visited.contains(nextNode.get())) {
-                NodePath newPath = createNodePath(currentNodePath, sw, nextNode.get());
-                queue.offer(newPath);
+                NodePath newNodePath = createNodePath(currentNodePath, sw, nextNode.get());
+                nodePathsToVisit.offer(newNodePath);
             }
         });
     }
@@ -120,7 +135,7 @@ private static Optional<Integer> getNextNodeIfAdjacent(int currentNode, int node
     }
 
     private static NodePath createNodePath(NodePath currentNodePath, Switch sw, int nextNode) {
-        List<SwitchInfo> newPathSwitches = new ArrayList<>(currentNodePath.pathSwitches());
+        List<SwitchInfo> newPathSwitches = new ArrayList<>(currentNodePath.traversedSwitches());
         SwitchInfo switchInfo = new SwitchInfo(sw.getId(), sw.getKind(), sw.isOpen());
         newPathSwitches.add(switchInfo);
         return new NodePath(nextNode, newPathSwitches, switchInfo);

src/test/resources/substations-form-data.json

@@ -129,7 +129,7 @@
           ],
           "SHUNT_NON_LINEAR": [
             {
-              "busbarSectionId": null,
+              "busbarSectionId": "NGEN4",
               "connectablePositionInfos": {
                 "connectionDirection": null
               },

src/test/resources/voltage-level-form-data.json

@@ -34,7 +34,7 @@
     ],
     "SHUNT_NON_LINEAR": [
       {
-        "busbarSectionId": null,
+        "busbarSectionId": "NGEN4",
         "connectablePositionInfos": {
           "connectionDirection": null
         },

src/test/resources/voltage-levels-form-data.json

@@ -95,7 +95,7 @@
       ],
       "SHUNT_NON_LINEAR": [
         {
-          "busbarSectionId": null,
+          "busbarSectionId": "NGEN4",
           "connectablePositionInfos": {
             "connectionDirection": null
           },