using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Microsoft.Msagl.Core.DataStructures;
using Microsoft.Msagl.Core.GraphAlgorithms;
using Microsoft.Msagl.Core.Layout;
using Microsoft.Msagl.Core.ProjectionSolver;

namespace Microsoft.Msagl.Layout.Layered {
    internal class ConstrainedOrdering {
        readonly GeometryGraph geometryGraph;
        readonly BasicGraph<Node, IntEdge> intGraph;
        internal ProperLayeredGraph ProperLayeredGraph;
        readonly int[] initialLayering;
        LayerInfo[] layerInfos;
        internal LayerArrays LayerArrays;
        readonly HorizontalConstraintsForSugiyama horizontalConstraints;
        int numberOfNodesOfProperGraph;
        readonly Database database;
        double[][] xPositions;
        int[][] yetBestLayers;

        readonly List<IntEdge> verticalEdges = new List<IntEdge>();

        readonly AdjacentSwapsWithConstraints adjSwapper;

        SugiyamaLayoutSettings settings;


        int numberOfLayers = -1;
        int noGainSteps;
        const int MaxNumberOfNoGainSteps=5;

        int NumberOfLayers {
            get {
                if (numberOfLayers > 0)
                    return numberOfLayers;
                return numberOfLayers = initialLayering.Max(i => i + 1);
            }
        }

        double NodeSeparation() {
            return settings.NodeSeparation;
        }

        internal ConstrainedOrdering(
            GeometryGraph geomGraph,
            BasicGraph<Node, IntEdge> basicIntGraph,
            int[] layering,
            Dictionary<Node, int> nodeIdToIndex,
            Database database,
            SugiyamaLayoutSettings settings) {

            this.settings = settings;
            horizontalConstraints = settings.HorizontalConstraints;

            horizontalConstraints.PrepareForOrdering(nodeIdToIndex, layering);

            geometryGraph = geomGraph;
            this.database = database;
            intGraph = basicIntGraph;
            initialLayering = layering;
            //this has to be changed only to insert layers that are needed
            if (NeedToInsertLayers(layering)) {
                for (int i = 0; i < layering.Length; i++)
                    layering[i] *= 2;
                LayersAreDoubled = true;
                numberOfLayers = -1;
            }

            PrepareProperLayeredGraphAndFillLayerInfos();

            adjSwapper = new AdjacentSwapsWithConstraints(
                LayerArrays,
                HasCrossWeights(),
                ProperLayeredGraph,
                layerInfos);
        }

        bool LayersAreDoubled { get; set; }

        bool NeedToInsertLayers(int[] layering) {
            return ExistsShortLabeledEdge(layering, intGraph.Edges) ||
                   ExistsShortMultiEdge(layering, database.Multiedges);
        }

        static bool ExistsShortMultiEdge(int[] layering, Dictionary<IntPair, List<IntEdge>> multiedges) {
            return multiedges.Any(multiedge => multiedge.Value.Count > 2 && layering[multiedge.Key.x] == 1 + layering[multiedge.Key.y]);
        }

        internal void Calculate() {
            AllocateXPositions();
            var originalGraph = intGraph.Nodes[0].GeometryParent as GeometryGraph;
            LayeredLayoutEngine.CalculateAnchorSizes(database, out database.anchors, ProperLayeredGraph, originalGraph, intGraph, settings);
            LayeredLayoutEngine.CalcInitialYAnchorLocations(LayerArrays, 500, geometryGraph, database, intGraph, settings, LayersAreDoubled);
            Order();
        }

        
        ConstrainedOrderMeasure CreateMeasure() {
            return new ConstrainedOrderMeasure(Ordering.GetCrossingsTotal(ProperLayeredGraph, LayerArrays));
        }

        bool HasCrossWeights() {
            return ProperLayeredGraph.Edges.Any(le => le.CrossingWeight != 1);
        }

        static bool ExistsShortLabeledEdge(int[] layering, IEnumerable<IntEdge> edges) {
            return edges.Any(edge => layering[edge.Source] == layering[edge.Target] + 1 && edge.Edge.Label != null);
        }

        void AllocateXPositions() {
            xPositions = new double[NumberOfLayers][];
            for (int i = 0; i < NumberOfLayers; i++)
                xPositions[i] = new double[LayerArrays.Layers[i].Length];
        }

