from django.http import Http404, HttpResponse
from featurestore.models import *
from vectorformats.Formats.GeoJSON import GeoJSON
from vectorformats.Feature import Feature as VFFeature
from django.db.models import Max 
import simplejson
from django.shortcuts import get_object_or_404
def add_feature_to_layer(feature, layer):
    feature.layers.add(layer)
    max = LayerFeatureList.objects.filter(layer=layer).aggregate(Max('order'))['order__max']
    if not max:
        max = 0
    lf = LayerFeatureList(feature=feature, layer=layer, order=max+1)
    lf.save()

def remove_feature_from_layer(feature, layer):
    feature.layers.remove(layer)
    LayerFeatureList.filter(feature=feature, layer=layer).delete()
    
def layer(request, id=None):
    layer = None
    if not id:
        layer = Layer()
    else:
        layer = Layer.objects.get(pk=id)
    if request.method == "POST":  
        layer.save()
    layer_data = {'id': layer.id}   
    layer_str = simplejson.dumps(layer_data)
    features = []
    seen = []
    for obj in layer.layerfeaturelist_set.all().order_by("order"):
        seen.append(obj.feature.id)
        features.append(feature_to_vffeature(obj.feature))    
    more = layer.feature_set.exclude(id__in=seen)   
    for feature in more:
        features.append(feature_to_vffeature(feature))    
    decoder = GeoJSON()
    data = decoder.encode(features, to_string=False)
    data['id'] = layer.id
    layer_str = simplejson.dumps(data)
    return HttpResponse(layer_str)


def manage_layer(request):
    if request.method == "POST":
        if 'layer' in request.POST and 'feature' in request.POST:
            layer = Layer.objects.filter(pk=request.POST['layer'])
            feature = Layer.objects.filter(pk=request.POST['feature'])
            add_feature_to_layer(feature, layer)
        elif 'order' in request.POST:
            layer = get_object_or_404(Layer, pk=request.POST['layer'])
            order = request.POST['order'].split(",")
            LayerFeatureList.objects.all().delete()
            for i in range(len(order)):
                lf = LayerFeatureList(layer=layer, feature_id=order[i], order=i)
                lf.save()

        return HttpResponse("")
    elif request.method == "DELETE":
        layer = Layer.objects.filter(pk=request.GET['layer'])
        feature = Layer.objects.filter(pk=request.GET['feature'])
        remove_feature_from_layer(feature, layer)
        return HttpResponse("")    
                

def feature_simple(request):
    feature = Feature()
    feature.geometry = simplejson.dumps({"type":"Point", "coordinates": [0,0]})
    feature.save()
    cat_id, layer_id = request.POST['layer'].split("-")
    layer = Layer.objects.get(pk=layer_id)
    add_feature_to_layer(feature, layer)
    feature.layers.add(layer)

    for key in ['title', 'description']:
        fp = Property(key=key, value=request.POST[key], feature=feature)
        fp.save()
    return HttpResponseRedirect('/map/%s/' % cat_id)

def feature(request, id=None):
    feature = None
    new = False

    if not id:
        feature = Feature()
        new = True
    else:
        feature = Feature.objects.get(pk=id)

    if request.method == "DELETE":
        feature.delete()
        return HttpResponse("")
    
    decoder = GeoJSON()
    if request.method == "POST":
        data = None
        if 'input' in request.POST:
            data = request.POST['input']
        else:
            data = request.raw_post_data
        features = decoder.decode(data)
        if len(features) != 1:
            raise Exception("Can't create multiple features at a time")
        feat = features[0]
        if feature.id:
            Property.objects.filter(feature=feature).delete()
        feature.geometry = simplejson.dumps(feat.geometry)
        feature.save()
        for key, value in feat.properties.items():
            if key == "layers": 
                for id in value:
                    layer = Layer.objects.get(pk=id)
                    if not layer in feature.layers.all():
                        add_feature_to_layer(feature, layer)
                continue        
            fp = Property(key=key, value=value, feature=feature)
            fp.save()
    props = {}
    for item in feature.property_set.all():
        props[item.key] = item.value
    props['layers'] = []
    for item in feature.layers.all(): 
        props['layers'].append(item.id)
    f = VFFeature(id=feature.id, geometry = simplejson.loads(feature.geometry), props = props)    
    data = decoder.encode([f])
    return HttpResponse(data)

def feature_to_vffeature(feature):    
    props = {}
    for item in feature.property_set.all():
        props[item.key] = item.value
    props['layers'] = []
    for item in feature.layers.all(): 
        props['layers'].append(item.id)
    try:
        geom = simplejson.loads(feature.geometry)
    except Exception, E:
        geom = None
    f = VFFeature(id=feature.id, geometry = geom, props = props)   
    return f