/*
 *    GeoTools - The Open Source Java GIS Toolkit
 *    http://geotools.org
 *    
 *    (C) 2001-2006  Vivid Solutions
 *    (C) 2001-2008, Open Source Geospatial Foundation (OSGeo)
 *    
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library is 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
 *    Lesser General Public License for more details.
 */
package org.geotools.geometry.iso.util.algorithm2D;

import java.util.Iterator;
import java.util.List;

import org.geotools.geometry.iso.primitive.RingImpl;
import org.geotools.geometry.iso.primitive.RingImplUnsafe;
import org.geotools.geometry.iso.primitive.SurfaceImpl;
import org.geotools.geometry.iso.root.GeometryImpl;
import org.geotools.geometry.iso.topograph2D.Coordinate;
import org.geotools.geometry.iso.topograph2D.Location;
import org.geotools.geometry.iso.topograph2D.util.CoordinateArrays;
import org.opengis.geometry.Geometry;
import org.opengis.geometry.aggregate.MultiPrimitive;
import org.opengis.geometry.primitive.Ring;

/**
 * Computes whether a point lies in the interior of an area {@link Geometry}.
 * The algorithm used is only guaranteed to return correct results for points
 * which are <b>not</b> on the boundary of the Geometry.
 *
 *
 *
 * @source $URL$
 */
public class SimplePointInAreaLocator {

	/**
	 * locate is the main location function. It handles both single-element and
	 * multi-element Geometries. The algorithm for multi-element Geometries is
	 * more complex, since it has to take into account the boundaryDetermination
	 * rule
	 * 
	 * @param p
	 * @param geom
	 * @return
	 */
	public static int locate(Coordinate p, GeometryImpl geom) {
		// TODO auskommentiert; checken!
		// if (geom.isEmpty())
		// return Location.EXTERIOR;

		if (containsPoint(p, geom))
			return Location.INTERIOR;
		return Location.EXTERIOR;
	}

	private static boolean containsPoint(Coordinate p, GeometryImpl geom) {

		if (geom instanceof SurfaceImpl) {
			return containsPointInPolygon(p, (SurfaceImpl) geom);
		}
		else if (geom instanceof MultiPrimitive) {
			Iterator geomi = ((MultiPrimitive) geom).getElements().iterator();
			while (geomi.hasNext()) {
				GeometryImpl g2 = (GeometryImpl) geomi.next();
				if (g2 != geom)
					if (containsPoint(p, g2))
						return true;
			}
		}
		return false;

		// OLD CODE:
		// if (geom instanceof Polygon) {
		// return containsPointInPolygon(p, (Polygon) geom);
		// } else if (geom instanceof GeometryCollection) {
		// Iterator geomi = new GeometryCollectionIterator(
		// (GeometryCollection) geom);
		// while (geomi.hasNext()) {
		// Geometry g2 = (Geometry) geomi.next();
		// if (g2 != geom)
		// if (containsPoint(p, g2))
		// return true;
		// }
		// }
		// return false;

	}

	public static boolean containsPointInPolygon(Coordinate p,
			SurfaceImpl aSurface) {

		// TODO auskommentiert; checken!
		// if (poly.isEmpty())
		// return false;

		List<Ring> rings = aSurface.getBoundaryRings();
		Ring shell = rings.get(0);

		// The point lies in the ring defined by the coordinatearray
		// representation of the exterior ring?
		// if not, return false
		if (!CGAlgorithms.isPointInRing(p, CoordinateArrays
				.toCoordinateArray(((RingImplUnsafe)shell).asDirectPositions()))) {
			return false;
		}

		// The point lies in the ring defined by the coordinatearray
		// representation of the exterior ring?
		for (int i = 1; i < rings.size(); i++) {
			RingImplUnsafe hole = (RingImplUnsafe) rings.get(i);
			// if so, return false
			if (CGAlgorithms.isPointInRing(p, CoordinateArrays
					.toCoordinateArray(hole.asDirectPositions()))) {
				return false;
			}
		}

		// the point lies inside the exterior ring, and outside the holes, so
		// its on the polygon
		return true;

		// OLD CODE:
		// if (poly.isEmpty())
		// return false;
		// LinearRing shell = (LinearRing) poly.getExteriorRing();
		// if (!CGAlgorithms.isPointInRing(p, shell.getCoordinates()))
		// return false;
		// // now test if the point lies in or on the holes
		// for (int i = 0; i < poly.getNumInteriorRing(); i++) {
		// LinearRing hole = (LinearRing) poly.getInteriorRingN(i);
		// if (CGAlgorithms.isPointInRing(p, hole.getCoordinates()))
		// return false;
		// }
		// return true;

	}

}