"""

 The OGRGeometry is a wrapper for using the OGR Geometry class

 (see http://www.gdal.org/ogr/classOGRGeometry.html).  OGRGeometry

 may be instantiated when reading geometries from OGR Data Sources

 (e.g. SHP files), or when given OGC WKT (a string).

 While the 'full' API is not present yet, the API is "pythonic" unlike

 the traditional and "next-generation" OGR Python bindings.  One major

 advantage OGR Geometries have over their GEOS counterparts is support

 for spatial reference systems and their transformation.

 Example:

  >>> from django.contrib.gis.gdal import OGRGeometry, OGRGeomType, SpatialReference

  >>> wkt1, wkt2 = 'POINT(-90 30)', 'POLYGON((0 0, 5 0, 5 5, 0 5)'

  >>> pnt = OGRGeometry(wkt1)

  >>> print pnt

  POINT (-90 30)

  >>> mpnt = OGRGeometry(OGRGeomType('MultiPoint'), SpatialReference('WGS84'))

  >>> mpnt.add(wkt1)

  >>> mpnt.add(wkt1)

  >>> print mpnt

  MULTIPOINT (-90 30,-90 30)

  >>> print mpnt.srs.name

  WGS 84

  >>> print mpnt.srs.proj

  +proj=longlat +ellps=WGS84 +datum=WGS84 +no_defs

  >>> mpnt.transform_to(SpatialReference('NAD27'))

  >>> print mpnt.proj

  +proj=longlat +ellps=clrk66 +datum=NAD27 +no_defs

  >>> print mpnt

  MULTIPOINT (-89.999930378602485 29.999797886557641,-89.999930378602485 29.999797886557641)

  The OGRGeomType class is to make it easy to specify an OGR geometry type:

  >>> from django.contrib.gis.gdal import OGRGeomType

  >>> gt1 = OGRGeomType(3) # Using an integer for the type

  >>> gt2 = OGRGeomType('Polygon') # Using a string

  >>> gt3 = OGRGeomType('POLYGON') # It's case-insensitive

  >>> print gt1 == 3, gt1 == 'Polygon' # Equivalence works w/non-OGRGeomType objects

  True

"""

# Python library requisites.

from binascii import a2b_hex

from ctypes import byref, string_at, c_char_p, c_double, c_ubyte, c_void_p

# Getting GDAL prerequisites

from django.contrib.gis.gdal.base import GDALBase

from django.contrib.gis.gdal.envelope import Envelope, OGREnvelope

from django.contrib.gis.gdal.error import OGRException, OGRIndexError, SRSException

from django.contrib.gis.gdal.geomtype import OGRGeomType

from django.contrib.gis.gdal.srs import SpatialReference, CoordTransform

# Getting the ctypes prototype functions that interface w/the GDAL C library.

from django.contrib.gis.gdal.prototypes import geom as capi, srs as srs_api

# For more information, see the OGR C API source code:

#  http://www.gdal.org/ogr/ogr__api_8h.html

#

# The OGR_G_* routines are relevant here.

#### OGRGeometry Class ####