        void Order() {
            CreateInitialOrderInLayers();
            TryPushingOutStrangersFromHorizontalBlocks();
            int n = 5;

            ConstrainedOrderMeasure measure = null;
        
            while (n-- > 0 && noGainSteps <= MaxNumberOfNoGainSteps) {
                
                SetXPositions();
                
                ConstrainedOrderMeasure newMeasure = CreateMeasure();
                if (measure == null || newMeasure < measure) {
                    noGainSteps = 0;
                    Ordering.CloneLayers(LayerArrays.Layers, ref yetBestLayers);
                    measure = newMeasure;
                } else {
                    noGainSteps++;
                    RestoreState();
                }
                
            }

            #region old code
            /*
             int noGainSteps = 0;
             for (int i = 0; i < NumberOfSweeps && noGainSteps <= MaxNumberOfNoGainSteps && !measure.Perfect(); i++) {
                 SweepDown(false);
                 SweepUp(false);
                 ConstrainedOrderMeasure newMeasure = CreateMeasure();
                 if (newMeasure < measure) {
                     noGainSteps = 0;
                     Ordering.CloneLayers(LayerArrays.Layers, ref yetBestLayers);
                     measure = newMeasure;
                 } else {
                     noGainSteps++;
                     RestoreState();
                 }
             }
             
             SwitchXPositions();
             SweepUpWithoutChangingLayerOrder(true);
             
             SwitchXPositions();
             SweepDownWithoutChangingLayerOrder(true);
             AverageXPositions();
              */
            #endregion
        }

        void SetXPositions() {
            ISolverShell solver = InitSolverWithoutOrder();
            ImproveWithAdjacentSwaps();
            PutLayerNodeSeparationsIntoSolver(solver);
            solver.Solve();
            SortLayers(solver);
            for (int i = 0; i < LayerArrays.Y.Length; i++)
                database.Anchors[i].X = solver.GetVariableResolvedPosition(i);

        }

        ISolverShell InitSolverWithoutOrder() {
            ISolverShell solver=CreateSolver();
            InitSolverVars(solver);
            
            PutLeftRightConstraintsIntoSolver(solver);
            PutVerticalConstraintsIntoSolver(solver);
            AddGoalsToKeepProperEdgesShort(solver);

            AddGoalsToKeepFlatEdgesShort(solver);
            return solver;
        }

        void SortLayers(ISolverShell solver) {
            for (int i = 0; i < LayerArrays.Layers.Length; i++)
                SortLayerBasedOnSolution(LayerArrays.Layers[i], solver);
        }

        void AddGoalsToKeepFlatEdgesShort(ISolverShell solver) {
            foreach (var layerInfo in layerInfos)
                AddGoalToKeepFlatEdgesShortOnBlockLevel(layerInfo, solver);
        }

        void InitSolverVars(ISolverShell solver) {
            for (int i = 0; i < LayerArrays.Y.Length; i++)
                solver.AddVariableWithIdealPosition(i, 0);
        }

        void AddGoalsToKeepProperEdgesShort(ISolverShell solver) {
            foreach (var edge in ProperLayeredGraph.Edges)
                solver.AddGoalTwoVariablesAreClose(edge.Source, edge.Target, PositionOverBaricenterWeight);

        }

        void PutVerticalConstraintsIntoSolver(ISolverShell solver) {
            foreach (var pair in horizontalConstraints.VerticalInts) {
                solver.AddGoalTwoVariablesAreClose(pair.Item1, pair.Item2, ConstrainedVarWeight);
            }
        }

        void PutLeftRightConstraintsIntoSolver(ISolverShell solver) {
            foreach (var pair in horizontalConstraints.LeftRighInts) {
                solver.AddLeftRightSeparationConstraint(pair.Item1, pair.Item2, SimpleGapBetweenTwoNodes(pair.Item1, pair.Item2));
            }
        }

        void PutLayerNodeSeparationsIntoSolver(ISolverShell solver) {
            foreach (var layer in LayerArrays.Layers) {
                for (int i = 0; i < layer.Length - 1; i++) {
                    int l = layer[i];
                    int r = layer[i + 1];
                    solver.AddLeftRightSeparationConstraint(l, r, SimpleGapBetweenTwoNodes(l, r));
                }
            }
        }

