from ctypes import c_uint, byref

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

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

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

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

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

 class Polygon(GEOSGeometry):

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

         """

         Initializes on an exterior ring and a sequence of holes (both

         instances may be either LinearRing instances, or a tuple/list

         that may be constructed into a LinearRing).

         Examples of initialization, where shell, hole1, and hole2 are 

         valid LinearRing geometries:

         >>> poly = Polygon(shell, hole1, hole2)

         >>> poly = Polygon(shell, (hole1, hole2))

         Example where a tuple parameters are used:

         >>> poly = Polygon(((0, 0), (0, 10), (10, 10), (0, 10), (0, 0)), 

                            ((4, 4), (4, 6), (6, 6), (6, 4), (4, 4)))

         """

         if not args:

             raise TypeError('Must provide at least one LinearRing, or a tuple, to initialize a Polygon.')

         # Getting the ext_ring and init_holes parameters from the argument list

         ext_ring = args[0]

         init_holes = args[1:]

         n_holes = len(init_holes)

         # If initialized as Polygon(shell, (LinearRing, LinearRing)) [for backward-compatibility]

         if n_holes == 1 and isinstance(init_holes[0], (tuple, list)) and \

                 (len(init_holes[0]) == 0 or isinstance(init_holes[0][0], LinearRing)): 

             init_holes = init_holes[0]

             n_holes = len(init_holes)

         # Ensuring the exterior ring and holes parameters are LinearRing objects

         # or may be instantiated into LinearRings.

         ext_ring = self._construct_ring(ext_ring, 'Exterior parameter must be a LinearRing or an object that can initialize a LinearRing.')

         holes_list = [] # Create new list, cause init_holes is a tuple.

         for i in xrange(n_holes):

             holes_list.append(self._construct_ring(init_holes[i], 'Holes parameter must be a sequence of LinearRings or objects that can initialize to LinearRings'))

         # Why another loop?  Because if a TypeError is raised, cloned pointers will

         # be around that can't be cleaned up.

         holes = get_pointer_arr(n_holes)

         for i in xrange(n_holes): holes[i] = capi.geom_clone(holes_list[i].ptr)

         # Getting the shell pointer address.

         shell = capi.geom_clone(ext_ring.ptr)

         # Calling with the GEOS createPolygon factory.

         super(Polygon, self).__init__(capi.create_polygon(shell, byref(holes), c_uint(n_holes)), **kwargs)

     def __getitem__(self, index):

         """

         Returns the ring at the specified index.  The first index, 0, will 

         always return the exterior ring.  Indices > 0 will return the 

         interior ring at the given index (e.g., poly[1] and poly[2] would

         return the first and second interior ring, respectively).

         """

         if index == 0:

             return self.exterior_ring

         else:

             # Getting the interior ring, have to subtract 1 from the index.

             return self.get_interior_ring(index-1) 

     def __setitem__(self, index, ring):

         "Sets the ring at the specified index with the given ring."

         # Checking the index and ring parameters.

         self._checkindex(index)

         if not isinstance(ring, LinearRing):

             raise TypeError('must set Polygon index with a LinearRing object')

         # Getting the shell

         if index == 0:

             shell = capi.geom_clone(ring.ptr)

         else:

             shell = capi.geom_clone(capi.get_extring(self.ptr))

         # Getting the interior rings (holes)

         nholes = len(self)-1

         if nholes > 0:

             holes = get_pointer_arr(nholes)

             for i in xrange(nholes):

                 if i == (index-1):

                     holes[i] = capi.geom_clone(ring.ptr)

                 else:

                     holes[i] = capi.geom_clone(capi.get_intring(self.ptr, i))

             holes_param = byref(holes)

         else:

             holes_param = None

         # Getting the current pointer, replacing with the newly constructed

         # geometry, and destroying the old geometry.

         prev_ptr = self.ptr

         srid = self.srid

         self.ptr = capi.create_polygon(shell, holes_param, c_uint(nholes))

         if srid: self.srid = srid

         capi.destroy_geom(prev_ptr)

     def __iter__(self):

         "Iterates over each ring in the polygon."

         for i in xrange(len(self)):

             yield self[i]

     def __len__(self):

         "Returns the number of rings in this Polygon."

         return self.num_interior_rings + 1

     def _construct_ring(self, param, msg=''):

         "Helper routine for trying to construct a ring from the given parameter."

         if isinstance(param, LinearRing): return param

         try:

             ring = LinearRing(param)

             return ring

         except TypeError:

             raise TypeError(msg)

     @classmethod

     def from_bbox(cls, bbox):

         "Constructs a Polygon from a bounding box (4-tuple)."

         x0, y0, x1, y1 = bbox

         return GEOSGeometry( 'POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))' %  (

                 x0, y0, x0, y1, x1, y1, x1, y0, x0, y0) )

     def get_interior_ring(self, ring_i):

         """

         Gets the interior ring at the specified index, 0 is for the first 

         interior ring, not the exterior ring.

         """

         self._checkindex(ring_i+1)

         return GEOSGeometry(capi.geom_clone(capi.get_intring(self.ptr, ring_i)), srid=self.srid)

     #### Polygon Properties ####

     @property

     def num_interior_rings(self):

         "Returns the number of interior rings."

         # Getting the number of rings

         return capi.get_nrings(self.ptr)

     def get_ext_ring(self):

         "Gets the exterior ring of the Polygon."

         return GEOSGeometry(capi.geom_clone(capi.get_extring(self.ptr)), srid=self.srid)

     def set_ext_ring(self, ring):

         "Sets the exterior ring of the Polygon."

         self[0] = ring

     # properties for the exterior ring/shell

     exterior_ring = property(get_ext_ring, set_ext_ring)

     shell = exterior_ring

     @property

     def tuple(self):

         "Gets the tuple for each ring in this Polygon."

         return tuple([self[i].tuple for i in xrange(len(self))])

     coords = tuple

     @property

     def kml(self):

         "Returns the KML representation of this Polygon."

         inner_kml = ''.join(["<innerBoundaryIs>%s</innerBoundaryIs>" % self[i+1].kml 

                              for i in xrange(self.num_interior_rings)])

         return "<Polygon><outerBoundaryIs>%s</outerBoundaryIs>%s</Polygon>" % (self[0].kml, inner_kml)