/* ========================================================================
 * PlantUML : a free UML diagram generator
 * ========================================================================
 *
 * (C) Copyright 2009-2024, Arnaud Roques
 *
 * Project Info:  https://plantuml.com
 * 
 * If you like this project or if you find it useful, you can support us at:
 * 
 * https://plantuml.com/patreon (only 1$ per month!)
 * https://plantuml.com/paypal
 * 
 * This file is part of PlantUML.
 *
 * PlantUML is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * PlantUML distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
 * License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 *
 *
 * Original Author:  Arnaud Roques
 *
 * 
 */
package net.sourceforge.plantuml.svek;

import static java.nio.charset.StandardCharsets.UTF_8;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import net.sourceforge.plantuml.StringUtils;
import net.sourceforge.plantuml.abel.Entity;
import net.sourceforge.plantuml.dot.DotSplines;
import net.sourceforge.plantuml.dot.Graphviz;
import net.sourceforge.plantuml.dot.GraphvizRuntimeEnvironment;
import net.sourceforge.plantuml.dot.GraphvizVersion;
import net.sourceforge.plantuml.dot.ProcessState;
import net.sourceforge.plantuml.klimt.awt.XColor;
import net.sourceforge.plantuml.klimt.font.StringBounder;
import net.sourceforge.plantuml.klimt.geom.Moveable;
import net.sourceforge.plantuml.klimt.geom.Rankdir;
import net.sourceforge.plantuml.klimt.geom.XCubicCurve2D;
import net.sourceforge.plantuml.klimt.geom.XPoint2D;
import net.sourceforge.plantuml.security.SFile;
import net.sourceforge.plantuml.skin.PragmaKey;
import net.sourceforge.plantuml.skin.UmlDiagramType;
import net.sourceforge.plantuml.style.ISkinParam;
import net.sourceforge.plantuml.teavm.TeaVM;
import net.sourceforge.plantuml.utils.Position;
import net.sourceforge.plantuml.vizjs.GraphvizJs;
import net.sourceforge.plantuml.vizjs.GraphvizJsRuntimeException;

public final class DotStringFactory implements Moveable {

	private final UmlDiagramType umlDiagramType;
	private final ISkinParam skinParam;
	private final Bibliotekon bibliotekon;
	private final Cluster root;

	public DotStringFactory(Bibliotekon bibliotekon, Cluster root, UmlDiagramType umlDiagramType,
			ISkinParam skinParam) {
		this.bibliotekon = bibliotekon;
		this.skinParam = skinParam;
		this.umlDiagramType = umlDiagramType;
		this.root = root;
	}

	public Bibliotekon getBibliotekon() {
		return bibliotekon;
	}

	private double getHorizontalDzeta(StringBounder stringBounder) {
		double max = 0;
		for (SvekEdge l : getBibliotekon().allLines()) {
			final double c = l.getHorizontalDzeta(stringBounder);
			if (c > max)
				max = c;

		}
		return max / 10;
	}

	private double getVerticalDzeta(StringBounder stringBounder) {
		double max = 0;
		for (SvekEdge l : getBibliotekon().allLines()) {
			final double c = l.getVerticalDzeta(stringBounder);
			if (c > max)
				max = c;

		}
		if (root.diagram.getPragma().isTrue(PragmaKey.KERMOR))
			return max / 100;
		return max / 10;
	}

