from ctypes import c_void_p

from types import NoneType

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

# Trying to import GDAL libraries, if available.  Have to place in

# try/except since this package may be used outside GeoDjango.

try:

    from django.contrib.gis import gdal

except ImportError:

    # A 'dummy' gdal module.

    class GDALInfo(object):

        HAS_GDAL = False

        GEOJSON = False

    gdal = GDALInfo()

# NumPy supported?

try:

    import numpy

except ImportError:

    numpy = False

class GEOSBase(object):

    """

    Base object for GEOS objects that has a pointer access property

    that controls access to the underlying C pointer.

    """

    # Initially the pointer is NULL.

    _ptr = None

    # Default allowed pointer type.

    ptr_type = c_void_p

    # Pointer access property.

    def _get_ptr(self):

        # Raise an exception if the pointer isn't valid don't

        # want to be passing NULL pointers to routines --

        # that's very bad.

        if self._ptr: return self._ptr

        else: raise GEOSException('NULL GEOS %s pointer encountered.' % self.__class__.__name__)

    def _set_ptr(self, ptr):

        # Only allow the pointer to be set with pointers of the

        # compatible type or None (NULL).

        if isinstance(ptr, int):

            self._ptr = self.ptr_type(ptr)

        elif isinstance(ptr, (self.ptr_type, NoneType)):

            self._ptr = ptr

        else:

            raise TypeError('Incompatible pointer type')

    # Property for controlling access to the GEOS object pointers.  Using

    # this raises an exception when the pointer is NULL, thus preventing

    # the C library from attempting to access an invalid memory location.

    ptr = property(_get_ptr, _set_ptr)

class ListMixin(object):

    _canSetSingle = False

    def _setSingle_rebuild(self, index, value):

        self._checkindex(index)

        self._setSlice(slice(index, index + 1, 1), [value])        

    _setSingle = _setSingle_rebuild

    def _checkindex(self, index):

        if index < 0 or index >= len(self):

            raise GEOSIndexError('invalid index: %s' % str(index))

    def _checkAllowedTypes(self, items):

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

        if hasattr(self, '_allowed'):

            if False in [isinstance(geom, self._allowed) for geom in items]:

                raise TypeError('Invalid Geometry type encountered in the arguments.')

    def __getitem__(self, index):

        "Gets the coordinates of the point(s) at the specified index/slice."

        if isinstance(index, slice):

            return [self._getItemExternal(i) for i in xrange(*index.indices(len(self)))]

        else:

            if index < 0:

                index += len(self)

            return self._getItemExternal(index)

    def __delitem__(self, index):

        "Delete the point(s) at the specified index/slice."

        if not isinstance(index, (int, long, slice)):

            raise TypeError("%s is not a legal index" % index)

        # calculate new length and dimensions

        origLen     = len(self)

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

            if index < 0: index += origLen

            if not 0 <= index < origLen:

                raise GEOSIndexError('invalid index: %d' % index)

            indexRange  = [index]

        else:

            indexRange  = range(*index.indices(origLen))

        newLen      = origLen - len(indexRange)

        newItems    = ( self._getItemInternal(i)

                        for i in xrange(origLen)

                        if i not in indexRange )

        self._setCollection(newLen, newItems)

    def __setitem__(self, index, geom):

        "Sets the Geometry at the specified index."

        if isinstance(index, slice):

            self._setSlice(index, geom)

        else:

            if index < 0: index += len(self)

            self._setSingle(index, geom)

    def _setSlice(self, index, values):

        "Assign values to a slice of the object"

        try:

            iter(values)

        except TypeError:

            raise TypeError('can only assign an iterable to a slice')

        self._checkAllowedTypes(values)

        origLen     = len(self)

        valueList   = list(values)

        start, stop, step = index.indices(origLen)

        stop = max(0, stop) # stop will be -1 if out-of-bounds

                            # negative index is given

        # CAREFUL: index.step and step are not the same!

        # step will never be None

        #

        if index.step is None:

            self._assignSimpleSlice(start, stop, valueList)

        else:

            self._assignExtendedSlice(start, stop, step, valueList)

    def _assignExtendedSlice(self, start, stop, step, valueList):

        'Assign an extended slice by rebuilding entire list'

        indexList   = range(start, stop, step)

        # extended slice, only allow assigning slice of same size

        if len(valueList) != len(indexList):

            raise ValueError('attempt to assign sequence of size %d '

                             'to extended slice of size %d'

                             % (len(valueList), len(indexList)))

        # we're not changing the length of the sequence

        newLen  = len(self)

        newVals = dict(zip(indexList, valueList))

        def newItems():

            for i in xrange(newLen):

                if i in newVals:

                    yield newVals[i]

                else:

                    yield self._getItemInternal(i)

        self._setCollection(newLen, newItems())

    def _assignExtendedSlice_no_rebuild(self, start, stop, step, valueList):

        'Assign an extended slice by re-assigning individual items'

        indexList   = range(start, stop, step)

        # extended slice, only allow assigning slice of same size

        if len(valueList) != len(indexList):

            raise ValueError('attempt to assign sequence of size %d '

                             'to extended slice of size %d'

                             % (len(valueList), len(indexList)))

        for i, val in zip(indexList, valueList):

            self._setSingle(i, val)

    def _assignSimpleSlice(self, start, stop, valueList):

        'Assign a simple slice; Can assign slice of any length'

        origLen = len(self)

        newLen  = origLen - stop + start + len(valueList)

        def newItems():

            for i in xrange(origLen + 1):

                if i == start:

                    for val in valueList:

                        yield val

                if i < origLen:

                    if i < start or i >= stop:

                        yield self._getItemInternal(i)

        self._setCollection(newLen, newItems())

    def append(self, val):

        "Standard list append method"

        self[len(self):] = [val]

    def extend(self, vals):

        "Standard list extend method"

        self[len(self):] = vals

    def insert(self, index, val):

        "Standard list insert method"

        if not isinstance(index, (int, long)):

            raise TypeError("%s is not a legal index" % index)

        self[index:index] = [val]

    def pop(self, index=-1):

        "Standard list pop method"

        result = self[index]

        del self[index]

        return result

    def index(self, val):

        "Standard list index method"

        for i in xrange(0, len(self)):

            if self[i] == val: return i

        raise ValueError('%s not in geometry' % str(val))

    def remove(self, val):

        "Standard list remove method"

        del self[self.index(val)]

    def count(self):

        "Standard list count method"

        return len(self)