        void ImproveWithAdjacentSwaps() {
            adjSwapper.DoSwaps();
        }

        void TryPushingOutStrangersFromHorizontalBlocks() {

        }

        void CreateInitialOrderInLayers() {
            //the idea is to topologically ordering all nodes horizontally, by using vertical components, then fill the layers according to this order
            Dictionary<int, int> nodesToVerticalComponentsRoots = CreateVerticalComponents();
            IEnumerable<IntPair> liftedLeftRightRelations = LiftLeftRightRelationsToComponentRoots(nodesToVerticalComponentsRoots).ToArray();
            int[] orderOfVerticalComponentRoots = TopologicalSort.GetOrderOnEdges(liftedLeftRightRelations);
            FillLayersWithVerticalComponentsOrder(orderOfVerticalComponentRoots, nodesToVerticalComponentsRoots);
            LayerArrays.UpdateXFromLayers();
        }

        void FillLayersWithVerticalComponentsOrder(int[] order, Dictionary<int, int> nodesToVerticalComponentsRoots) {
            Dictionary<int, List<int>> componentRootsToComponents = CreateComponentRootsToComponentsMap(nodesToVerticalComponentsRoots);
            var alreadyInLayers = new bool[LayerArrays.Y.Length];
            var runninglayerCounts = new int[LayerArrays.Layers.Length];
            foreach (var vertCompRoot in order)
                PutVerticalComponentIntoLayers(EnumerateVertComponent(componentRootsToComponents, vertCompRoot), runninglayerCounts, alreadyInLayers);
            for (int i = 0; i < ProperLayeredGraph.NodeCount; i++)
                if (alreadyInLayers[i] == false)
                    AddVertToLayers(i, runninglayerCounts, alreadyInLayers);

        }

        IEnumerable<int> EnumerateVertComponent(Dictionary<int, List<int>> componentRootsToComponents, int vertCompRoot) {
            List<int> compList;
            if (componentRootsToComponents.TryGetValue(vertCompRoot, out compList)) {
                foreach (var i in compList)
                    yield return i;
            } else
                yield return vertCompRoot;

        }


        void PutVerticalComponentIntoLayers(IEnumerable<int> vertComponent, int[] runningLayerCounts, bool[] alreadyInLayers) {
            foreach (var i in vertComponent)
                AddVertToLayers(i, runningLayerCounts, alreadyInLayers);
        }

        void AddVertToLayers(int i, int[] runningLayerCounts, bool[] alreadyInLayers) {
            if (alreadyInLayers[i])
                return;
            int layerIndex = LayerArrays.Y[i];

            int xIndex = runningLayerCounts[layerIndex];
            var layer = LayerArrays.Layers[layerIndex];

            layer[xIndex++] = i;
            alreadyInLayers[i] = true;
            List<int> block;
            if (horizontalConstraints.BlockRootToBlock.TryGetValue(i, out block))
                foreach (var v in block) {
                    if (alreadyInLayers[v]) continue;
                    layer[xIndex++] = v;
                    alreadyInLayers[v] = true;
                }
            runningLayerCounts[layerIndex] = xIndex;
        }

        static Dictionary<int, List<int>> CreateComponentRootsToComponentsMap(Dictionary<int, int> nodesToVerticalComponentsRoots) {
            var d = new Dictionary<int, List<int>>();
            foreach (var kv in nodesToVerticalComponentsRoots) {
                int i = kv.Key;
                var root = kv.Value;
                List<int> component;
                if (!d.TryGetValue(root, out component)) {
                    d[root] = component = new List<int>();
                }
                component.Add(i);
            }
            return d;
        }

        IEnumerable<IntPair> LiftLeftRightRelationsToComponentRoots(Dictionary<int, int> nodesToVerticalComponentsRoots) {
            foreach (var pair in horizontalConstraints.LeftRighInts)
                yield return new IntPair(GetFromDictionaryOrIdentical(nodesToVerticalComponentsRoots, pair.Item1),
                    GetFromDictionaryOrIdentical(nodesToVerticalComponentsRoots, pair.Item2));
            foreach (var pair in horizontalConstraints.LeftRightIntNeibs)
                yield return new IntPair(GetFromDictionaryOrIdentical(nodesToVerticalComponentsRoots, pair.Item1),
                    GetFromDictionaryOrIdentical(nodesToVerticalComponentsRoots, pair.Item2));
        }

