/*****************************************************************************
 * Copyright (c) 2015 CEA LIST.
 *
 *
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *  Sebastien Revol (CEA LIST) sebastien.revol@cea.fr - Initial API and implementation
 *  Vincent Lorenzo (CEa LIST) vincent.lorenzo@cea.fr - bugs 496176, 499237 
 *****************************************************************************/

package org.eclipse.papyrus.interoperability.rpy.blackboxes;


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg.KeyPoint;
import org.eclipse.gmf.runtime.notation.Connector;
import org.eclipse.gmf.runtime.notation.IdentityAnchor;
import org.eclipse.gmf.runtime.notation.NotationFactory;
import org.eclipse.gmf.runtime.notation.RelativeBendpoints;
import org.eclipse.gmf.runtime.notation.datatype.RelativeBendpoint;
import org.eclipse.m2m.qvt.oml.blackbox.java.Operation;
import org.eclipse.m2m.qvt.oml.blackbox.java.Operation.Kind;
import org.eclipse.papyrus.interoperability.rpy.geometry.rpygeometry.Point;
import org.eclipse.papyrus.interoperability.rpy.geometry.rpygeometry.RpyGeometryFactory;
import org.eclipse.papyrus.interoperability.rpy.geometry.rpygeometry.RpyShape;
import org.eclipse.papyrus.interoperability.rpy.geometry.utils.RpyShapeOperations;
import org.eclipse.papyrus.interoperability.rpy.rpymetamodel.CGIAnchor;
import org.eclipse.papyrus.interoperability.rpy.rpymetamodel.CGIAssociationEnd;
import org.eclipse.papyrus.interoperability.rpy.rpymetamodel.CGIDiagramFrame;
import org.eclipse.papyrus.interoperability.rpy.rpymetamodel.CGIObjectLink;
import org.eclipse.papyrus.interoperability.rpy.rpymetamodel.GraphElementsType;

/**
 * @author sr246418
 *
 */

public class Rpy2PapyrusNotationBlackboxes {

	/** the size of the transform field */
	public static final int M_TRANSFORM_SIZE = 6;

	/** the index of intersting value in m transform */
	public static final int M_TRANSFORM_X_RATIO_INDEX = 0;
	public static final int M_TRANSFORM_Y_RATIO_INDEX = 3;
	public static final int M_TRANSFORM_X_POSITION_INDEX = 4;
	public static final int M_TRANSFORM_Y_POSITION_INDEX = 5;

	/** the index of the x and y value for each points of the rectangle */
	public static final int M_POLYGON__RECTANGLE_NB_POINTS_INDEX = 0;

	/** the index of the x and y value for each points of the rectangle */
	public static final int M_POLYGON__RECTANGLE_TOP_LEFT_CORNER_X_INDEX = 1;
	public static final int M_POLYGON__RECTANGLE_TOP_LEFT_CORNER_Y_INDEX = 2;
	public static final int M_POLYGON__RECTANGLE_BOTTOM_LEFT_CORNER_X_INDEX = 3;
	public static final int M_POLYGON__RECTANGLE_BOTTOM_LEFT_CORNER_Y_INDEX = 4;
	public static final int M_POLYGON__RECTANGLE_BOTTOM_RIGHT_CORNER_X_INDEX = 5;
	public static final int M_POLYGON__RECTANGLE_BOTTOM_RIGHT_CORNER__Y_INDEX = 6;
	public static final int M_POLYGON__RECTANGLE_TOP_RIGHT_CORNER_X_INDEX = 7;
	public static final int M_POLYGON__RECTANGLE_TOP_RIGHT_CORNER_Y_INDEX = 8;

	/** X and Y indexes for a point in an array */
	public static final int X_INDEX = 0;
	public static final int Y_INDEX = 1;

	/** code returned when we are not able to get the wanted value */
	public static final int ERROR_CODE = Integer.MAX_VALUE;

	/** names of structural feature */
	public static final String M_TRANSFORM = "m_transform"; //$NON-NLS-1$
	public static final String M_POLYGON = "m_polygon"; //$NON-NLS-1$
	public static final String M_pPARENT = "m_pParent"; //$NON-NLS-1$

	// TODO : try to link me to GMF value!
	private static final int MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS = -643984;

	@Operation(kind = Kind.HELPER)
	public boolean contains(final String aString, final String aPotentialSubString) {
		if (null == aString || aPotentialSubString == null) {
			return false;
		}
		return aString.contains(aPotentialSubString);
	}