	private String createDotString(StringBounder stringBounder, DotMode dotMode, String... dotStrings) {
		final StringBuilder sb = new StringBuilder();

		double nodesep = getHorizontalDzeta(stringBounder);
		if (nodesep < getMinNodeSep())
			nodesep = getMinNodeSep();

		if (skinParam.getNodesep() != 0)
			nodesep = skinParam.getNodesep();

		final String nodesepInches = SvekUtils.pixelToInches(nodesep);
		// Log.println("nodesep=" + nodesepInches);
		double ranksep = getVerticalDzeta(stringBounder);
		if (ranksep < getMinRankSep())
			ranksep = getMinRankSep();

		if (skinParam.getRanksep() != 0)
			ranksep = skinParam.getRanksep();

		final String ranksepInches = SvekUtils.pixelToInches(ranksep);
		// Log.println("ranksep=" + ranksepInches);
		sb.append("digraph unix {");
		SvekUtils.println(sb);

		for (String s : dotStrings) {
			if (s.startsWith("ranksep"))
				sb.append("ranksep=" + ranksepInches + ";");
			else if (s.startsWith("nodesep"))
				sb.append("nodesep=" + nodesepInches + ";");
			else
				sb.append(s);

			SvekUtils.println(sb);
		}
		// sb.append("newrank=true;");
		// SvekUtils.println(sb);
		sb.append("remincross=true;");
		SvekUtils.println(sb);
		sb.append("searchsize=500;");
		SvekUtils.println(sb);
		// if (OptionFlags.USE_COMPOUND) {
		// sb.append("compound=true;");
		// SvekUtils.println(sb);
		// }

		final DotSplines dotSplines = skinParam.getDotSplines();
		if (dotSplines == DotSplines.POLYLINE) {
			sb.append("splines=polyline;");
			SvekUtils.println(sb);
		} else if (dotSplines == DotSplines.ORTHO) {
			sb.append("splines=ortho;");
			sb.append("forcelabels=true;");
			SvekUtils.println(sb);
		}

		if (skinParam.getRankdir() == Rankdir.LEFT_TO_RIGHT) {
			sb.append("rankdir=LR;");
			SvekUtils.println(sb);
		}

		manageMinMaxCluster(sb);

		if (root.diagram.getPragma().isTrue(PragmaKey.KERMOR)) {
			for (SvekEdge line : getBibliotekon().lines0())
				line.appendLine(getGraphvizVersion(), sb, dotMode, dotSplines);
			for (SvekEdge line : getBibliotekon().lines1())
				line.appendLine(getGraphvizVersion(), sb, dotMode, dotSplines);

			root.printCluster3_forKermor(sb, getBibliotekon().allLines(), stringBounder, dotMode, getGraphvizVersion(),
					umlDiagramType);

		} else {
			root.printCluster1(sb, getBibliotekon().allLines(), stringBounder);

			for (SvekEdge line : getBibliotekon().lines0())
				line.appendLine(getGraphvizVersion(), sb, dotMode, dotSplines);

			root.printCluster2(sb, getBibliotekon().allLines(), stringBounder, dotMode, getGraphvizVersion(),
					umlDiagramType);

			for (SvekEdge line : getBibliotekon().lines1())
				line.appendLine(getGraphvizVersion(), sb, dotMode, dotSplines);

		}

		SvekUtils.println(sb);
		sb.append("}");

		return sb.toString();
	}

	private void manageMinMaxCluster(final StringBuilder sb) {
		final List<String> minPointCluster = new ArrayList<>();
		final List<String> maxPointCluster = new ArrayList<>();
		for (Cluster cluster : getBibliotekon().allCluster()) {
			final String minPoint = cluster.getMinPoint(umlDiagramType);
			if (minPoint != null)
				minPointCluster.add(minPoint);

			final String maxPoint = cluster.getMaxPoint(umlDiagramType);
			if (maxPoint != null)
				maxPointCluster.add(maxPoint);

		}
		if (minPointCluster.size() > 0) {
			sb.append("{rank=min;");
			for (String s : minPointCluster) {
				sb.append(s);
				sb.append(" [shape=point,width=.01,label=\"\"]");
				sb.append(";");
			}
			sb.append("}");
			SvekUtils.println(sb);
		}
		if (maxPointCluster.size() > 0) {
			sb.append("{rank=max;");
			for (String s : maxPointCluster) {
				sb.append(s);
				sb.append(" [shape=point,width=.01,label=\"\"]");
				sb.append(";");
			}
			sb.append("}");
			SvekUtils.println(sb);
		}
	}

	private int getMinRankSep() {
		if (umlDiagramType == UmlDiagramType.ACTIVITY) {
			// return 29;
			return 40;
		}
		if (root.diagram.getPragma().isTrue(PragmaKey.KERMOR))
			return 40;
		return 60;
	}

	private int getMinNodeSep() {
		if (umlDiagramType == UmlDiagramType.ACTIVITY) {
			// return 15;
			return 20;
		}
		return 35;
	}

	private GraphvizVersion graphvizVersion;