        static int GetFromDictionaryOrIdentical(Dictionary<int, int> d, int key) {
            int i;
            if (d.TryGetValue(key, out i))
                return i;
            return key;
        }

        /// <summary>
        /// These blocks are connected components in the vertical constraints. They don't necesserely span consequent layers.
        /// </summary>
        /// <returns></returns>
        Dictionary<int, int> CreateVerticalComponents() {
            var vertGraph = new BasicGraph<IntEdge>(from pair in horizontalConstraints.VerticalInts select new IntEdge(pair.Item1, pair.Item2));
            var verticalComponents = ConnectedComponentCalculator<IntEdge>.GetComponents(vertGraph);
            var nodesToComponentRoots = new Dictionary<int, int>();
            foreach (var component in verticalComponents) {
                var ca = component.ToArray();
                if (ca.Length == 1)
                    continue;
                int componentRoot = -1;
                foreach (var j in component) {
                    if (componentRoot == -1)
                        componentRoot = j;
                    nodesToComponentRoots[j] = componentRoot;
                }
            }
            return nodesToComponentRoots;
        }

        void RestoreState() {
            LayerArrays.UpdateLayers(yetBestLayers);
        }

// #if TEST_MSAGL
//         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledCode")]
//         void Show() {
//             SugiyamaLayoutSettings.ShowDatabase(database);
//         }
// #endif

// #if TEST_MSAGL
//         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "System.Console.Write(System.String)"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledCode")]
//         static void PrintPositions(double[] positions) {
//             for (int j = 0; j < positions.Length; j++)
//                 Console.Write(" " + positions[j]);
//             Console.WriteLine();
//         }
// #endif


        void SortLayerBasedOnSolution(int[] layer, ISolverShell solver) {
            int length = layer.Length;
            var positions = new double[length];
            int k = 0;
            foreach (int v in layer)
                positions[k++] = solver.GetVariableResolvedPosition(v);

            Array.Sort(positions, layer);
            int i = 0;
            foreach (int v in layer)
                LayerArrays.X[v] = i++;
        }

        const double ConstrainedVarWeight = 10e6;
        const double PositionOverBaricenterWeight = 5;

        static int NodeToBlockRootSoftOnLayerInfo(LayerInfo layerInfo, int node) {
            int root;
            return layerInfo.nodeToBlockRoot.TryGetValue(node, out root) ? root : node;
        }

        static void AddGoalToKeepFlatEdgesShortOnBlockLevel(LayerInfo layerInfo, ISolverShell solver) {
            if (layerInfo != null)
                foreach (var couple in layerInfo.flatEdges) {
                    int sourceBlockRoot = NodeToBlockRootSoftOnLayerInfo(layerInfo, couple.Item1);
                    int targetBlockRoot = NodeToBlockRootSoftOnLayerInfo(layerInfo, couple.Item2);
                    if (sourceBlockRoot != targetBlockRoot)
                        solver.AddGoalTwoVariablesAreClose(sourceBlockRoot, targetBlockRoot);
                }
        }

        static bool NodeIsConstrainedBelow(int v, LayerInfo layerInfo) {
            if (layerInfo == null)
                return false;
            return layerInfo.constrainedFromBelow.ContainsKey(v);
        }

        static bool NodeIsConstrainedAbove(int v, LayerInfo layerInfo) {
            if (layerInfo == null)
                return false;
            return layerInfo.constrainedFromAbove.ContainsKey(v);
        }

        internal static bool BelongsToNeighbBlock(int p, LayerInfo layerInfo) {
            return layerInfo != null && (layerInfo.nodeToBlockRoot.ContainsKey(p) || layerInfo.neigBlocks.ContainsKey(p));
            //p is a root of the block
        }

        static bool NodesAreConstrainedBelow(int leftNode, int rightNode, LayerInfo layerInfo) {
            return NodeIsConstrainedBelow(leftNode, layerInfo) && NodeIsConstrainedBelow(rightNode, layerInfo);
        }

        static bool NodesAreConstrainedAbove(int leftNode, int rightNode, LayerInfo layerInfo) {
            return NodeIsConstrainedAbove(leftNode, layerInfo) && NodeIsConstrainedAbove(rightNode, layerInfo);
        }