	// TODO add GMF source and target object to get their size and location ?
	// 0 : source, 1 : target, 2, ... bendpoints if required
	// TODO : we advice to manage anchor and bendpoints in the same method, to be able to make required adjutment
	/**
	 * @param
	 * 			a
	 *            Rpy association
	 * @param
	 * 			result
	 * @return a list, where the 2 first values are the source anchor and the target anchors.
	 * 
	 *         TODO update documentation when we will manage bendpoint too in the same method
	 *         //TODO speak about the magic number
	 *         //TODO try to set one anchor term to 0 or 1 each time
	 *         //TODO : property m_line_style is not yet exploited : 0 is straight, 2 is rectilinear
	 * 
	 */
	@Operation(kind = Kind.QUERY)
	public void addAnchorsAndBendpoints(Object association, Connector result) {
		if (!isARpyLink(association)) {
			return;
		}
		// 1. we need to get all in absolute position
		// find source and target anchor in absolute location
		final List<String> rpySourceAnchorAsString = getM_SourcePort(association);
		final List<String> rpyTargetAnchorAsString = getM_TargetPort(association);
		final GraphElementsType sourceGraphicalObject = getM_pSource(association);
		final GraphElementsType targetGraphicalObject = getM_pTarget(association);
		final RpyShape sourceShape = RpyShapeOperations.createRpyShape(sourceGraphicalObject);
		final RpyShape targetShape = RpyShapeOperations.createRpyShape(targetGraphicalObject);


		final Point rpySourceAnchor = RpyGeometryFactory.eINSTANCE.createPoint();
		rpySourceAnchor.setX(Double.valueOf(rpySourceAnchorAsString.get(0)));
		rpySourceAnchor.setY(Double.valueOf(rpySourceAnchorAsString.get(1)));
		final Point rpySourceAnchorInAbsolute = sourceShape.getTransform().multiply(rpySourceAnchor);


		final Point rpyTargetAnchor = RpyGeometryFactory.eINSTANCE.createPoint();
		rpyTargetAnchor.setX(Double.valueOf(rpyTargetAnchorAsString.get(0)));
		rpyTargetAnchor.setY(Double.valueOf(rpyTargetAnchorAsString.get(1)));
		final Point rpyTargetAnchorInAbsolute = targetShape.getTransform().multiply(rpyTargetAnchor);


		// 2. determine bendpoints in absolute location
		final List<String> rpyBendpointsAsString = getM_arrow(association);
		final List<Point> rpyBendpointsInAbsolute = new ArrayList<Point>();
		if (rpyBendpointsAsString.size() > 0) {
			for (int i = 1; i < Integer.valueOf(rpyBendpointsAsString.get(0)) * 2; i = i + 2) {
				Point newPoint = RpyGeometryFactory.eINSTANCE.createPoint();
				newPoint.setX(Double.valueOf(rpyBendpointsAsString.get(i)));
				newPoint.setY(Double.valueOf(rpyBendpointsAsString.get(i + 1)));
				rpyBendpointsInAbsolute.add(newPoint);
			}
		}


		// 3. here we get the source anchor, the target anchor and the bendpoints in absolute location
		// it is here we could do some adjustment to fix round errors
		// TODO : fix round errors!?
		// /!\ fixing error could make problems for link linked to link ?
		// bendpoint could be not in the good location, if we add/remove an offset to the compartemnt contents!

		// 4. we can now determine source anchor, target anchor and bendpoints
		final Point sourceAnchorInRelative = RpyGeometryFactory.eINSTANCE.createPoint();
		sourceAnchorInRelative.setX(rpySourceAnchorInAbsolute.getX() - sourceShape.getAbsolutePosition().getX());
		sourceAnchorInRelative.setY(rpySourceAnchorInAbsolute.getY() - sourceShape.getAbsolutePosition().getY());

		final Point targetAnchorInRelative = RpyGeometryFactory.eINSTANCE.createPoint();
		targetAnchorInRelative.setX(rpyTargetAnchorInAbsolute.getX() - targetShape.getAbsolutePosition().getX());
		targetAnchorInRelative.setY(rpyTargetAnchorInAbsolute.getY() - targetShape.getAbsolutePosition().getY());

		final Point firstBendpoint = RpyGeometryFactory.eINSTANCE.createPoint();
		firstBendpoint.setX(rpySourceAnchorInAbsolute.getX());
		firstBendpoint.setY(rpySourceAnchorInAbsolute.getY());

		final Point lastBendpoint = RpyGeometryFactory.eINSTANCE.createPoint();
		lastBendpoint.setX(rpyTargetAnchorInAbsolute.getX());
		lastBendpoint.setY(rpyTargetAnchorInAbsolute.getY());


		// we create the bendpoints list
		List<RelativeBendpoint> gmfBendpoints = new ArrayList<RelativeBendpoint>();
		// source bendpoints
		gmfBendpoints.add(new RelativeBendpoint(firstBendpoint.getIntX(), firstBendpoint.getIntY(), MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS, MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS));

		// intermediate bendpoints
		for (Point current : rpyBendpointsInAbsolute) {
			gmfBendpoints.add(new RelativeBendpoint(current.getIntX(), current.getIntY(), MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS, MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS));
		}

		// last bendpoints
		gmfBendpoints.add(new RelativeBendpoint(lastBendpoint.getIntX(), lastBendpoint.getIntY(), MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS, MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS));

		// we register the bendpoints into the connector
		RelativeBendpoints bendpoints12 = NotationFactory.eINSTANCE.createRelativeBendpoints();
		bendpoints12.setPoints(gmfBendpoints);
		result.setBendpoints(bendpoints12);

		IdentityAnchor sourceAnchor = NotationFactory.eINSTANCE.createIdentityAnchor();
		sourceAnchor.setId(getAnchorFromAbsolutePosition(sourceShape, sourceAnchorInRelative));

		IdentityAnchor targetAnchor = NotationFactory.eINSTANCE.createIdentityAnchor();
		targetAnchor.setId(getAnchorFromAbsolutePosition(targetShape, targetAnchorInRelative));

		result.setSourceAnchor(sourceAnchor);
		result.setTargetAnchor(targetAnchor);
		//

		// TODO : rewritte anchor code
		// String sourceAnchor = getAnchorFromAbsolutePosition(sourceShape, rpySourceAnchorAsString);
		// String targetAnchor = getAnchorFromAbsolutePosition(targetShape, rpyTargetAnchorAsString);
		// List<String> returnedValues = new ArrayList<>();
		// returnedValues.add(sourceAnchor);
		// returnedValues.add(targetAnchor);
		//
		// return returnedValues;
	}

