import ctypes, random, unittest, sys

from django.contrib.gis.geos import *

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

from django.contrib.gis.tests.geometries import *

class GEOSTest(unittest.TestCase):

    @property

    def null_srid(self):

        """

        Returns the proper null SRID depending on the GEOS version.

        See the comments in `test15_srid` for more details.

        """

        info = geos_version_info()

        if info['version'] == '3.0.0' and info['release_candidate']:

            return -1

        else:

            return None

    def test00_base(self):

        "Tests out the GEOSBase class."

        # Testing out GEOSBase class, which provides a `ptr` property

        # that abstracts out access to underlying C pointers.

        class FakeGeom1(GEOSBase):

            pass

        # This one only accepts pointers to floats

        c_float_p = ctypes.POINTER(ctypes.c_float)

        class FakeGeom2(GEOSBase):

            ptr_type = c_float_p

        # Default ptr_type is `c_void_p`.

        fg1 = FakeGeom1()

        # Default ptr_type is C float pointer

        fg2 = FakeGeom2()

        # These assignments are OK -- None is allowed because

        # it's equivalent to the NULL pointer.

        fg1.ptr = ctypes.c_void_p()

        fg1.ptr = None

        fg2.ptr = c_float_p(ctypes.c_float(5.23))

        fg2.ptr = None

        # Because pointers have been set to NULL, an exception should be

        # raised when we try to access it.  Raising an exception is

        # preferrable to a segmentation fault that commonly occurs when

        # a C method is given a NULL memory reference.

        for fg in (fg1, fg2):

            # Equivalent to `fg.ptr`

            self.assertRaises(GEOSException, fg._get_ptr)

        # Anything that is either not None or the acceptable pointer type will

        # result in a TypeError when trying to assign it to the `ptr` property.

        # Thus, memmory addresses (integers) and pointers of the incorrect type

        # (in `bad_ptrs`) will not be allowed.

        bad_ptrs = (5, ctypes.c_char_p('foobar'))

        for bad_ptr in bad_ptrs:

            # Equivalent to `fg.ptr = bad_ptr`

            self.assertRaises(TypeError, fg1._set_ptr, bad_ptr)

            self.assertRaises(TypeError, fg2._set_ptr, bad_ptr)

    def test01a_wkt(self):

        "Testing WKT output."

        for g in wkt_out:

            geom = fromstr(g.wkt)

            self.assertEqual(g.ewkt, geom.wkt)

    def test01b_hex(self):

        "Testing HEX output."

        for g in hex_wkt:

            geom = fromstr(g.wkt)

            self.assertEqual(g.hex, geom.hex)

    def test01c_kml(self):

        "Testing KML output."

        for tg in wkt_out:

            geom = fromstr(tg.wkt)

            kml = getattr(tg, 'kml', False)

            if kml: self.assertEqual(kml, geom.kml)

    def test01d_errors(self):

        "Testing the Error handlers."

        # string-based

        print "\nBEGIN - expecting GEOS_ERROR; safe to ignore.\n"

        for err in errors:

            try:

                g = fromstr(err.wkt)

            except (GEOSException, ValueError):

                pass

        # Bad WKB

        self.assertRaises(GEOSException, GEOSGeometry, buffer('0'))

        print "\nEND - expecting GEOS_ERROR; safe to ignore.\n"

        class NotAGeometry(object):

            pass

        # Some other object

        self.assertRaises(TypeError, GEOSGeometry, NotAGeometry())

        # None

        self.assertRaises(TypeError, GEOSGeometry, None)

    def test01e_wkb(self):

        "Testing WKB output."

        from binascii import b2a_hex

        for g in hex_wkt:

            geom = fromstr(g.wkt)

            wkb = geom.wkb

            self.assertEqual(b2a_hex(wkb).upper(), g.hex)

    def test01f_create_hex(self):

        "Testing creation from HEX."

        for g in hex_wkt:

            geom_h = GEOSGeometry(g.hex)

            # we need to do this so decimal places get normalised

            geom_t = fromstr(g.wkt)

            self.assertEqual(geom_t.wkt, geom_h.wkt)

    def test01g_create_wkb(self):

        "Testing creation from WKB."

        from binascii import a2b_hex

        for g in hex_wkt:

            wkb = buffer(a2b_hex(g.hex))

            geom_h = GEOSGeometry(wkb)

            # we need to do this so decimal places get normalised

            geom_t = fromstr(g.wkt)

            self.assertEqual(geom_t.wkt, geom_h.wkt)

    def test01h_ewkt(self):

        "Testing EWKT."

        srid = 32140

        for p in polygons:

            ewkt = 'SRID=%d;%s' % (srid, p.wkt)

            poly = fromstr(ewkt)

            self.assertEqual(srid, poly.srid)

            self.assertEqual(srid, poly.shell.srid)

            self.assertEqual(srid, fromstr(poly.ewkt).srid) # Checking export

    def test01i_json(self):

        "Testing GeoJSON input/output (via GDAL)."

        if not gdal or not gdal.GEOJSON: return

        for g in json_geoms:

            geom = GEOSGeometry(g.wkt)

            if not hasattr(g, 'not_equal'):

                self.assertEqual(g.json, geom.json)

                self.assertEqual(g.json, geom.geojson)

            self.assertEqual(GEOSGeometry(g.wkt), GEOSGeometry(geom.json))

    def test01k_fromfile(self):

        "Testing the fromfile() factory."

        from StringIO import StringIO

        ref_pnt = GEOSGeometry('POINT(5 23)')

        wkt_f = StringIO()

        wkt_f.write(ref_pnt.wkt)

        wkb_f = StringIO()

        wkb_f.write(str(ref_pnt.wkb))

        # Other tests use `fromfile()` on string filenames so those

        # aren't tested here.

        for fh in (wkt_f, wkb_f):

            fh.seek(0)

            pnt = fromfile(fh)

            self.assertEqual(ref_pnt, pnt)

    def test01k_eq(self):

        "Testing equivalence."

        p = fromstr('POINT(5 23)')

        self.assertEqual(p, p.wkt)

        self.assertNotEqual(p, 'foo')

        ls = fromstr('LINESTRING(0 0, 1 1, 5 5)')

        self.assertEqual(ls, ls.wkt)

        self.assertNotEqual(p, 'bar')

        # Error shouldn't be raise on equivalence testing with

        # an invalid type.

        for g in (p, ls):

            self.assertNotEqual(g, None)

            self.assertNotEqual(g, {'foo' : 'bar'})

            self.assertNotEqual(g, False)

    def test02a_points(self):

        "Testing Point objects."

        prev = fromstr('POINT(0 0)')

        for p in points:

            # Creating the point from the WKT

            pnt = fromstr(p.wkt)

            self.assertEqual(pnt.geom_type, 'Point')

            self.assertEqual(pnt.geom_typeid, 0)

            self.assertEqual(p.x, pnt.x)

            self.assertEqual(p.y, pnt.y)

            self.assertEqual(True, pnt == fromstr(p.wkt))

            self.assertEqual(False, pnt == prev)

            # Making sure that the point's X, Y components are what we expect

            self.assertAlmostEqual(p.x, pnt.tuple[0], 9)

            self.assertAlmostEqual(p.y, pnt.tuple[1], 9)

            # Testing the third dimension, and getting the tuple arguments

            if hasattr(p, 'z'):

                self.assertEqual(True, pnt.hasz)

                self.assertEqual(p.z, pnt.z)

                self.assertEqual(p.z, pnt.tuple[2], 9)

                tup_args = (p.x, p.y, p.z)

                set_tup1 = (2.71, 3.14, 5.23)

                set_tup2 = (5.23, 2.71, 3.14)

            else:

                self.assertEqual(False, pnt.hasz)

                self.assertEqual(None, pnt.z)

                tup_args = (p.x, p.y)

                set_tup1 = (2.71, 3.14)

                set_tup2 = (3.14, 2.71)

            # Centroid operation on point should be point itself

            self.assertEqual(p.centroid, pnt.centroid.tuple)

            # Now testing the different constructors

            pnt2 = Point(tup_args)  # e.g., Point((1, 2))

            pnt3 = Point(*tup_args) # e.g., Point(1, 2)

            self.assertEqual(True, pnt == pnt2)

            self.assertEqual(True, pnt == pnt3)

            # Now testing setting the x and y

            pnt.y = 3.14

            pnt.x = 2.71

            self.assertEqual(3.14, pnt.y)

            self.assertEqual(2.71, pnt.x)

            # Setting via the tuple/coords property

            pnt.tuple = set_tup1

            self.assertEqual(set_tup1, pnt.tuple)

            pnt.coords = set_tup2

            self.assertEqual(set_tup2, pnt.coords)

            prev = pnt # setting the previous geometry

    def test02b_multipoints(self):

        "Testing MultiPoint objects."

        for mp in multipoints:

            mpnt = fromstr(mp.wkt)

            self.assertEqual(mpnt.geom_type, 'MultiPoint')

            self.assertEqual(mpnt.geom_typeid, 4)

            self.assertAlmostEqual(mp.centroid[0], mpnt.centroid.tuple[0], 9)

            self.assertAlmostEqual(mp.centroid[1], mpnt.centroid.tuple[1], 9)

            self.assertRaises(GEOSIndexError, mpnt.__getitem__, len(mpnt))

            self.assertEqual(mp.centroid, mpnt.centroid.tuple)

            self.assertEqual(mp.points, tuple(m.tuple for m in mpnt))

            for p in mpnt:

                self.assertEqual(p.geom_type, 'Point')

                self.assertEqual(p.geom_typeid, 0)

                self.assertEqual(p.empty, False)

                self.assertEqual(p.valid, True)

    def test03a_linestring(self):

        "Testing LineString objects."

        prev = fromstr('POINT(0 0)')

        for l in linestrings:

            ls = fromstr(l.wkt)

            self.assertEqual(ls.geom_type, 'LineString')

            self.assertEqual(ls.geom_typeid, 1)

            self.assertEqual(ls.empty, False)

            self.assertEqual(ls.ring, False)

            if hasattr(l, 'centroid'):

                self.assertEqual(l.centroid, ls.centroid.tuple)

            if hasattr(l, 'tup'):

                self.assertEqual(l.tup, ls.tuple)

            self.assertEqual(True, ls == fromstr(l.wkt))

            self.assertEqual(False, ls == prev)

            self.assertRaises(GEOSIndexError, ls.__getitem__, len(ls))

            prev = ls

            # Creating a LineString from a tuple, list, and numpy array

            self.assertEqual(ls, LineString(ls.tuple))  # tuple

            self.assertEqual(ls, LineString(*ls.tuple)) # as individual arguments

            self.assertEqual(ls, LineString([list(tup) for tup in ls.tuple])) # as list

            self.assertEqual(ls.wkt, LineString(*tuple(Point(tup) for tup in ls.tuple)).wkt) # Point individual arguments

            if numpy: self.assertEqual(ls, LineString(numpy.array(ls.tuple))) # as numpy array

    def test03b_multilinestring(self):

        "Testing MultiLineString objects."

        prev = fromstr('POINT(0 0)')

        for l in multilinestrings:

            ml = fromstr(l.wkt)

            self.assertEqual(ml.geom_type, 'MultiLineString')

            self.assertEqual(ml.geom_typeid, 5)

            self.assertAlmostEqual(l.centroid[0], ml.centroid.x, 9)

            self.assertAlmostEqual(l.centroid[1], ml.centroid.y, 9)

            self.assertEqual(True, ml == fromstr(l.wkt))

            self.assertEqual(False, ml == prev)

            prev = ml

            for ls in ml:

                self.assertEqual(ls.geom_type, 'LineString')

                self.assertEqual(ls.geom_typeid, 1)

                self.assertEqual(ls.empty, False)

            self.assertRaises(GEOSIndexError, ml.__getitem__, len(ml))

            self.assertEqual(ml.wkt, MultiLineString(*tuple(s.clone() for s in ml)).wkt)

            self.assertEqual(ml, MultiLineString(*tuple(LineString(s.tuple) for s in ml)))

    def test04_linearring(self):

        "Testing LinearRing objects."

        for rr in linearrings:

            lr = fromstr(rr.wkt)

            self.assertEqual(lr.geom_type, 'LinearRing')

            self.assertEqual(lr.geom_typeid, 2)

            self.assertEqual(rr.n_p, len(lr))

            self.assertEqual(True, lr.valid)

            self.assertEqual(False, lr.empty)

            # Creating a LinearRing from a tuple, list, and numpy array

            self.assertEqual(lr, LinearRing(lr.tuple))

            self.assertEqual(lr, LinearRing(*lr.tuple))

            self.assertEqual(lr, LinearRing([list(tup) for tup in lr.tuple]))

            if numpy: self.assertEqual(lr, LinearRing(numpy.array(lr.tuple)))

    def test05a_polygons(self):

        "Testing Polygon objects."

        # Testing `from_bbox` class method

        bbox = (-180, -90, 180, 90)

        p = Polygon.from_bbox( bbox )

        self.assertEqual(bbox, p.extent)

        prev = fromstr('POINT(0 0)')

        for p in polygons:

            # Creating the Polygon, testing its properties.

            poly = fromstr(p.wkt)

            self.assertEqual(poly.geom_type, 'Polygon')

            self.assertEqual(poly.geom_typeid, 3)