        double GetGapFromNodeNodesConstrainedBelow(int leftNode, int rightNode, LayerInfo layerInfo,
                                                          int layerIndex) {
            double gap = SimpleGapBetweenTwoNodes(leftNode, rightNode);
            leftNode = layerInfo.constrainedFromBelow[leftNode];
            rightNode = layerInfo.constrainedFromBelow[rightNode];
            layerIndex--;
            layerInfo = layerInfos[layerIndex];
            if (layerIndex > 0 && NodesAreConstrainedBelow(leftNode, rightNode, layerInfo))
                return Math.Max(gap, GetGapFromNodeNodesConstrainedBelow(leftNode, rightNode, layerInfo, layerIndex));
            return Math.Max(gap, SimpleGapBetweenTwoNodes(leftNode, rightNode));
        }

        double GetGapFromNodeNodesConstrainedAbove(int leftNode, int rightNode, LayerInfo layerInfo,
                                                          int layerIndex) {
            double gap = SimpleGapBetweenTwoNodes(leftNode, rightNode);
            leftNode = layerInfo.constrainedFromAbove[leftNode];
            rightNode = layerInfo.constrainedFromAbove[rightNode];
            layerIndex++;
            layerInfo = layerInfos[layerIndex];
            if (layerIndex < LayerArrays.Layers.Length - 1 && NodesAreConstrainedAbove(leftNode, rightNode, layerInfo))
                return Math.Max(gap, GetGapFromNodeNodesConstrainedAbove(leftNode, rightNode, layerInfo, layerIndex));
            return Math.Max(gap, SimpleGapBetweenTwoNodes(leftNode, rightNode));
        }

        double SimpleGapBetweenTwoNodes(int leftNode, int rightNode) {
            return database.anchors[leftNode].RightAnchor +
                   NodeSeparation() + database.anchors[rightNode].LeftAnchor;
        }

        internal static ISolverShell CreateSolver() {
            return new SolverShell();
        }

        void PrepareProperLayeredGraphAndFillLayerInfos() {
            layerInfos = new LayerInfo[NumberOfLayers];
            CreateProperLayeredGraph();
            CreateExtendedLayerArrays();
            FillBlockRootToBlock();
            FillLeftRightPairs();
            FillFlatEdges();
            FillAboveBelow();
            FillBlockRootToVertConstrainedNode();
        }

        void FillBlockRootToVertConstrainedNode() {
            foreach (LayerInfo layerInfo in layerInfos)
                foreach (int v in VertConstrainedNodesOfLayer(layerInfo)) {
                    int blockRoot;
                    if (TryGetBlockRoot(v, out blockRoot, layerInfo))
                        layerInfo.blockRootToVertConstrainedNodeOfBlock[blockRoot] = v;
                }
        }

        static bool TryGetBlockRoot(int v, out int blockRoot, LayerInfo layerInfo) {
            if (layerInfo.nodeToBlockRoot.TryGetValue(v, out blockRoot))
                return true;
            if (layerInfo.neigBlocks.ContainsKey(v)) {
                blockRoot = v;
                return true;
            }
            return false;
        }

        static IEnumerable<int> VertConstrainedNodesOfLayer(LayerInfo layerInfo) {
            if (layerInfo != null) {
                foreach (int v in layerInfo.constrainedFromAbove.Keys)
                    yield return v;
                foreach (int v in layerInfo.constrainedFromBelow.Keys)
                    yield return v;
            }
        }


        void CreateExtendedLayerArrays() {
            var layeringExt = new int[numberOfNodesOfProperGraph];
            Array.Copy(initialLayering, layeringExt, initialLayering.Length);
            foreach (IntEdge edge in ProperLayeredGraph.BaseGraph.Edges) {
                var ledges = (LayerEdge[])edge.LayerEdges;
                if (ledges != null && ledges.Length > 1) {
                    int layerIndex = initialLayering[edge.Source] - 1;
                    for (int i = 0; i < ledges.Length - 1; i++)
                        layeringExt[ledges[i].Target] = layerIndex--;
                }
            }
            LayerArrays = new LayerArrays(layeringExt);
        }