	/**
	 * 
	 * @param anObject
	 *            an object
	 * @return
	 * 		<code>true</code> if the object can be considered as a rpy link
	 */
	private boolean isARpyLink(final Object anObject) {
		if (getM_pSource(anObject) != null && getM_pTarget(anObject) != null && getM_SourcePort(anObject).size() == 2 && getM_TargetPort(anObject).size() == 2) {
			return true;
		}
		return false;
	}

	private List<String> getM_arrow(Object anObject) {
		if (anObject instanceof CGIObjectLink) {
			return ((CGIObjectLink) anObject).getM_arrow();
		} else if (anObject instanceof CGIAnchor) {
			return ((CGIAnchor) anObject).getM_arrow();
		} else if (anObject instanceof CGIAssociationEnd) {
			return ((CGIAssociationEnd) anObject).getM_arrow();
		}
		return Collections.emptyList();
	}

	private GraphElementsType getM_pSource(Object anObject) {
		if (anObject instanceof CGIObjectLink) {
			return (GraphElementsType) ((CGIObjectLink) anObject).getM_pSource();
		} else if (anObject instanceof CGIAnchor) {
			return (GraphElementsType) ((CGIAnchor) anObject).getM_pSource();
		} else if (anObject instanceof CGIAssociationEnd) {
			return (GraphElementsType) ((CGIAssociationEnd) anObject).getM_pSource();
		}
		return null;
	}

	private GraphElementsType getM_pTarget(Object anObject) {
		if (anObject instanceof CGIObjectLink) {
			return (GraphElementsType) ((CGIObjectLink) anObject).getM_pTarget();
		} else if (anObject instanceof CGIAnchor) {
			return (GraphElementsType) ((CGIAnchor) anObject).getM_pTarget();
		} else if (anObject instanceof CGIAssociationEnd) {
			return (GraphElementsType) ((CGIAssociationEnd) anObject).getM_pTarget();
		}
		return null;
	}

	private List<String> getM_SourcePort(Object anObject) {
		if (anObject instanceof CGIObjectLink) {
			return ((CGIObjectLink) anObject).getM_SourcePort();
		} else if (anObject instanceof CGIAnchor) {
			return ((CGIAnchor) anObject).getM_SourcePort();
		} else if (anObject instanceof CGIAssociationEnd) {
			return ((CGIAssociationEnd) anObject).getM_SourcePort();
		}
		return Collections.emptyList();
	}

	private List<String> getM_TargetPort(Object anObject) {
		if (anObject instanceof CGIObjectLink) {
			return ((CGIObjectLink) anObject).getM_TargetPort();
		} else if (anObject instanceof CGIAnchor) {
			return ((CGIAnchor) anObject).getM_TargetPort();
		} else if (anObject instanceof CGIAssociationEnd) {
			return ((CGIAssociationEnd) anObject).getM_TargetPort();
		}
		return Collections.emptyList();
	}


