"""

  This module houses the Geometry Collection objects:

  GeometryCollection, MultiPoint, MultiLineString, and MultiPolygon

 """

 from ctypes import c_int, c_uint, byref

 from django.contrib.gis.geos.error import GEOSException, GEOSIndexError

 from django.contrib.gis.geos.geometry import GEOSGeometry

 from django.contrib.gis.geos.libgeos import get_pointer_arr, GEOM_PTR, GEOS_PREPARE

 from django.contrib.gis.geos.linestring import LineString, LinearRing

 from django.contrib.gis.geos.point import Point

 from django.contrib.gis.geos.polygon import Polygon

 from django.contrib.gis.geos import prototypes as capi

 class GeometryCollection(GEOSGeometry):

     _typeid = 7

     _minlength = 1

     def __init__(self, *args, **kwargs):

         "Initializes a Geometry Collection from a sequence of Geometry objects."

         # Checking the arguments

         if not args:

             raise TypeError, 'Must provide at least one Geometry to initialize %s.' % self.__class__.__name__

         if len(args) == 1:

             # If only one geometry provided or a list of geometries is provided

             #  in the first argument.

             if isinstance(args[0], (tuple, list)):

                 init_geoms = args[0]

             else:

                 init_geoms = args

         else:

             init_geoms = args

         # Ensuring that only the permitted geometries are allowed in this collection

         # this is moved to list mixin super class

         self._check_allowed(init_geoms)

         # Creating the geometry pointer array.

         collection = self._create_collection(len(init_geoms), iter(init_geoms))

         super(GeometryCollection, self).__init__(collection, **kwargs)

     def __iter__(self):

         "Iterates over each Geometry in the Collection."

         for i in xrange(len(self)):

             yield self[i]

     def __len__(self):

         "Returns the number of geometries in this Collection."

         return self.num_geom

     ### Methods for compatibility with ListMixin ###

     @classmethod

     def _create_collection(cls, length, items):

         # Creating the geometry pointer array.

         geoms = get_pointer_arr(length)

         for i, g in enumerate(items):

             # this is a little sloppy, but makes life easier

             # allow GEOSGeometry types (python wrappers) or pointer types

             geoms[i] = capi.geom_clone(getattr(g, 'ptr', g))

         return capi.create_collection(c_int(cls._typeid), byref(geoms), c_uint(length))

     def _getitem_internal(self, index):

         return capi.get_geomn(self.ptr, index)

     def _getitem_external(self, index):

         "Returns the Geometry from this Collection at the given index (0-based)."

         # Checking the index and returning the corresponding GEOS geometry.

         return GEOSGeometry(capi.geom_clone(self._getitem_internal(index)), srid=self.srid)

     def _set_collection(self, length, items):

         "Create a new collection, and destroy the contents of the previous pointer."

         prev_ptr = self.ptr

         srid = self.srid

         self.ptr = self._create_collection(length, items)

         if srid: self.srid = srid

         capi.destroy_geom(prev_ptr)

     # Because GeometryCollections need to be rebuilt upon the changing of a

     # component geometry, these routines are set to their counterparts that

     # rebuild the entire geometry.

     _set_single = GEOSGeometry._set_single_rebuild

     _assign_extended_slice = GEOSGeometry._assign_extended_slice_rebuild

     @property

     def kml(self):

         "Returns the KML for this Geometry Collection."

         return '<MultiGeometry>%s</MultiGeometry>' % ''.join([g.kml for g in self])

     @property

     def tuple(self):

         "Returns a tuple of all the coordinates in this Geometry Collection"

         return tuple([g.tuple for g in self])

     coords = tuple

 # MultiPoint, MultiLineString, and MultiPolygon class definitions.

 class MultiPoint(GeometryCollection):

     _allowed = Point

     _typeid = 4

 class MultiLineString(GeometryCollection):

     _allowed = (LineString, LinearRing)

     _typeid = 5

     @property

     def merged(self):

         """ 

         Returns a LineString representing the line merge of this 

         MultiLineString.

         """ 

         return self._topology(capi.geos_linemerge(self.ptr))         

 class MultiPolygon(GeometryCollection):

     _allowed = Polygon

     _typeid = 6

     @property

     def cascaded_union(self):

         "Returns a cascaded union of this MultiPolygon."

         if GEOS_PREPARE:

             return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid)

         else:

             raise GEOSException('The cascaded union operation requires GEOS 3.1+.')

 # Setting the allowed types here since GeometryCollection is defined before

 # its subclasses.

 GeometryCollection._allowed = (Point, LineString, LinearRing, Polygon, MultiPoint, MultiLineString, MultiPolygon)