"""

 This module contains the 'base' GEOSGeometry object -- all GEOS Geometries

 inherit from this object.

"""

# Python, ctypes and types dependencies.

import re

from ctypes import addressof, byref, c_double, c_size_t

# super-class for mutable list behavior

from django.contrib.gis.geos.mutable_list import ListMixin

# GEOS-related dependencies.

from django.contrib.gis.geos.base import GEOSBase, gdal

from django.contrib.gis.geos.coordseq import GEOSCoordSeq

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

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

from django.contrib.gis.geos.mutable_list import ListMixin

# All other functions in this module come from the ctypes

# prototypes module -- which handles all interaction with

# the underlying GEOS library.

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

class GEOSGeometry(GEOSBase, ListMixin):

    "A class that, generally, encapsulates a GEOS geometry."

    # Raise GEOSIndexError instead of plain IndexError

    # (see ticket #4740 and GEOSIndexError docstring)

    _IndexError = GEOSIndexError

    ptr_type = GEOM_PTR

    #### Python 'magic' routines ####

    def __init__(self, geo_input, srid=None):

        """

        The base constructor for GEOS geometry objects, and may take the

        following inputs:

         * strings:

            - WKT

            - HEXEWKB (a PostGIS-specific canonical form)

            - GeoJSON (requires GDAL)

         * buffer:

            - WKB

        The `srid` keyword is used to specify the Source Reference Identifier

        (SRID) number for this Geometry.  If not set, the SRID will be None.

        """

        if isinstance(geo_input, basestring):

            if isinstance(geo_input, unicode):

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

                geo_input = geo_input.encode('ascii')

            wkt_m = wkt_regex.match(geo_input)

            if wkt_m:

                # Handling WKT input.

                if wkt_m.group('srid'): srid = int(wkt_m.group('srid'))

            elif hex_regex.match(geo_input):

                # Handling HEXEWKB input.

                # Handling GeoJSON input.

            else:

                raise ValueError('String or unicode input unrecognized as WKT EWKT, and HEXEWKB.')

        elif isinstance(geo_input, GEOM_PTR):

            # When the input is a pointer to a geomtry (GEOM_PTR).

            g = geo_input

        elif isinstance(geo_input, buffer):

            # When the input is a buffer (WKB).

        elif isinstance(geo_input, GEOSGeometry):

            g = capi.geom_clone(geo_input.ptr)

        else:

            # Invalid geometry type.

            raise TypeError('Improper geometry input type: %s' % str(type(geo_input)))

        if bool(g):

            # Setting the pointer object with a valid pointer.

            self.ptr = g

        else:

            raise GEOSException('Could not initialize GEOS Geometry with given input.')

        # Post-initialization setup.

        self._post_init(srid)

    def _post_init(self, srid):

        "Helper routine for performing post-initialization setup."

        # Setting the SRID, if given.

        if srid and isinstance(srid, int): self.srid = srid

        # Setting the class type (e.g., Point, Polygon, etc.)

        self.__class__ = GEOS_CLASSES[self.geom_typeid]

        # Setting the coordinate sequence for the geometry (will be None on

        # geometries that do not have coordinate sequences)

        self._set_cs()

    def __del__(self):

        """

        Destroys this Geometry; in other words, frees the memory used by the

        GEOS C++ object.

        """

        if self._ptr: capi.destroy_geom(self._ptr)

    def __copy__(self):

        """

        Returns a clone because the copy of a GEOSGeometry may contain an

        invalid pointer location if the original is garbage collected.

        """

        return self.clone()

    def __deepcopy__(self, memodict):

        """

        The `deepcopy` routine is used by the `Node` class of django.utils.tree;

        thus, the protocol routine needs to be implemented to return correct

        copies (clones) of these GEOS objects, which use C pointers.

        """

        return self.clone()

    def __str__(self):

        "WKT is used for the string representation."

        return self.wkt

    def __repr__(self):

        "Short-hand representation because WKT may be very large."

        return '<%s object at %s>' % (self.geom_type, hex(addressof(self.ptr)))

    # Pickling support

    def __getstate__(self):

        # The pickled state is simply a tuple of the WKB (in string form)

        # and the SRID.

        return str(self.wkb), self.srid

    def __setstate__(self, state):

        # Instantiating from the tuple state that was pickled.

        wkb, srid = state

        if not ptr: raise GEOSException('Invalid Geometry loaded from pickled state.')

        self.ptr = ptr

        self._post_init(srid)

    # Comparison operators

    def __eq__(self, other):

        """

        Equivalence testing, a Geometry may be compared with another Geometry

        or a WKT representation.

        """

        if isinstance(other, basestring):

            return self.wkt == other

        elif isinstance(other, GEOSGeometry):

            return self.equals_exact(other)

        else:

            return False

    def __ne__(self, other):

        "The not equals operator."

        return not (self == other)

    ### Geometry set-like operations ###

    # Thanks to Sean Gillies for inspiration:

    #  http://lists.gispython.org/pipermail/community/2007-July/001034.html

    # g = g1 | g2

    def __or__(self, other):

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

        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)

    #### Coordinate Sequence Routines ####

    @property

    def has_cs(self):

        "Returns True if this Geometry has a coordinate sequence, False if not."

        # Only these geometries are allowed to have coordinate sequences.

        if isinstance(self, (Point, LineString, LinearRing)):

            return True

        else:

            return False

    def _set_cs(self):

        "Sets the coordinate sequence for this Geometry."

        if self.has_cs:

            self._cs = GEOSCoordSeq(capi.get_cs(self.ptr), self.hasz)

        else:

            self._cs = None

    @property

    def coord_seq(self):

        "Returns a clone of the coordinate sequence for this Geometry."

        if self.has_cs:

            return self._cs.clone()

    #### Geometry Info ####

    @property

    def geom_type(self):

        "Returns a string representing the Geometry type, e.g. 'Polygon'"

        return capi.geos_type(self.ptr)

    @property

    def geom_typeid(self):

        "Returns an integer representing the Geometry type."

        return capi.geos_typeid(self.ptr)

    @property

    def num_geom(self):

        "Returns the number of geometries in the Geometry."

        return capi.get_num_geoms(self.ptr)

    @property

    def num_coords(self):

        "Returns the number of coordinates in the Geometry."

        return capi.get_num_coords(self.ptr)

    @property

    def num_points(self):

        "Returns the number points, or coordinates, in the Geometry."

        return self.num_coords

    @property

    def dims(self):

        "Returns the dimension of this Geometry (0=point, 1=line, 2=surface)."

        return capi.get_dims(self.ptr)

    def normalize(self):

        "Converts this Geometry to normal form (or canonical form)."

        return capi.geos_normalize(self.ptr)

    #### Unary predicates ####

    @property

    def empty(self):

        """

        Returns a boolean indicating whether the set of points in this Geometry

        are empty.

        """

        return capi.geos_isempty(self.ptr)

    @property

    def hasz(self):

        "Returns whether the geometry has a 3D dimension."

        return capi.geos_hasz(self.ptr)

    @property

    def ring(self):

        "Returns whether or not the geometry is a ring."

        return capi.geos_isring(self.ptr)

    @property

    def simple(self):

        "Returns false if the Geometry not simple."

        return capi.geos_issimple(self.ptr)

    @property

    def valid(self):

        "This property tests the validity of this Geometry."

        return capi.geos_isvalid(self.ptr)

    #### Binary predicates. ####

    def contains(self, other):

        "Returns true if other.within(this) returns true."

        return capi.geos_contains(self.ptr, other.ptr)

    def crosses(self, other):

        """

        Returns true if the DE-9IM intersection matrix for the two Geometries

        is T*T****** (for a point and a curve,a point and an area or a line and

        an area) 0******** (for two curves).

        """

        return capi.geos_crosses(self.ptr, other.ptr)

    def disjoint(self, other):

        """

        Returns true if the DE-9IM intersection matrix for the two Geometries

        is FF*FF****.

        """

        return capi.geos_disjoint(self.ptr, other.ptr)

    def equals(self, other):

        """

        Returns true if the DE-9IM intersection matrix for the two Geometries

        is T*F**FFF*.

        """

        return capi.geos_equals(self.ptr, other.ptr)

    def equals_exact(self, other, tolerance=0):

        """

        Returns true if the two Geometries are exactly equal, up to a

        specified tolerance.

        """

        return capi.geos_equalsexact(self.ptr, other.ptr, float(tolerance))

    def intersects(self, other):

        "Returns true if disjoint returns false."

        return capi.geos_intersects(self.ptr, other.ptr)

    def overlaps(self, other):

        """

        Returns true if the DE-9IM intersection matrix for the two Geometries

        is T*T***T** (for two points or two surfaces) 1*T***T** (for two curves).

        """

        return capi.geos_overlaps(self.ptr, other.ptr)

    def relate_pattern(self, other, pattern):

        """

        Returns true if the elements in the DE-9IM intersection matrix for the

        two Geometries match the elements in pattern.

        """

        if not isinstance(pattern, basestring) or len(pattern) > 9:

            raise GEOSException('invalid intersection matrix pattern')

        return capi.geos_relatepattern(self.ptr, other.ptr, pattern)

    def touches(self, other):

        """

        Returns true if the DE-9IM intersection matrix for the two Geometries

        is FT*******, F**T***** or F***T****.

        """

        return capi.geos_touches(self.ptr, other.ptr)

    def within(self, other):

        """

        Returns true if the DE-9IM intersection matrix for the two Geometries

        is T*F**F***.

        """

        return capi.geos_within(self.ptr, other.ptr)

    #### SRID Routines ####

    def get_srid(self):

        "Gets the SRID for the geometry, returns None if no SRID is set."

        s = capi.geos_get_srid(self.ptr)

        if s == 0: return None

        else: return s

    def set_srid(self, srid):

        "Sets the SRID for the geometry."

        capi.geos_set_srid(self.ptr, srid)

    srid = property(get_srid, set_srid)

    #### Output Routines ####

    @property

    def ewkt(self):

        if self.get_srid(): return 'SRID=%s;%s' % (self.srid, self.wkt)

        else: return self.wkt

    @property

    def wkt(self):

    @property

    def hex(self):

        """

        """

        # A possible faster, all-python, implementation:

        #  str(self.wkb).encode('hex')

    @property

    def json(self):

        """

        Returns GeoJSON representation of this Geometry if GDAL 1.5+

        is installed.

        """

            return self.ogr.json

        else:

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

    geojson = json

    @property

    def wkb(self):