	/** This method has been developed (not yet finished and not yet usable) to be able to create link on link */
	@Operation(kind = Kind.QUERY)
	// TODO : finish me!
	public void addAnchorsAndBendpoints_V2_FOR_LinkONLink(CGIAnchor association, Connector result) {
		// 1. we need to get all in absolute position
		// find source and target anchor in absolute location
		final List<String> rpySourceAnchorAsString = association.getM_SourcePort();
		final List<String> rpyTargetAnchorAsString = association.getM_TargetPort();
		final GraphElementsType sourceGraphicalObject = (GraphElementsType) association.getM_pSource();
		final GraphElementsType targetGraphicalObject = (GraphElementsType) association.getM_pTarget();
		Point newTargetAnchorInAbsolute = null;// RpyGeometryFactory.eINSTANCE.createPoint();

		// ------------------this part of the code has been done to be able to create anchor on a link (comment link linked to an other link!!!!-----

		if (targetGraphicalObject instanceof CGIObjectLink) {// we are connected on a link, so rpyTargetAnchorAsString could have a first value in % and the second one seem be 0
			CGIObjectLink link = ((CGIObjectLink) targetGraphicalObject);
			Connector tmp = NotationFactory.eINSTANCE.createConnector();
			addAnchorsAndBendpoints(link, tmp);
			// 1. calculate the full length of the link:
			final RelativeBendpoints bendpoints = (RelativeBendpoints) tmp.getBendpoints();
			double length = 0;
			List<LineSeg> linesSegs = new ArrayList<LineSeg>();
			// Iterator<RelativeBendpoint> iter = bendpoints.getPoints().iterator();
			List<Double> cumulatedLength = new ArrayList<>();
			for (int i = 1; i < bendpoints.getPoints().size(); i++) {
				RelativeBendpoint pt1 = (RelativeBendpoint) bendpoints.getPoints().get(i - 1);
				RelativeBendpoint pt2 = (RelativeBendpoint) bendpoints.getPoints().get(i);
				linesSegs.add(new LineSeg(new org.eclipse.draw2d.geometry.Point(pt1.getSourceX(), pt1.getSourceY()), new org.eclipse.draw2d.geometry.Point(pt2.getSourceX(), pt2.getSourceY())));
			}


			for (LineSeg lineSeg : linesSegs) {
				length += lineSeg.length();
				cumulatedLength.add(Double.valueOf(length));
			}

			double percentage = Double.valueOf(rpyTargetAnchorAsString.get(0));
			double wantedLength = length * percentage / 100.00;

			int wantedLineSeg = -1;
			int iter = 0;
			while (wantedLineSeg == -1 && iter < cumulatedLength.size()) {
				if (cumulatedLength.get(iter) > wantedLength) {
					// i is the index of the lineseg on which the good length is obtained
					wantedLineSeg = iter;
				}
			}

			double needToCrossOnThisLineSeg = -1;
			if (iter == 0) {
				needToCrossOnThisLineSeg = wantedLength;
			} else {
				needToCrossOnThisLineSeg = wantedLength - cumulatedLength.get(wantedLineSeg - 1);
			}
			LineSeg w = linesSegs.get(iter);
			double percentage12 = 100 * needToCrossOnThisLineSeg / linesSegs.get(iter).length();
			double xOffset = ((double) w.getTerminus().x - (double) w.getOrigin().x) * percentage12 / 100.0;
			double yOffset = ((double) w.getTerminus().y - (double) w.getOrigin().y) * percentage12 / 100.0;
			newTargetAnchorInAbsolute = RpyGeometryFactory.eINSTANCE.createPoint();
			newTargetAnchorInAbsolute.setX(w.getOrigin().x + xOffset);
			newTargetAnchorInAbsolute.setY(w.getOrigin().y + yOffset);

			org.eclipse.draw2d.geometry.Point ptResult = new org.eclipse.draw2d.geometry.Point();
			KeyPoint toto = KeyPoint.ORIGIN;
			w.pointOn((long) needToCrossOnThisLineSeg, toto, ptResult);

			// double tmpLength = 0;
			// Iterator<LineSeg> iter = linesSegs.iterator();
			//
			// while (tmpLength < wantedLength && iter.hasNext()) {
			// LineSeg current = iter.next();
			// tmpLength += current.length();
			// }
			//
			// int segIndex = -1;
			// for (int i = 0; i < cumulatedLength.size(); i++) {
			// if (wantedLength > cumulatedLength.get(i)) {
			// segIndex = i - 1;
			// }
			// }
			// double requiredLengthOnThisSeg = wantedLength - cumulatedLength.get(segIndex);
			int j = 0;
			j++;
			Connector c = null;
			// c.
		}

		final RpyShape sourceShape = RpyShapeOperations.createRpyShape(sourceGraphicalObject);
		final RpyShape targetShape = RpyShapeOperations.createRpyShape(targetGraphicalObject);


		final Point rpySourceAnchor = RpyGeometryFactory.eINSTANCE.createPoint();
		rpySourceAnchor.setX(Double.valueOf(rpySourceAnchorAsString.get(0)));
		rpySourceAnchor.setY(Double.valueOf(rpySourceAnchorAsString.get(1)));
		final Point rpySourceAnchorInAbsolute = sourceShape.getTransform().multiply(rpySourceAnchor);


		final Point rpyTargetAnchor = RpyGeometryFactory.eINSTANCE.createPoint();
		rpyTargetAnchor.setX(Double.valueOf(rpyTargetAnchorAsString.get(0)));
		rpyTargetAnchor.setY(Double.valueOf(rpyTargetAnchorAsString.get(1)));
		final Point rpyTargetAnchorInAbsolute;
		if (newTargetAnchorInAbsolute == null) {
			rpyTargetAnchorInAbsolute = targetShape.getTransform().multiply(rpyTargetAnchor);
		} else {
			rpyTargetAnchorInAbsolute = newTargetAnchorInAbsolute;
		}

		// 2. determine bendpoints in absolute location
		final List<String> rpyBendpointsAsString = association.getM_arrow();
		final List<Point> rpyBendpointsInAbsolute = new ArrayList<Point>();
		if (rpyBendpointsAsString.size() > 0) {
			for (int i = 1; i < Integer.valueOf(rpyBendpointsAsString.get(0)) * 2; i = i + 2) {
				Point newPoint = RpyGeometryFactory.eINSTANCE.createPoint();
				newPoint.setX(Double.valueOf(rpyBendpointsAsString.get(i)));
				newPoint.setY(Double.valueOf(rpyBendpointsAsString.get(i + 1)));
				rpyBendpointsInAbsolute.add(newPoint);
			}
		}


		// 3. here we get the source anchor, the target anchor and the bendpoints in absolute location
		// it is here we could do some adjustment to fix round errors
		// TODO : fix round errors!?
		// /!\ fixing error could make problems for link linked to link ?
		// bendpoint could be not in the good location, if we add/remove an offset to the compartemnt contents!


		// 4. we can now determine source anchor, target anchor and bendpoints
		final Point sourceAnchorInRelative = RpyGeometryFactory.eINSTANCE.createPoint();
		sourceAnchorInRelative.setX(rpySourceAnchorInAbsolute.getX() - sourceShape.getAbsolutePosition().getX());
		sourceAnchorInRelative.setY(rpySourceAnchorInAbsolute.getY() - sourceShape.getAbsolutePosition().getY());

		final Point targetAnchorInRelative = RpyGeometryFactory.eINSTANCE.createPoint();
		targetAnchorInRelative.setX(rpyTargetAnchorInAbsolute.getX() - targetShape.getAbsolutePosition().getX());
		targetAnchorInRelative.setY(rpyTargetAnchorInAbsolute.getY() - targetShape.getAbsolutePosition().getY());

		final Point firstBendpoint = RpyGeometryFactory.eINSTANCE.createPoint();
		firstBendpoint.setX(rpySourceAnchorInAbsolute.getX());
		firstBendpoint.setY(rpySourceAnchorInAbsolute.getY());

		final Point lastBendpoint = RpyGeometryFactory.eINSTANCE.createPoint();
		lastBendpoint.setX(rpyTargetAnchorInAbsolute.getX());
		lastBendpoint.setY(rpyTargetAnchorInAbsolute.getY());


		// we create the bendpoints list
		List<RelativeBendpoint> gmfBendpoints = new ArrayList<RelativeBendpoint>();
		// source bendpoints
		gmfBendpoints.add(new RelativeBendpoint(firstBendpoint.getIntX(), firstBendpoint.getIntY(), MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS, MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS));

		// intermediate bendpoints
		for (Point current : rpyBendpointsInAbsolute) {
			gmfBendpoints.add(new RelativeBendpoint(current.getIntX(), current.getIntY(), MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS, MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS));
		}

		// last bendpoints
		gmfBendpoints.add(new RelativeBendpoint(lastBendpoint.getIntX(), lastBendpoint.getIntY(), MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS, MAGIC_NUMBER_FOR_ABSOLUTE_BENDPOINTS));

		// we register the bendpoints into the connector
		RelativeBendpoints bendpoints12 = NotationFactory.eINSTANCE.createRelativeBendpoints();
		bendpoints12.setPoints(gmfBendpoints);
		result.setBendpoints(bendpoints12);

		IdentityAnchor sourceAnchor = NotationFactory.eINSTANCE.createIdentityAnchor();
		sourceAnchor.setId(getAnchorFromAbsolutePosition(sourceShape, sourceAnchorInRelative));

		IdentityAnchor targetAnchor = NotationFactory.eINSTANCE.createIdentityAnchor();
		targetAnchor.setId(getAnchorFromAbsolutePosition(targetShape, targetAnchorInRelative));

		result.setSourceAnchor(sourceAnchor);
		result.setTargetAnchor(targetAnchor);
	}