        void CreateProperLayeredGraph() {
            IEnumerable<IntEdge> edges = CreatePathEdgesOnIntGraph();
            var nodeCount = Math.Max(intGraph.NodeCount, BasicGraph<Node, IntEdge>.VertexCount(edges));
            var baseGraph = new BasicGraph<Node, IntEdge>(edges, nodeCount) { Nodes = intGraph.Nodes };
            ProperLayeredGraph = new ProperLayeredGraph(baseGraph);
        }

        IEnumerable<IntEdge> CreatePathEdgesOnIntGraph() {
            numberOfNodesOfProperGraph = intGraph.NodeCount;
            var ret = new List<IntEdge>();
            foreach (IntEdge ie in intGraph.Edges) {
                if (initialLayering[ie.Source] > initialLayering[ie.Target]) {
                    CreateLayerEdgesUnderIntEdge(ie);
                    ret.Add(ie);
                    if (horizontalConstraints.VerticalInts.Contains(new Tuple<int, int>(ie.Source, ie.Target)))
                        verticalEdges.Add(ie);
                }
            }

            return ret;
        }


        void CreateLayerEdgesUnderIntEdge(IntEdge ie) {
            int source = ie.Source;
            int target = ie.Target;

            int span = LayeredLayoutEngine.EdgeSpan(initialLayering, ie);
            ie.LayerEdges = new LayerEdge[span];
            Debug.Assert(span > 0);
            if (span == 1)
                ie.LayerEdges[0] = new LayerEdge(ie.Source, ie.Target, ie.CrossingWeight);
            else {
                ie.LayerEdges[0] = new LayerEdge(source, numberOfNodesOfProperGraph, ie.CrossingWeight);
                for (int i = 0; i < span - 2; i++)
                    ie.LayerEdges[i + 1] = new LayerEdge(numberOfNodesOfProperGraph++, numberOfNodesOfProperGraph,
                                                         ie.CrossingWeight);
                ie.LayerEdges[span - 1] = new LayerEdge(numberOfNodesOfProperGraph++, target, ie.CrossingWeight);
            }
        }


        void FillAboveBelow() {
            foreach (IntEdge ie in verticalEdges) {
                foreach (LayerEdge le in ie.LayerEdges) {
                    int upper = le.Source;
                    int lower = le.Target;
                    RegisterAboveBelowOnConstrainedUpperLower(upper, lower);
                }
            }

            foreach (var p in horizontalConstraints.VerticalInts)
                RegisterAboveBelowOnConstrainedUpperLower(p.Item1, p.Item2);
        }

        void RegisterAboveBelowOnConstrainedUpperLower(int upper, int lower) {
            LayerInfo topLayerInfo = GetOrCreateLayerInfo(LayerArrays.Y[upper]);
            LayerInfo bottomLayerInfo = GetOrCreateLayerInfo(LayerArrays.Y[lower]);

            topLayerInfo.constrainedFromBelow[upper] = lower;
            bottomLayerInfo.constrainedFromAbove[lower] = upper;
        }

        void FillFlatEdges() {
            foreach (IntEdge edge in intGraph.Edges) {
                int l = initialLayering[edge.Source];
                if (l == initialLayering[edge.Target]) {
                    GetOrCreateLayerInfo(l).flatEdges.Insert(new Tuple<int, int>(edge.Source, edge.Target));
                }
            }
        }

        void FillLeftRightPairs() {
            foreach (var p in horizontalConstraints.LeftRighInts) {
                LayerInfo layerInfo = GetOrCreateLayerInfo(initialLayering[p.Item1]);
                layerInfo.leftRight.Insert(p);
            }
        }

        /// <summary>
        /// when we call this function we know that a LayerInfo is needed
        /// </summary>
        /// <param name="layerNumber"></param>
        /// <returns></returns>
        LayerInfo GetOrCreateLayerInfo(int layerNumber) {
            LayerInfo layerInfo = layerInfos[layerNumber] ?? (layerInfos[layerNumber] = new LayerInfo());
            return layerInfo;
        }

        void FillBlockRootToBlock() {
            foreach (var p in horizontalConstraints.BlockRootToBlock) {
                LayerInfo layerInfo = GetOrCreateLayerInfo(initialLayering[p.Key]);
                layerInfo.neigBlocks[p.Key] = p.Value;
                foreach (int i in p.Value)
                    layerInfo.nodeToBlockRoot[i] = p.Key;
            }
        }
    }
}