from django.contrib.gis.geos import *

from random import random

SEQ_LENGTH = 10

SEQ_RANGE = (-1 * SEQ_LENGTH, SEQ_LENGTH)

SEQ_BOUNDS = (-1 * SEQ_LENGTH, -1, 0, SEQ_LENGTH - 1)

SEQ_OUT_OF_BOUNDS = (-1 * SEQ_LENGTH -1 , SEQ_LENGTH)

def seqrange(): return xrange(*SEQ_RANGE)

def random_coord(dim    = 2,           # coordinate dimensions

                 rng    = (-50,50),    # coordinate range

                 num_type     = float,

                 round_coords = True):

    if round_coords:

        num = lambda: num_type(round(random() * (rng[1]-rng[0]) + rng[0]))

    else:

        num = lambda: num_type(random() * (rng[1]-rng[0]) + rng[0])

    return tuple( num() for axis in xrange(dim) )

def random_list(length = SEQ_LENGTH, ring = False, **kwargs):

    result  = [ random_coord(**kwargs) for index in xrange(length) ]

    if ring:

        result[-1] = result[0]

    return result

random_list.single = random_coord

def random_coll(count = SEQ_LENGTH, **kwargs):

    return [ tuple(random_list(**kwargs)) for i in xrange(count) ]

random_coll.single = random_list

class PyMutTestGeom:

    "The Test Geometry class container."

    def __init__(self, geom_type, coords_fcn=random_list, subtype=tuple, **kwargs):

        self.geom_type  = geom_type

        self.subtype    = subtype

        self.coords_fcn = coords_fcn

        self.fcn_args   = kwargs

        self.coords = self.coords_fcn(**kwargs)

        self.geom   = self.make_geom()

    def newitem(self, **kwargs):

        a = self.coords_fcn.single(**kwargs)

        return self.subtype(a), tuple(a)

    @property

    def tuple_coords(self):

        return tuple(self.coords)

    def make_geom(self):

        return self.geom_type(map(self.subtype,self.coords))

def slice_geometries(ring=True): 

    testgeoms = [

        PyMutTestGeom(LineString),

        PyMutTestGeom(MultiPoint, subtype=Point),

        PyMutTestGeom(MultiLineString, coords_fcn=random_coll, subtype=LineString),

        ]

    if ring:

        testgeoms.append(PyMutTestGeom(LinearRing, ring=True))

    return testgeoms

def getslice_functions(): 

    def gs_01(x): x[0:4],   

    def gs_02(x): x[5:-1],  

    def gs_03(x): x[6:2:-1],

    def gs_04(x): x[:],     

    def gs_05(x): x[:3],    

    def gs_06(x): x[::2],   

    def gs_07(x): x[::-4],  

    def gs_08(x): x[7:7],   

    def gs_09(x): x[20:],   

    # don't really care about ringy-ness here

    return mark_ring(vars(), 'gs_')

def delslice_functions():

    def ds_01(x): del x[0:4]   

    def ds_02(x): del x[5:-1]  

    def ds_03(x): del x[6:2:-1]

    def ds_04(x): del x[:]     # should this be allowed?

    def ds_05(x): del x[:3]    

    def ds_06(x): del x[1:9:2]   

    def ds_07(x): del x[::-4]  

    def ds_08(x): del x[7:7]   

    def ds_09(x): del x[-7:-2]

    return mark_ring(vars(), 'ds_')

def setslice_extended_functions(g):

    a = g.coords_fcn(3, rng=(100,150))

    def maptype(x,a):

        if isinstance(x, list): return a

        else: return map(g.subtype, a)

    def sse_00(x): x[:3:1]      = maptype(x, a)

    def sse_01(x): x[0:3:1]     = maptype(x, a)

    def sse_02(x): x[2:5:1]     = maptype(x, a)

    def sse_03(x): x[-3::1]     = maptype(x, a)

    def sse_04(x): x[-4:-1:1]   = maptype(x, a)

    def sse_05(x): x[8:5:-1]    = maptype(x, a)

    def sse_06(x): x[-6:-9:-1]  = maptype(x, a)

    def sse_07(x): x[:8:3]      = maptype(x, a)

    def sse_08(x): x[1::3]      = maptype(x, a)

    def sse_09(x): x[-2::-3]    = maptype(x, a)

    def sse_10(x): x[7:1:-2]    = maptype(x, a)

    def sse_11(x): x[2:8:2]     = maptype(x, a)

    return mark_ring(vars(), 'sse_')

def setslice_simple_functions(g):

    a = g.coords_fcn(3, rng=(100,150))

    def maptype(x,a):

        if isinstance(x, list): return a

        else: return map(g.subtype, a)

    def ss_00(x): x[:0]  = maptype(x, a)

    def ss_01(x): x[:1]  = maptype(x, a)

    def ss_02(x): x[:2]  = maptype(x, a)

    def ss_03(x): x[:3]  = maptype(x, a)

    def ss_04(x): x[-4:] = maptype(x, a)

    def ss_05(x): x[-3:] = maptype(x, a)

    def ss_06(x): x[-2:] = maptype(x, a)

    def ss_07(x): x[-1:] = maptype(x, a)

    def ss_08(x): x[5:]  = maptype(x, a)

    def ss_09(x): x[:]   = maptype(x, a)

    def ss_10(x): x[4:4] = maptype(x, a)

    def ss_11(x): x[4:5] = maptype(x, a)

    def ss_12(x): x[4:7] = maptype(x, a)

    def ss_13(x): x[4:8] = maptype(x, a)

    def ss_14(x): x[10:] = maptype(x, a)

    def ss_15(x): x[20:30]  = maptype(x, a)

    def ss_16(x): x[-13:-8] = maptype(x, a)

    def ss_17(x): x[-13:-9] = maptype(x, a)

    def ss_18(x): x[-13:-10] = maptype(x, a)

    def ss_19(x): x[-13:-11] = maptype(x, a)

    return mark_ring(vars(), 'ss_')

def test_geos_functions():

    return (

        lambda x: x.num_coords,

        lambda x: x.empty,

        lambda x: x.valid,

        lambda x: x.simple,

        lambda x: x.ring,

        lambda x: x.boundary,

        lambda x: x.convex_hull,

        lambda x: x.extend,

        lambda x: x.area,

        lambda x: x.length,

            )

def mark_ring(locals, name_pat, length=SEQ_LENGTH):

    '''

    Accepts an array of functions which perform slice modifications

    and labels each function as to whether or not it preserves ring-ness

    '''

    func_array = [ val for name, val in locals.items()

                    if hasattr(val, '__call__')

                    and name.startswith(name_pat) ]

    for i in xrange(len(func_array)):

        a = range(length)

        a[-1] = a[0]

        func_array[i](a)

        ring = len(a) == 0 or (len(a) > 3 and a[-1] == a[0])

        func_array[i].ring = ring

    return func_array

def getcoords(o):

    if hasattr(o, 'coords'):

        return o.coords

    else:

        return o