	protected String getAnchorFromAbsolutePosition(RpyShape shape, Point point) {
		float newxRatio = 0;// = new Float(xPort) / new Float(shape.getWidth());
		float newyRatio = 0;// = new Float(yPort) / new Float(shape.getHeight());
		newxRatio = new Float(point.getX()) / new Float(shape.getWidth());
		newyRatio = new Float(point.getY()) / new Float(shape.getHeight());
		if (newxRatio > 1) {
			newxRatio = 1;
		}
		if (newyRatio > 1) {
			newyRatio = 1;
		}

		String id = "(" + newxRatio + "," + newyRatio + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		return id;
	}

	@Deprecated
	protected String getAnchorFromAbsolutePosition(RpyShape shape, List<String> port) {
		Point point = RpyGeometryFactory.eINSTANCE.createPoint();
		point.setX(Double.valueOf(port.get(0)));
		point.setY(Double.valueOf(port.get(1)));
		Point res = shape.getTransform().multiply(point);
		res.setX(res.getX() - shape.getAbsolutePosition().getX());
		res.setY(res.getY() - shape.getAbsolutePosition().getY());

		double[] topLeft = new double[] { shape.getParentRelativePosition().getX(), shape.getParentRelativePosition().getY() };
		double[] topRight = new double[] { shape.getParentRelativePosition().getX() + (double) shape.getWidth(), shape.getParentRelativePosition().getY() };
		double[] bottomLeft = new double[] { shape.getParentRelativePosition().getX(), shape.getParentRelativePosition().getY() + (double) shape.getHeight() };

		double xPort = Double.parseDouble(port.get(0));
		if (xPort < topLeft[X_INDEX]) {
			xPort = topLeft[X_INDEX];
		}
		if (xPort > topRight[X_INDEX]) {
			xPort = topRight[X_INDEX];
		}

		double yPort = Double.parseDouble(port.get(1));
		if (yPort < topLeft[Y_INDEX]) {
			yPort = topLeft[Y_INDEX];
		}
		if (yPort > bottomLeft[Y_INDEX]) {
			yPort = bottomLeft[Y_INDEX];
		}

		float newxRatio = new Float(xPort) / new Float(shape.getWidth());
		float newyRatio = new Float(yPort) / new Float(shape.getHeight());
		newxRatio = new Float(res.getX()) / new Float(shape.getWidth());
		newyRatio = new Float(res.getY()) / new Float(shape.getHeight());
		if (newxRatio > 1) {
			newxRatio = 1;
		}
		if (newyRatio > 1) {
			newyRatio = 1;
		}

		String id = "(" + newxRatio + "," + newyRatio + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		return id;
	}

