import binascii

from django.contrib.gis.geos import (
    GEOSGeometry,
    Point,
    Polygon,
    WKBReader,
    WKBWriter,
    WKTReader,
    WKTWriter,
)
from django.contrib.gis.geos.libgeos import geos_version_tuple
from django.test import SimpleTestCase


class GEOSIOTest(SimpleTestCase):
    def test01_wktreader(self):
        # Creating a WKTReader instance
        wkt_r = WKTReader()
        wkt = "POINT (5 23)"

        # read() should return a GEOSGeometry
        ref = GEOSGeometry(wkt)
        g1 = wkt_r.read(wkt.encode())
        g2 = wkt_r.read(wkt)

        for geom in (g1, g2):
            with self.subTest(geom=geom):
                self.assertEqual(ref, geom)

        # Should only accept string objects.
        bad_input = (1, 5.23, None, False, memoryview(b"foo"))
        msg = "'wkt' must be bytes or str (got {} instead)."
        for bad_wkt in bad_input:
            with (
                self.subTest(bad_wkt=bad_wkt),
                self.assertRaisesMessage(TypeError, msg.format(bad_wkt)),
            ):
                wkt_r.read(bad_wkt)

    def test02_wktwriter(self):
        # Creating a WKTWriter instance, testing its ptr property.
        wkt_w = WKTWriter()
        msg = "Incompatible pointer type: "
        with self.assertRaisesMessage(TypeError, msg):
            wkt_w.ptr = WKTReader.ptr_type()

        ref = GEOSGeometry("POINT (5 23)")
        ref_wkt = "POINT (5.0000000000000000 23.0000000000000000)"
        self.assertEqual(ref_wkt, wkt_w.write(ref).decode())

    def test_wktwriter_constructor_arguments(self):
        wkt_w = WKTWriter(dim=3, trim=True, precision=3)
        ref = GEOSGeometry("POINT (5.34562 23 1.5)")
        if geos_version_tuple() > (3, 10):
            ref_wkt = "POINT Z (5.346 23 1.5)"
        else:
            ref_wkt = "POINT Z (5.35 23 1.5)"
        self.assertEqual(ref_wkt, wkt_w.write(ref).decode())

    def test03_wkbreader(self):
        # Creating a WKBReader instance
        wkb_r = WKBReader()

        hex_bin = b"000000000140140000000000004037000000000000"
        hex_str = "000000000140140000000000004037000000000000"
        wkb = memoryview(binascii.a2b_hex(hex_bin))
        ref = GEOSGeometry(hex_bin)

        # read() should return a GEOSGeometry on either a hex string or
        # a WKB buffer.
        g1 = wkb_r.read(wkb)
        g2 = wkb_r.read(hex_bin)
        g3 = wkb_r.read(hex_str)
        for geom in (g1, g2, g3):
            with self.subTest(geom=geom):
                self.assertEqual(ref, geom)

        bad_input = (1, 5.23, None, False)
        msg = "'wkb' must be bytes, str or memoryview (got {} instead)."
        for bad_wkb in bad_input:
            with (
                self.subTest(bad_wkb=bad_wkb),
                self.assertRaisesMessage(TypeError, msg.format(bad_wkb)),
            ):
                wkb_r.read(bad_wkb)

    def test04_wkbwriter(self):
        wkb_w = WKBWriter()

        # Representations of 'POINT (5 23)' in hex -- one normal and
        # the other with the byte order changed.
        g = GEOSGeometry("POINT (5 23)")
        hex1 = b"010100000000000000000014400000000000003740"
        wkb1 = memoryview(binascii.a2b_hex(hex1))
        hex2 = b"000000000140140000000000004037000000000000"
        wkb2 = memoryview(binascii.a2b_hex(hex2))

        self.assertEqual(hex1, wkb_w.write_hex(g))
        self.assertEqual(wkb1, wkb_w.write(g))

        # Ensuring bad byteorders are not accepted.
        msg = "Byte order parameter must be 0 (Big Endian) or 1 (Little Endian)."
        for bad_byteorder in (-1, 2, 523, "foo", None):
            # Equivalent of `wkb_w.byteorder = bad_byteorder`
            with (
                self.subTest(bad_byteorder=bad_byteorder),
                self.assertRaisesMessage(ValueError, msg),
            ):
                wkb_w._set_byteorder(bad_byteorder)

        # Setting the byteorder to 0 (for Big Endian)
        wkb_w.byteorder = 0
        self.assertEqual(hex2, wkb_w.write_hex(g))
        self.assertEqual(wkb2, wkb_w.write(g))

        # Back to Little Endian
        wkb_w.byteorder = 1

        # Now, trying out the 3D and SRID flags.
        g = GEOSGeometry("POINT (5 23 17)")
        g.srid = 4326

        hex3d = b"0101000080000000000000144000000000000037400000000000003140"
        wkb3d = memoryview(binascii.a2b_hex(hex3d))
        hex3d_srid = (
            b"01010000A0E6100000000000000000144000000000000037400000000000003140"
        )
        wkb3d_srid = memoryview(binascii.a2b_hex(hex3d_srid))

        # Ensuring bad output dimensions are not accepted
        msg = "WKB output dimension must be 2 or 3"
        for bad_outdim in (-1, 0, 1, 4, 423, "foo", None):
            with (
                self.subTest(bad_outdim=bad_outdim),
                self.assertRaisesMessage(ValueError, msg),
            ):
                wkb_w.outdim = bad_outdim

        # Now setting the output dimensions to be 3
        wkb_w.outdim = 3

        self.assertEqual(hex3d, wkb_w.write_hex(g))
        self.assertEqual(wkb3d, wkb_w.write(g))

        # Telling the WKBWriter to include the srid in the representation.
        wkb_w.srid = True
        self.assertEqual(hex3d_srid, wkb_w.write_hex(g))
        self.assertEqual(wkb3d_srid, wkb_w.write(g))

    def test_wkt_writer_trim(self):
        wkt_w = WKTWriter()
        self.assertFalse(wkt_w.trim)
        self.assertEqual(
            wkt_w.write(Point(1, 1)), b"POINT (1.0000000000000000 1.0000000000000000)"
        )

        wkt_w.trim = True
        self.assertTrue(wkt_w.trim)
        self.assertEqual(wkt_w.write(Point(1, 1)), b"POINT (1 1)")
        self.assertEqual(wkt_w.write(Point(1.1, 1)), b"POINT (1.1 1)")
        self.assertEqual(
            wkt_w.write(Point(1.0 / 3, 1)), b"POINT (0.3333333333333333 1)"
        )

        wkt_w.trim = False
        self.assertFalse(wkt_w.trim)
        self.assertEqual(
            wkt_w.write(Point(1, 1)), b"POINT (1.0000000000000000 1.0000000000000000)"
        )

    def test_wkt_writer_precision(self):
        wkt_w = WKTWriter()
        self.assertIsNone(wkt_w.precision)
        self.assertEqual(
            wkt_w.write(Point(1.0 / 3, 2.0 / 3)),
            b"POINT (0.3333333333333333 0.6666666666666666)",
        )

        wkt_w.precision = 1
        self.assertEqual(wkt_w.precision, 1)
        self.assertEqual(wkt_w.write(Point(1.0 / 3, 2.0 / 3)), b"POINT (0.3 0.7)")

        wkt_w.precision = 0
        self.assertEqual(wkt_w.precision, 0)
        self.assertEqual(wkt_w.write(Point(1.0 / 3, 2.0 / 3)), b"POINT (0 1)")

        wkt_w.precision = None
        self.assertIsNone(wkt_w.precision)
        self.assertEqual(
            wkt_w.write(Point(1.0 / 3, 2.0 / 3)),
            b"POINT (0.3333333333333333 0.6666666666666666)",
        )

        with self.assertRaisesMessage(
            AttributeError, "WKT output rounding precision must be "
        ):
            wkt_w.precision = "potato"

    def test_empty_point_wkb(self):
        p = Point(srid=4326)
        wkb_w = WKBWriter()

        wkb_w.srid = False
        with self.assertRaisesMessage(
            ValueError, "Empty point is not representable in WKB."
        ):
            wkb_w.write(p)
        with self.assertRaisesMessage(
            ValueError, "Empty point is not representable in WKB."
        ):
            wkb_w.write_hex(p)

        wkb_w.srid = True
        for byteorder, hex in enumerate(
            [
                b"0020000001000010E67FF80000000000007FF8000000000000",
                b"0101000020E6100000000000000000F87F000000000000F87F",
            ]
        ):
            wkb_w.byteorder = byteorder
            self.assertEqual(wkb_w.write_hex(p), hex)
            self.assertEqual(GEOSGeometry(wkb_w.write_hex(p)), p)
            self.assertEqual(wkb_w.write(p), memoryview(binascii.a2b_hex(hex)))
            self.assertEqual(GEOSGeometry(wkb_w.write(p)), p)

    def test_empty_polygon_wkb(self):
        p = Polygon(srid=4326)
        p_no_srid = Polygon()
        wkb_w = WKBWriter()
        wkb_w.srid = True
        for byteorder, hexes in enumerate(
            [
                (b"000000000300000000", b"0020000003000010E600000000"),
                (b"010300000000000000", b"0103000020E610000000000000"),
            ]
        ):
            wkb_w.byteorder = byteorder
            for srid, hex in enumerate(hexes):
                wkb_w.srid = srid
                with self.subTest(byteorder=byteorder, hexes=hexes):
                    self.assertEqual(wkb_w.write_hex(p), hex)
                    self.assertEqual(
                        GEOSGeometry(wkb_w.write_hex(p)), p if srid else p_no_srid
                    )
                    self.assertEqual(wkb_w.write(p), memoryview(binascii.a2b_hex(hex)))
                    self.assertEqual(
                        GEOSGeometry(wkb_w.write(p)), p if srid else p_no_srid
                    )