class OGRGeometry(GDALBase):

    "Generally encapsulates an OGR geometry."

    def __init__(self, geom_input, srs=None):

        "Initializes Geometry on either WKT or an OGR pointer as input."

        str_instance = isinstance(geom_input, basestring)

        # If HEX, unpack input to to a binary buffer.

        if str_instance and hex_regex.match(geom_input):

            geom_input = buffer(a2b_hex(geom_input.upper()))

            str_instance = False

        if str_instance:

            # Checking if unicode

            if isinstance(geom_input, unicode):

                # Encoding to ASCII, WKT or HEX doesn't need any more.

                geom_input = geom_input.encode('ascii')

            wkt_m = wkt_regex.match(geom_input)

            json_m = json_regex.match(geom_input)

            if wkt_m:

                if wkt_m.group('type').upper() == 'LINEARRING':

                    # OGR_G_CreateFromWkt doesn't work with LINEARRING WKT.

                    #  See http://trac.osgeo.org/gdal/ticket/1992.

                    g = capi.create_geom(OGRGeomType(wkt_m.group('type')).num)

                else:

            elif json_m:

                if GEOJSON:

                    g = capi.from_json(geom_input)

                else:

                    raise NotImplementedError('GeoJSON input only supported on GDAL 1.5+.')

            else:

                # Seeing if the input is a valid short-hand string

                # (e.g., 'Point', 'POLYGON').

                ogr_t = OGRGeomType(geom_input)

                g = capi.create_geom(OGRGeomType(geom_input).num)

        elif isinstance(geom_input, buffer):

            # WKB was passed in

            g = capi.from_wkb(str(geom_input), None, byref(c_void_p()), len(geom_input))

        elif isinstance(geom_input, OGRGeomType):

            # OGRGeomType was passed in, an empty geometry will be created.

            g = capi.create_geom(geom_input.num)

        elif isinstance(geom_input, self.ptr_type):

            # OGR pointer (c_void_p) was the input.

            g = geom_input

        else:

            raise OGRException('Invalid input type for OGR Geometry construction: %s' % type(geom_input))

        # Now checking the Geometry pointer before finishing initialization

        # by setting the pointer for the object.

        if not g:

            raise OGRException('Cannot create OGR Geometry from input: %s' % str(geom_input))

        self.ptr = g

        # Assigning the SpatialReference object to the geometry, if valid.

        if bool(srs): self.srs = srs

        # Setting the class depending upon the OGR Geometry Type

        self.__class__ = GEO_CLASSES[self.geom_type.num]

    @classmethod

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

        x0, y0, x1, y1 = bbox

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

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

    ### Geometry set-like operations ###

    # g = g1 | g2

    def __or__(self, other):

        "Returns the union of the two geometries."

        return self.union(other)

    # g = g1 & g2

    def __and__(self, other):

        "Returns the intersection of this Geometry and the other."

        return self.intersection(other)

    # g = g1 - g2

    def __sub__(self, other):

        "Return the difference this Geometry and the other."

        return self.difference(other)

    # g = g1 ^ g2

    def __xor__(self, other):

        "Return the symmetric difference of this Geometry and the other."

        return self.sym_difference(other)

    def __eq__(self, other):

        "Is this Geometry equal to the other?"

    def __ne__(self, other):

        "Tests for inequality."

    def __str__(self):

        "WKT is used for the string representation."

        return self.wkt

    #### Geometry Properties ####

    @property

    def dimension(self):

        "Returns 0 for points, 1 for lines, and 2 for surfaces."

        return capi.get_dims(self.ptr)

        "Returns the coordinate dimension of the Geometry."

    @property

    def geom_count(self):

        "The number of elements in this Geometry."

        return capi.get_geom_count(self.ptr)

    @property

    def point_count(self):

        "Returns the number of Points in this Geometry."

        return capi.get_point_count(self.ptr)

    @property

    def num_points(self):

        "Alias for `point_count` (same name method in GEOS API.)"

        return self.point_count

    @property

    def num_coords(self):

        "Alais for `point_count`."

        return self.point_count

    @property

    def geom_type(self):

        "Returns the Type for this Geometry."

    @property

    def geom_name(self):

        "Returns the Name of this Geometry."

        return capi.get_geom_name(self.ptr)

    @property

    def area(self):

        "Returns the area for a LinearRing, Polygon, or MultiPolygon; 0 otherwise."

        return capi.get_area(self.ptr)

    @property

    def envelope(self):

        "Returns the envelope for this Geometry."

        # TODO: Fix Envelope() for Point geometries.

        return Envelope(capi.get_envelope(self.ptr, byref(OGREnvelope())))

    @property

    def extent(self):

        "Returns the envelope as a 4-tuple, instead of as an Envelope object."

        return self.envelope.tuple

    #### SpatialReference-related Properties ####

    # The SRS property

    def _get_srs(self):

        "Returns the Spatial Reference for this Geometry."

        try:

            srs_ptr = capi.get_geom_srs(self.ptr)

            return SpatialReference(srs_api.clone_srs(srs_ptr))

        except SRSException:

            return None

    def _set_srs(self, srs):

        "Sets the SpatialReference for this geometry."

        if isinstance(srs, SpatialReference):

        elif isinstance(srs, (int, long, basestring)):

            sr = SpatialReference(srs)

        else:

            raise TypeError('Cannot assign spatial reference with object of type: %s' % type(srs))

        capi.assign_srs(self.ptr, srs_ptr)

    srs = property(_get_srs, _set_srs)

    # The SRID property

    def _get_srid(self):

        srs = self.srs

        if srs: return srs.srid

        return None

    def _set_srid(self, srid):

        if isinstance(srid, (int, long)):

            self.srs = srid

        else:

            raise TypeError('SRID must be set with an integer.')

    srid = property(_get_srid, _set_srid)

    #### Output Methods ####

    @property

    def geos(self):

        "Returns a GEOSGeometry object from this OGRGeometry."

        from django.contrib.gis.geos import GEOSGeometry

        return GEOSGeometry(self.wkb, self.srid)

    @property

    def gml(self):

        "Returns the GML representation of the Geometry."

        return capi.to_gml(self.ptr)

    @property

    def hex(self):

        "Returns the hexadecimal representation of the WKB (a string)."

        return str(self.wkb).encode('hex').upper()

        #return b2a_hex(self.wkb).upper()

    @property

    def json(self):

        """

        Returns the GeoJSON representation of this Geometry (requires

        GDAL 1.5+).

        """

            return capi.to_json(self.ptr)

        else:

            raise NotImplementedError('GeoJSON output only supported on GDAL 1.5+.')

    geojson = json

    @property

    def kml(self):

        "Returns the KML representation of the Geometry."

        if GEOJSON:

            return capi.to_kml(self.ptr, None)

        else:

            raise NotImplementedError('KML output only supported on GDAL 1.5+.')

    @property

    def wkb_size(self):

        "Returns the size of the WKB buffer."

        return capi.get_wkbsize(self.ptr)

    @property

    def wkb(self):

        "Returns the WKB representation of the Geometry."

        if sys.byteorder == 'little':

            byteorder = 1 # wkbNDR (from ogr_core.h)

        else:

            byteorder = 0 # wkbXDR

        sz = self.wkb_size

        # Creating the unsigned character buffer, and passing it in by reference.

        buf = (c_ubyte * sz)()

        wkb = capi.to_wkb(self.ptr, byteorder, byref(buf))

        # Returning a buffer of the string at the pointer.

        return buffer(string_at(buf, sz))

    @property

    def wkt(self):

        "Returns the WKT representation of the Geometry."

        return capi.to_wkt(self.ptr, byref(c_char_p()))

    #### Geometry Methods ####

    def clone(self):

        "Clones this OGR Geometry."

        return OGRGeometry(capi.clone_geom(self.ptr), self.srs)

    def close_rings(self):

        """

        If there are any rings within this geometry that have not been

        closed, this routine will do so by adding the starting point at the

        end.

        """

        # Closing the open rings.

        capi.geom_close_rings(self.ptr)

    def transform(self, coord_trans, clone=False):

        """

        Transforms this geometry to a different spatial reference system.

        May take a CoordTransform object, a SpatialReference object, string

        WKT or PROJ.4, and/or an integer SRID.  By default nothing is returned

        and the geometry is transformed in-place.  However, if the `clone`

        keyword is set, then a transformed clone of this geometry will be

        returned.

        """

        if clone:

            klone = self.clone()

            klone.transform(coord_trans)

            return klone