	@Operation(kind = Kind.HELPER)
	public String getAnchorId(List<String> polygon, List<String> transform, List<String> port) {

		// int[] topLeft = new int[] { Integer.parseInt(polygon.get(1)), Integer.parseInt(polygon.get(2)) };

		int[] topLeft = new int[] { Integer.parseInt(polygon.get(M_POLYGON__RECTANGLE_TOP_LEFT_CORNER_X_INDEX)), Integer.parseInt(polygon.get(M_POLYGON__RECTANGLE_TOP_LEFT_CORNER_Y_INDEX)) };
		int[] topRight = new int[] { Integer.parseInt(polygon.get(M_POLYGON__RECTANGLE_TOP_RIGHT_CORNER_X_INDEX)), Integer.parseInt(polygon.get(M_POLYGON__RECTANGLE_TOP_RIGHT_CORNER_Y_INDEX)) };
		int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(M_POLYGON__RECTANGLE_BOTTOM_LEFT_CORNER_X_INDEX)), Integer.parseInt(polygon.get(M_POLYGON__RECTANGLE_BOTTOM_LEFT_CORNER_Y_INDEX)) };

		int xPort = Integer.parseInt(port.get(0));
		if (xPort < topLeft[X_INDEX]) {
			xPort = topLeft[X_INDEX];
		}
		if (xPort > topRight[X_INDEX]) {
			xPort = topRight[X_INDEX];
		}

		int yPort = Integer.parseInt(port.get(1));
		if (yPort < topLeft[Y_INDEX]) {
			yPort = topLeft[Y_INDEX];
		}
		if (yPort > bottomLeft[Y_INDEX]) {
			yPort = bottomLeft[Y_INDEX];
		}

		float newxRatio = new Float(xPort) / new Float(getRelativeWidth(topRight[0], topLeft[0]));
		float newyRatio = new Float(yPort) / new Float(getRelativeHeight(bottomLeft[1], topLeft[1]));

		if (newxRatio > 1) {
			newxRatio = 1;
		}
		if (newyRatio > 1) {
			newyRatio = 1;
		}

		String id = "(" + newxRatio + "," + newyRatio + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

		return id;

	}

	public static int getRelativeHeight(int a, int b) {
		return (a - b);
	}

	public static int getRelativeWidth(int a, int b) {
		return (a - b);
	}

	/**
	 * 
	 * @param polygon
	 * @param transform
	 * @return
	 * 
	 * @deprecated since 0.7
	 */
	@Deprecated
	@Operation(kind = Kind.HELPER)
	public int getStateHeight(List<String> polygon, List<String> transform) {

		// State Partition (top left, top right, bottom right, bottom left) not
		// same for classes
		int[] topLeft = new int[] { Integer.parseInt(polygon.get(1)), Integer.parseInt(polygon.get(2)) };
		int[] topRight = new int[] { Integer.parseInt(polygon.get(3)), Integer.parseInt(polygon.get(4)) };
		int[] bottomRight = new int[] { Integer.parseInt(polygon.get(5)), Integer.parseInt(polygon.get(6)) };
		int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(7)), Integer.parseInt(polygon.get(8)) };
		float xRatio = Float.parseFloat(transform.get(0));
		float yRatio = Float.parseFloat(transform.get(3));
		return Math.round(yRatio * (bottomLeft[1] - topLeft[1]));
	}

	/**
	 * 
	 * @param polygon
	 * @param transform
	 * @return
	 * 
	 * @deprecated since 0.7
	 */
	@Deprecated
	@Operation(kind = Kind.HELPER)
	public int getStateWidth(List<String> polygon, List<String> transform) {
		int[] topLeft = new int[] { Integer.parseInt(polygon.get(1)), Integer.parseInt(polygon.get(2)) };
		int[] topRight = new int[] { Integer.parseInt(polygon.get(3)), Integer.parseInt(polygon.get(4)) };
		int[] bottomRight = new int[] { Integer.parseInt(polygon.get(5)), Integer.parseInt(polygon.get(6)) };
		int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(7)), Integer.parseInt(polygon.get(8)) };
		float xRatio = Float.parseFloat(transform.get(0));
		float yRatio = Float.parseFloat(transform.get(3));
		return Math.round(xRatio * (topRight[0] - topLeft[0]));
	}

	/**
	 * 
	 * @param polygon
	 * @param transform
	 * @return
	 * 
	 * @deprecated since 0.7
	 */
	@Deprecated
	@Operation(kind = Kind.HELPER)
	public int getClassHeight(List<String> polygon, List<String> transform) {

		// State Partition (top left, top right, bottom right, bottom left) not
		// same for classes
		int[] topLeft = new int[] { Integer.parseInt(polygon.get(1)), Integer.parseInt(polygon.get(2)) };
		int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(3)), Integer.parseInt(polygon.get(4)) };
		int[] bottomRight = new int[] { Integer.parseInt(polygon.get(5)), Integer.parseInt(polygon.get(6)) };
		int[] topRight = new int[] { Integer.parseInt(polygon.get(7)), Integer.parseInt(polygon.get(8)) };
		float xRatio = Float.parseFloat(transform.get(0));
		float yRatio = Float.parseFloat(transform.get(3));
		return Math.round(yRatio * (bottomLeft[1] - topLeft[1]));
	}

	@Operation(kind = Kind.HELPER)
	public int getClassWidth(List<String> polygon, List<String> transform) {
		int[] topLeft = new int[] { Integer.parseInt(polygon.get(1)), Integer.parseInt(polygon.get(2)) };
		int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(3)), Integer.parseInt(polygon.get(4)) };
		int[] bottomRight = new int[] { Integer.parseInt(polygon.get(5)), Integer.parseInt(polygon.get(6)) };
		int[] topRight = new int[] { Integer.parseInt(polygon.get(7)), Integer.parseInt(polygon.get(8)) };
		float xRatio = Float.parseFloat(transform.get(0));
		float yRatio = Float.parseFloat(transform.get(3));
		return Math.round(xRatio * (topRight[0] - topLeft[0]));
	}


	/**
	 * 
	 * @param m_polygon
	 *            the field polygon
	 * @param m_transform
	 *            the field transform
	 * @return the width of the object
	 * @deprecated since 0.7. use others method instead
	 */
	@Deprecated
	public int getWidth(List<String> m_polygon, List<String> m_transform) {
		int[] topLeft = new int[] { Integer.parseInt(m_polygon.get(1)), Integer.parseInt(m_polygon.get(2)) };
		// int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(3)), Integer.parseInt(polygon.get(4)) };
		// int[] bottomRight = new int[] { Integer.parseInt(polygon.get(5)), Integer.parseInt(polygon.get(6)) };
		int[] topRight = new int[] { Integer.parseInt(m_polygon.get(7)), Integer.parseInt(m_polygon.get(8)) };
		float xRatio = Float.parseFloat(m_transform.get(0));
		// float yRatio = Float.parseFloat(transform.get(3));
		return Math.round(xRatio * (topRight[0] - topLeft[0]));
	}

	/**
	 * 
	 * @param polygon
	 *            the field polygon
	 * @param transform
	 *            the field transform
	 * @return the height of the object
	 * @deprecated since 0.7. use others method instead
	 */
	@Deprecated
	public int getHeight(List<String> polygon, List<String> transform) {
		int[] topLeft = new int[] { Integer.parseInt(polygon.get(1)), Integer.parseInt(polygon.get(2)) };
		int[] bottomLeft = new int[] { Integer.parseInt(polygon.get(3)), Integer.parseInt(polygon.get(4)) };
		// int[] bottomRight = new int[] { Integer.parseInt(polygon.get(5)), Integer.parseInt(polygon.get(6)) };
		// int[] topRight = new int[] { Integer.parseInt(polygon.get(7)), Integer.parseInt(polygon.get(8)) };
		// float xRatio = Float.parseFloat(transform.get(0));
		float yRatio = Float.parseFloat(transform.get(3));
		return Math.round(yRatio * (bottomLeft[1] - topLeft[1]));
	}


	/**
	 * 
	 * @param element
	 *            a graphical element
	 * @return
	 * 		the X ratio to apply on the object to get its width
	 */
	@Operation(kind = Kind.HELPER)
	public float get_X_Ratio(GraphElementsType element) {
		float result = 1;
		final List<String> mTransform = getTransformList(element);
		if (null != mTransform && mTransform.size() == M_TRANSFORM_SIZE) {
			result = Float.parseFloat(mTransform.get(M_TRANSFORM_X_RATIO_INDEX));
			final GraphElementsType parent = getParent(element);
			if (!(parent instanceof CGIDiagramFrame)) {
				result = result * get_X_Ratio(parent);
			}
		}
		return result;
	}

	/**
	 * 
	 * @param element
	 *            a graphical element
	 * @return
	 * 		the X ratio to apply on the object to get its height
	 */
	@Operation(kind = Kind.HELPER)
	public float get_Y_Ratio(final GraphElementsType element) {
		float result = 1;
		final List<String> mTransform = getTransformList(element);
		if (null != mTransform && mTransform.size() == M_TRANSFORM_SIZE) {
			result = Float.parseFloat(mTransform.get(M_TRANSFORM_Y_RATIO_INDEX));
			final GraphElementsType parent = getParent(element);
			if (!(parent instanceof CGIDiagramFrame)) {
				result = result * get_Y_Ratio(parent);
			}
		}
		return result;
	}

	/**
	 * 
	 * @param element
	 *            a graphical element
	 * @return
	 * 		the value of the m_pParent field if it exits for the given object or <code>null</code> in other case
	 */
	private final GraphElementsType getParent(final GraphElementsType element) {
		final EStructuralFeature paretnFeature = element.eClass().getEStructuralFeature("m_pParent"); //$NON-NLS-1$
		if (null != paretnFeature) {
			Object value = element.eGet(paretnFeature);
			if (value instanceof GraphElementsType) {
				return (GraphElementsType) value;
			}
		}
		return null;
	}

	/**
	 * 
	 * @param element
	 *            a graphical element
	 * @return
	 * 		the value of the m_Transform field if it exits for the given object or <code>null</code> in other case
	 */
	@SuppressWarnings("unchecked")
	protected final List<String> getTransformList(final GraphElementsType element) {
		List<String> returnedValues = new ArrayList<String>();
		final EStructuralFeature mTransformFeature = element.eClass().getEStructuralFeature(M_TRANSFORM);
		if (null != mTransformFeature) {
			final Object mTransformValue = element.eGet(mTransformFeature);
			if (mTransformValue instanceof List<?>) {
				returnedValues.addAll((List<String>) mTransformValue);
			}
		}

		// We can consider number in e as 0;
		List<String> toReturn = new ArrayList<String>();
		if (returnedValues.size() != 6) {
			for (int i = 0; i < returnedValues.size(); i++) {
				String tmp = returnedValues.get(i);
				if (tmp.startsWith("e")) {
					continue;
				}
				if (!tmp.startsWith("e") && returnedValues.size() > (i + 1)) {
					String tmp2 = returnedValues.get(i + 1);
					if (tmp2.startsWith("e")) {
						tmp += tmp2;
					}
				}
				toReturn.add(tmp);
			}
			returnedValues = toReturn;
		}
		for (int i = 0; i < returnedValues.size(); i++) {
			String tmp = returnedValues.get(i);
			if (tmp.contains("e-")) {
				returnedValues.set(i, "0");
			}
		}

		return returnedValues;
	}

	/**
	 * 
	 * @param element
	 *            a graphical element
	 * @return
	 * 		the value of the m_Polygon field if it exits for the given object or <code>null</code> in other case
	 */
	@SuppressWarnings("unchecked")
	protected final List<String> getPolygonList(GraphElementsType element) {
		final EStructuralFeature mPolygonFeature = element.eClass().getEStructuralFeature(M_POLYGON);
		if (null != mPolygonFeature) {
			final Object mPolygonValue = element.eGet(mPolygonFeature);
			if (mPolygonValue instanceof List<?>) {
				return (List<String>) mPolygonValue;
			}
		}
		final EStructuralFeature mPositionlygonFeature = element.eClass().getEStructuralFeature("m_position");
		if (null != mPolygonFeature) {
			final Object mPolygonValue = element.eGet(mPolygonFeature);
			if (mPolygonValue instanceof List<?>) {
				return (List<String>) mPolygonValue;
			}
		}
		return null;
	}

	@Operation(kind = Kind.HELPER)
	public int getRectangleWidth(final GraphElementsType element) {
		RpyShape shape = RpyShapeOperations.createRpyShape(element);
		return shape.getWidth();
	}

	@Operation(kind = Kind.HELPER)
	public int getRectangleHeight(final GraphElementsType element) {
		RpyShape shape = RpyShapeOperations.createRpyShape(element);
		return shape.getHeight();
	}

	@Operation(kind = Kind.HELPER)
	public int getX(final GraphElementsType element) {
		RpyShape shape = RpyShapeOperations.createRpyShape(element);
		return shape.getParentRelativePosition().getIntX();
	}


	@Operation(kind = Kind.HELPER)
	public int getY(final GraphElementsType element) {
		RpyShape shape = RpyShapeOperations.createRpyShape(element);
		return shape.getParentRelativePosition().getIntY();
	}

	// TODO : move me into an upper plugin
	/**
	 * 
	 * @param aString
	 *            a string
	 * @return the parsed result of the string or {@link Integer#MAX_VALUE} if a problem occurred
	 */
	protected final int stringToInteger(final String aString) {
		int result = Integer.MAX_VALUE;
		if (aString.contains(".")) { //$NON-NLS-1$
			result = Float.valueOf(Float.parseFloat(aString)).intValue();
		} else {
			result = Integer.parseInt(aString);
		}
		return result;
	}
}