	public GraphvizVersion getGraphvizVersion() {
		if (TeaVM.isTeaVM())
			return null;
		else {
			if (graphvizVersion == null)
				graphvizVersion = getGraphvizVersionInternal();

			return graphvizVersion;
		}
	}

	private GraphvizVersion getGraphvizVersionInternal() {
		if (TeaVM.isTeaVM())
			return null;
		else {
			final Graphviz graphviz = GraphvizRuntimeEnvironment.getInstance().create(skinParam, "foo;", "svg");
			if (graphviz instanceof GraphvizJs)
				return GraphvizJs.getGraphvizVersion(false);

			final File f = graphviz.getDotExe();
			return GraphvizRuntimeEnvironment.getInstance().getVersion(f);
		}
	}

	public String getSvg(StringBounder stringBounder, DotMode dotMode, BaseFile basefile, String[] dotOptions)
			throws IOException {
		String dotString = createDotString(stringBounder, dotMode, dotOptions);

		if (TeaVM.isTeaVM()) {
			// ::revert when JAVA8
			return net.sourceforge.plantuml.teavm.GraphVizjsTeaVMEngine.renderDotToSvg(dotString);
			// return null;
			// ::done
		} else {

			if (basefile != null) {
				final SFile f = basefile.getTraceFile("svek.dot");
				SvekUtils.traceString(f, dotString);
			}

			Graphviz graphviz = GraphvizRuntimeEnvironment.getInstance().create(skinParam, dotString, "svg");
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			try {
				final ProcessState state = graphviz.createFile3(baos);
				baos.close();
				if (state.differs(ProcessState.TERMINATED_OK()))
					throw new IllegalStateException("Timeout4 " + state, state.getCause());

			} catch (GraphvizJsRuntimeException e) {
				System.err.println("GraphvizJsRuntimeException");
				graphvizVersion = GraphvizJs.getGraphvizVersion(true);
				dotString = createDotString(stringBounder, dotMode, dotOptions);
				graphviz = GraphvizRuntimeEnvironment.getInstance().create(skinParam, dotString, "svg");
				baos = new ByteArrayOutputStream();
				final ProcessState state = graphviz.createFile3(baos);
				baos.close();
				if (state.differs(ProcessState.TERMINATED_OK()))
					throw new IllegalStateException("Timeout4 " + state, state.getCause());

			}
			final byte[] result = baos.toByteArray();
			final String s = new String(result, UTF_8);

			if (basefile != null) {
				final SFile f = basefile.getTraceFile("svek.svg");
				SvekUtils.traceString(f, s);
			}

			return s;
		}
	}

	public boolean illegalDotExe() {
		if (TeaVM.isTeaVM())
			return false;
		final Graphviz graphviz = GraphvizRuntimeEnvironment.getInstance().create(skinParam, "svg");
		if (graphviz instanceof GraphvizJs)
			return false;

		final File dotExe = graphviz.getDotExe();
		return dotExe == null || dotExe.isFile() == false || dotExe.canRead() == false;
	}

	public File getDotExe() {
		if (!TeaVM.isTeaVM()) {
			final Graphviz graphviz = GraphvizRuntimeEnvironment.getInstance().create(skinParam, "svg");
			return graphviz.getDotExe();
		} else {
			throw new UnsupportedOperationException("TEAVM777");
		}
	}

	private static final Pattern pGraph = Pattern.compile("(?m)\\<svg\\s+width=\"(\\d+)pt\"\\s+height=\"(\\d+)pt\"");

	public void solve(final String svg) throws IOException, InterruptedException {
		if (svg.length() == 0)
			throw new EmptySvgException();

		final Matcher mGraph = pGraph.matcher(svg);
		if (mGraph.find() == false)
			throw new IllegalStateException();

		final int fullHeight = Integer.parseInt(mGraph.group(2));

		final Point2DFunction move = new YDelta(fullHeight);
		final SvgResult svgResult = new SvgResult(svg, move);
		for (SvekNode node : getBibliotekon().allNodes()) {
			int idx = svg.indexOf("<title>" + node.getUid() + "</title>");
			if (node.getType() == ShapeType.RECTANGLE || node.getType() == ShapeType.RECTANGLE_HTML_FOR_PORTS
					|| node.getType() == ShapeType.RECTANGLE_WITH_CIRCLE_INSIDE || node.getType() == ShapeType.FOLDER
					|| node.getType() == ShapeType.DIAMOND || node.getType() == ShapeType.RECTANGLE_PORT) {
				final List<XPoint2D> points = svgResult.substring(idx).extractList(SvgResult.POINTS_EQUALS);
				final XPoint2D min = SvekUtils.getMinXY(points);
				node.moveDelta(min.getX(), min.getY());
			} else if (node.getType() == ShapeType.ROUND_RECTANGLE) {
				final int idx2 = svg.indexOf("d=\"", idx + 1);
				idx = svg.indexOf("points=\"", idx + 1);
				final List<XPoint2D> points;
				if (idx2 != -1 && (idx == -1 || idx2 < idx)) {
					// GraphViz 2.30
					points = svgResult.substring(idx2).extractList(SvgResult.D_EQUALS);
				} else {
					points = svgResult.substring(idx).extractList(SvgResult.POINTS_EQUALS);
					for (int i = 0; i < 3; i++) {
						idx = svg.indexOf("points=\"", idx + 1);
						points.addAll(svgResult.substring(idx).extractList(SvgResult.POINTS_EQUALS));
					}
				}
				final XPoint2D min = SvekUtils.getMinXY(points);
				node.moveDelta(min.getX(), min.getY());
			} else if (node.getType() == ShapeType.OCTAGON || node.getType() == ShapeType.HEXAGON) {
				idx = svg.indexOf("points=\"", idx + 1);
				final int starting = idx;
				final List<XPoint2D> points = svgResult.substring(starting).extractList(SvgResult.POINTS_EQUALS);
				final XPoint2D min = SvekUtils.getMinXY(points);
				// corner1.manage(minX, minY);
				node.moveDelta(min.getX(), min.getY());
				node.setPolygon(min.getX(), min.getY(), points);
			} else if (node.getType() == ShapeType.CIRCLE || node.getType() == ShapeType.OVAL) {
				final double cx = SvekUtils.getValue(svg, idx, "cx");
				final double cy = SvekUtils.getValue(svg, idx, "cy") + fullHeight;
				final double rx = SvekUtils.getValue(svg, idx, "rx");
				final double ry = SvekUtils.getValue(svg, idx, "ry");
				node.moveDelta(cx - rx, cy - ry);
			} else {
				throw new IllegalStateException(node.getType().toString() + " " + node.getUid());
			}
		}

		for (Cluster cluster : getBibliotekon().allCluster()) {
			if (cluster.getGroup().isPacked())
				continue;

			int idx = getClusterIndex(svg, cluster.getColor());
			final int starting = idx;
			final List<XPoint2D> points = svgResult.substring(starting).extractList(SvgResult.POINTS_EQUALS);
			final XPoint2D min = SvekUtils.getMinXY(points);
			final XPoint2D max = SvekUtils.getMaxXY(points);
			cluster.setPosition(min, max);

			if (cluster.getTitleAndAttributeWidth() == 0 || cluster.getTitleAndAttributeHeight() == 0)
				continue;

			idx = getClusterIndex(svg, cluster.getTitleColor());
			final List<XPoint2D> pointsTitle = svgResult.substring(idx).extractList(SvgResult.POINTS_EQUALS);
			cluster.setTitlePosition(SvekUtils.getMinXY(pointsTitle));

			if (root.diagram.getPragma().isTrue(PragmaKey.KERMOR)) {
				if (cluster.getGroup().getNotes(Position.TOP).size() > 0) {
					final List<XPoint2D> noteUp = svgResult.substring(getClusterIndex(svg, cluster.getColorNoteTop()))
							.extractList(SvgResult.POINTS_EQUALS);
					cluster.setNoteTopPosition(SvekUtils.getMinXY(noteUp));
				}
				if (cluster.getGroup().getNotes(Position.BOTTOM).size() > 0) {
					final List<XPoint2D> noteBottom = svgResult
							.substring(getClusterIndex(svg, cluster.getColorNoteBottom()))
							.extractList(SvgResult.POINTS_EQUALS);
					cluster.setNoteBottomPosition(SvekUtils.getMinXY(noteBottom));
				}
			}
		}

		for (SvekEdge line : getBibliotekon().allLines())
			line.solveLine(svgResult);

		// Align edges at label nodes for orthogonal routing
		if (skinParam.getDotSplines() == DotSplines.ORTHO)
			alignEdgesAtLabelNodes();

		for (SvekEdge line : getBibliotekon().allLines())
			line.manageCollision(getBibliotekon().allNodes());

	}

	/**
	 * Insert horizontal corners in orthogonal edges to align them through label
	 * node centers. This handles the case where edges entering and leaving a label
	 * node are horizontally misaligned.
	 */
	private void alignEdgesAtLabelNodes() {
		// Find all nodes that are edge labels (typically named "transition_...")
		final List<SvekNode> labelNodes = new ArrayList<>();
		for (SvekNode node : getBibliotekon().allNodes()) {
			final Entity entity = getBibliotekon().getLeaf(node);
			if (entity != null && entity.getName() != null && entity.getName().startsWith("transition_")) {
				labelNodes.add(node);
			}
		}

		// For each label node, find edges connecting through it and align them
		for (SvekNode labelNode : labelNodes) {
			alignEdgesThroughLabel(labelNode);
		}
	}

	/**
	 * Align edges that pass through a specific label node
	 */
	private void alignEdgesThroughLabel(SvekNode labelNode) {
		// Find edges coming into and out of this label node
		final Entity labelEntity = getBibliotekon().getLeaf(labelNode);
		if (labelEntity == null)
			return;

		// Get all edges connected to this label node
		final List<SvekEdge> connectedEdges = getBibliotekon().getAllLineConnectedTo(labelEntity);
		if (connectedEdges.size() != 2)
			return; // We need exactly 2 edges (one in, one out)

		// Determine which edge is incoming and which is outgoing
		final SvekEdge edge0 = connectedEdges.get(0);
		final SvekEdge edge1 = connectedEdges.get(1);

		if (edge0.getDotPath() == null || edge1.getDotPath() == null)
			return;

		// The edge whose endpoint is above the label is incoming (ends at label)
		// The edge whose startpoint is below the label is outgoing (starts from label)
		final double labelCenterY = labelNode.getMinY() + labelNode.getHeight() / 2.0;
		final double edge0EndY = edge0.getDotPath().getEndPoint().getY();
		final double edge0StartY = edge0.getDotPath().getStartPoint().getY();

		SvekEdge edgeIn, edgeOut;
		// If edge0 ends near the label (incoming to label), then edge1 starts from
		// label (outgoing)
		if (Math.abs(edge0EndY - labelCenterY) < Math.abs(edge0StartY - labelCenterY)) {
			edgeIn = edge0;
			edgeOut = edge1;
		} else {
			edgeIn = edge1;
			edgeOut = edge0;
		}

		insertCornersForAlignment(edgeIn, edgeOut, labelNode);
	}

	/**
	 * Insert horizontal corners in edges to align them at the label node center.
	 * This creates new paths with straight line segments and right-angle corners.
	 */
	private void insertCornersForAlignment(SvekEdge edgeIn, SvekEdge edgeOut, SvekNode labelNode) {
		final net.sourceforge.plantuml.klimt.shape.DotPath pathIn = edgeIn.getDotPath();
		final net.sourceforge.plantuml.klimt.shape.DotPath pathOut = edgeOut.getDotPath();

		if (pathIn == null || pathOut == null)
			return;

		// Get the label node center position
		final double labelCenterX = labelNode.getMinX() + labelNode.getWidth() / 2.0;
		final double labelCenterY = labelNode.getMinY() + labelNode.getHeight() / 2.0;

		// Get edge endpoints
		final XPoint2D inStart = pathIn.getStartPoint();
		final XPoint2D inEnd = pathIn.getEndPoint();
		final XPoint2D outStart = pathOut.getStartPoint();
		final XPoint2D outEnd = pathOut.getEndPoint();

		// Check if edges are misaligned horizontally
		final double xDiff = Math.abs(inEnd.getX() - outStart.getX());
		if (xDiff < 5.0) // Already aligned
			return;

		// Check if they connect through this label (vertically adjacent)
		final double yGap = Math.abs(inEnd.getY() - outStart.getY());
		if (yGap > 30.0) // Not connected through this label
			return;

		// Rebuild incoming edge with corner to align at label center
		final net.sourceforge.plantuml.klimt.shape.DotPath newPathIn = rebuildPathWithCorner(inStart, inEnd,
				labelCenterX, labelCenterY, true);
		if (newPathIn != null) {
			edgeIn.replaceDotPath(newPathIn);
		}

		// Rebuild outgoing edge with corner to align at label center
		final net.sourceforge.plantuml.klimt.shape.DotPath newPathOut = rebuildPathWithCorner(outStart, outEnd,
				labelCenterX, labelCenterY, false);
		if (newPathOut != null) {
			edgeOut.replaceDotPath(newPathOut);
		}
	}

	/**
	 * Rebuild a path with a horizontal corner to route through the target X
	 * coordinate. Creates straight line segments: start -> corner1 -> corner2 ->
	 * end The horizontal segment is placed at the start/end Y coordinate to avoid
	 * obscuring the label.
	 */
	private net.sourceforge.plantuml.klimt.shape.DotPath rebuildPathWithCorner(XPoint2D start, XPoint2D end,
			double targetX, double targetY, boolean isIncoming) {

		final double startX = start.getX();
		final double startY = start.getY();
		final double endX = end.getX();
		final double endY = end.getY();

		// Check if we need to add a corner
		if (Math.abs(startX - targetX) < 1.0 && Math.abs(endX - targetX) < 1.0) {
			return null; // Already aligned, no change needed
		}

		// Create path with vertical alignment at targetX
		// Pattern for incoming: start → vertical → horizontal → vertical (aligned at
		// targetX) → end
		// Pattern for outgoing: start → vertical (aligned at targetX) → horizontal →
		// vertical → end
		final List<XCubicCurve2D> beziers = new ArrayList<>();

		if (isIncoming) {
			// Incoming edge: vertical → horizontal → vertical (aligned at targetX)
			final double horizontalY = endY - 20;

			// Segment 1: vertical from start down to horizontal routing level
			beziers.add(new XCubicCurve2D(startX, startY, startX, startY, startX, horizontalY, startX, horizontalY));

			// Segment 2: horizontal jog from startX to targetX
			beziers.add(new XCubicCurve2D(startX, horizontalY, startX, horizontalY, targetX, horizontalY, targetX,
					horizontalY));

			// Segment 3: vertical aligned segment at targetX down to endY (path ends at
			// targetX)
			beziers.add(new XCubicCurve2D(targetX, horizontalY, targetX, horizontalY, targetX, endY, targetX, endY));

		} else {
			// Outgoing edge: vertical (aligned at targetX) → horizontal → vertical
			final double horizontalY = startY + 20;

			// Segment 1: vertical aligned segment at targetX from startY (path starts at
			// targetX)
			beziers.add(
					new XCubicCurve2D(targetX, startY, targetX, startY, targetX, horizontalY, targetX, horizontalY));

			// Segment 2: horizontal jog from targetX to endX
			beziers.add(new XCubicCurve2D(targetX, horizontalY, targetX, horizontalY, endX, horizontalY, endX,
					horizontalY));

			// Segment 3: vertical down to actual end point
			beziers.add(new XCubicCurve2D(endX, horizontalY, endX, horizontalY, endX, endY, endX, endY));
		}

		return net.sourceforge.plantuml.klimt.shape.DotPath.fromBeziers(beziers);
	}

	private int getClusterIndex(final String svg, int colorInt) {
		final String colorString = StringUtils.goLowerCase(XColor.toHexRGBColor(colorInt));
		final String keyTitle1 = "=\"" + colorString + "\"";
		int idx = svg.indexOf(keyTitle1);
		if (idx == -1) {
			final String keyTitle2 = "stroke:" + colorString + ";";
			idx = svg.indexOf(keyTitle2);
		}
		if (idx == -1)
			throw new IllegalStateException("Cannot find color " + colorString);

		return idx;
	}

	public void moveDelta(double deltaX, double deltaY) {
		for (SvekNode sh : getBibliotekon().allNodes())
			sh.moveDelta(deltaX, deltaY);

		for (SvekEdge line : getBibliotekon().allLines())
			line.moveDelta(deltaX, deltaY);

		for (Cluster cl : getBibliotekon().allCluster())
			cl.moveDelta(deltaX, deltaY);

	}

}
