#from django import models
from django.views.generic.list_detail import object_list
from django.contrib.contenttypes.models import  ContentType
from django.contrib.sites.models import Site
from django.http import Http404, HttpResponse, HttpResponseGone
from django.core.exceptions import ObjectDoesNotExist
from django.template import loader, RequestContext
from django.contrib.auth.views import redirect_to_login
from django.utils.html import strip_tags, strip_entities
from django.utils import simplejson
from django.conf import settings

from zilbo.common.tag.models import Tag, TagObject, TagUserObject
from zilbo.common.tag.tagthenet import tags_from_text
from zilbo.common.utils.misc import verify_objref_hash, get_model, get_content_type, get_object, get_content_type_id_by_modelname

def model_tags_list( request, model_name, mode='user',
        template_name = None, 
        template_loader=loader, 
        context_processors=None
        ):
    try:
        c_mod = ContentType.objects.get( name__exact=model_name)
        #c_mod = get_content_type( model_name )
    except ImportError:
        raise Http404("model %s does not exist" % ( model_name ))

    if mode == 'user' and not request.user.is_anonymous():
        possibles = c_mod.taguserobject_set.all()
    else:
        mode = 'central'
        possibles = c_mod.tagobject_set.all()


    object_list={}
    for tagobj in possibles:
        object_list[ tagobj.tag.id ] = tagobj.tag

    tag_list = object_list.values()
    tag_list.sort()

    if not template_name:
        template_name = "tag/list_model.html"
    t = template_loader.get_template(template_name)
    c = RequestContext(request, {
            'content': c_mod, 'object_list': tag_list, 'title':c_mod.name ,'mode': mode,
            }, context_processors)
    return HttpResponse(t.render(c))

def model_tags_detail( request, model_name, tag_name, mode='user',
        template_name = None, 
        template_loader=loader, 
        context_processors=None):
    try:
        c_mod = ContentType.objects.get( name__exact=model_name)
#        c_mod = get_content_type( model_name )
    except ImportError:
        raise Http404("%s does not exist" % ( model_name ))

    try:
        tag = Tag.objects.get( slug__exact = tag_name )
    except ObjectDoesNotExist:
        raise Http404("Tag %s does not exist" % (tag_name ))

    keys=[]

    if mode == 'user' and not request.user.is_anonymous():
        object_list = TagUserObject.objects.filter( tag__id__exact = tag.id, content_type__id__exact = c_mod.id)
    else:
        mode = 'central'
        object_list = TagObject.objects.filter( tag__id__exact = tag.id, content_type__id__exact = c_mod.id )

        if request.POST:
            keys = request.POST.keys()
            to_add=[]

            for key in keys:
                if key.startswith("id_"):
                    (i,id_number) = key.split("_")
                    to_add.append(int(id_number))
            # if mode == 'user' and not request.user.is_anonymous():
            #     TagUserObject.objects.set_bulk_tags(tag, c_mod, request.user, to_add )
            #     object_list = TagUserObject.objects.filter( tag__id__exact = tag.id, content_type__id__exact = c_mod.id)
            # else:
            mode='central'
            TagObject.objects.set_bulk_tags(tag, c_mod, to_add )
            object_list = TagObject.objects.filter( tag__id__exact = tag.id, content_type__id__exact = c_mod.id )

    if not template_name:
        template_name = "tag/list_model_tag.html"
    t = template_loader.get_template(template_name)
    c = RequestContext(request, {
            'content': c_mod, 'tag': tag, 'object_list': object_list,
            'title':'%ss with the %s tag' % (c_mod.name, tag.name),
            'mode':mode,
            'keys':keys
            
            }, context_processors)
    return HttpResponse(t.render(c))

def tag_detail( request, tag_name, mode='user',
        template_name = None, 
        template_loader=loader, 
        context_processors=None):

    c_ids=[]
    try:
        models= settings.TAG_DISPLAY_MODELS
        if models is not None:
            for model in models.split(","):
                c_ids.append( get_content_type_id_by_modelname(model))
    except:
        pass

    try:
        tag = Tag.objects.get( slug__exact = tag_name )
    except ObjectDoesNotExist:
        raise Http404("Tag %s does not exist" % (tag_name ))


    if mode == 'user' and not request.user.is_anonymous():
        print c_ids
        if len(c_ids) == 0:
            list = tag.tagged_user_objects.all()
            summary_list = tag.tagged_objects.all()
        else:
            list = tag.tagged_user_objects.filter(content_type__id__in = c_ids)
            summary_list = tag.tagged_objects.filter(content_type__id__in = c_ids)

        taggable_objects = TagUserObject.get_tagged_models().values()
    else:
        mode='central'
        if len(c_ids) == 0:
            list = tag.tagged_objects.all()
        else:
            list = tag.tagged_objects.filter(content_type__id__in = c_ids)

        summary_list = list
        taggable_objects = TagObject.get_tagged_models().values()

    if not template_name:
        template_name = "tag/tag_detail.html"
    t = template_loader.get_template(template_name)
    c = RequestContext(request, {
        'tag': tag,  'object_list':list , 'mode':mode, 'title': tag.name, 'taggable_objects': taggable_objects , 'summary': summary_list,
            } , context_processors)
    return HttpResponse(t.render(c))

def object_tag2( request, model_name, slug, key, mode='user' ,
        template_name = None, 
        template_loader=loader, 
        context_processors=None):
    try:
        c_mod = ContentType.objects.get( name__exact=model_name)
        #c_mod = get_content_type( model_name )
    except  ObjectDoesNotExist:
        raise Http404("%s does not exist" % ( model_name ))

    try:
        lookup = { "%s__iexact" % slug : key } 
        object = c_mod.get_object_for_this_type( **lookup )
    except  ObjectDoesNotExist:
        raise Http404("%s.%s %s does not exist" % ( model_name, slug, key))

#    return object_tag( request, model_name, object.id, mode, template_name, template_loader, context_processors )
    return object_tag( request, c_mod, object, mode, template_name, template_loader, context_processors )

def object_tag3( request, content_type_id, object_id,  hash,
        mode='user' ,
        template_name = None, 
        template_loader=loader, 
        context_processors=None):
    if not verify_objref_hash( content_type_id, object_id, hash ):
        raise Http404("Not Found")

    c_obj= ContentType.objects.get(pk=content_type_id)

    try:
        obj = c_obj.get_object_for_this_type(pk=object_id )
    except ObjectDoesNotExist:
        raise Http404("Can't find that object")

    return object_tag( request, c_obj, obj, mode, template_name, template_loader, context_processors )

def object_tag( request, c_mod, object, mode='user' ,
        template_name = None, 
        template_loader=loader, 
        context_processors=None):

    if request.POST:
        if request.user.is_anonymous():
            if request.POST.has_key('json'):
                response = HttpResponse(simplejson.dumps({ 'result':False, 'text':"you need to be logged in"}), 'text/javascript')
            else:
                return redirect_to_login( request.path )

        tagstring = request.POST.get('tags', "")
        object_ref = request.POST.get('object_ref',"1/1/1")
        ( c, o, h ) = object_ref.split('/')
        if ( not verify_objref_hash( c,o,h )):
            if request.POST.has_key('json'):
                response = HttpResponse(simplejson.dumps({ 'result':False, 'text':"hash mismatch"}), 'text/javascript')
            else:
                return HttpResponseGone( 'hash mismatch')

        tags = Tag.objects.create_from_string(request.user, tagstring)
        if mode == 'user' and not request.user.is_anonymous():
            old = TagUserObject.objects.filter( content_type__id__exact = c_mod.id, object_id = object.id )
        else:
            mode='central'
            old = TagObject.objects.filter( content_type__id__exact = c_mod.id, object_id = object.id )

        # there are better ways I'm sure
        # I promise I'll fix it later .. or better yet submit a patch ;-)
        for tagO in old:
            tagO.delete()

        for tag in tags:
            # checked for registered user above
            if mode == 'user' :
#                print "about to add tag %s" % tag
                new_tag = TagUserObject( content_type= c_mod, object_id = object.id, tag = tag, user = request.user )
            else:
                new_tag = TagObject( content_type= c_mod, object_id = object.id, tag = tag)
            new_tag.save()

        if request.POST.has_key('json'):
            return HttpResponse(simplejson.dumps({ 'result':True, 'text':"changes applied"}), 'text/javascript')

    if mode == 'user' and not request.user.is_anonymous():
        list = TagUserObject.objects.filter( content_type = c_mod.id, object_id = object.id)
        taggable_objects = TagUserObject.get_tags_for_model( c_mod ).values()
        try:
            summary_tags = TagObject.objects.filter( content_type = c_mod.id, object_id = object.id)
        except TagObject.DoesNotExist:
            summary_tags=[]
    else:
        mode='central'
        list = TagObject.objects.filter( content_type = c_mod.id, object_id = object.id)
        taggable_objects = TagObject.get_tags_for_model( c_mod ).values()


    if request.GET:
        if request.GET.has_key('json'):
            tag_list={}
            for t in list:
                tag_list[ t.tag.name ] = 1
            t_list = tag_list.keys()
            t_list.sort()
            return HttpResponse(simplejson.dumps({ 'result':True, 'group': t_list }), 'text/javascript')

    if template_name:
        t = template_loader.get_template(template_name)
    else:
        template_name = "%s/%s_tag.html" % ( object._meta.app_label, object._meta.module_name )
        t = template_loader.select_template([template_name, "tag/object_tag.html"])


    context =  {
            'object': object ,  'tag_list':list , 'mode':mode, 'tags': taggable_objects,
    }

    if mode=='user' and not request.user.is_anonymous():
        context['summary_tags'] = summary_tags
    c = RequestContext(request, context, context_processors)
    return HttpResponse(t.render(c))


def search_model( request, model_name, mode='user',
                  extra_lookup_kwargs=None, extra_context=None):
#    try:
#        c_mod = ContentType.objects.get( name__exact=model_name)
##        c_mod = get_content_type( model_name )
#    except  ObjectDoesNotExist:
#        raise Http404("%s does not exist" % ( model_name ))
#    mod = c_mod.model_class()
    if extra_context is None: extra_context = {} 
    if extra_lookup_kwargs is None: extra_lookup_kwargs = {}
    ct = get_content_type_id_by_modelname( model_name )
    mod = get_model( ct ) 
   
    if mod is None:
        raise Http404("%s does not exist" % ( model_name ))

    filter = extra_lookup_kwargs.copy()
    keys = request.GET.keys()
    good_keys=[]
    if keys:
            meta = mod._meta
            for key in keys:
                try:
                    meta.get_field(key)
                    value =  request.GET.get(key,None)
                    good_keys.append(key)

                    if value:
                        filter[key+'__icontains'] = value
                except:
                    {}
    object_list = mod.objects.filter(**filter)
    returned_list=[]
    for obj in object_list:
        returned_list.append({ 'id': obj.id, 'name': str(obj), 'url': obj.get_absolute_url() })
    return HttpResponse(simplejson.dumps( {'keys':good_keys, 'object_list':returned_list}), 'text/javascript')

def search_model_keys( request, model_name, mode='user'):
#    try:
#       c_mod = ContentType.objects.get( name__exact=model_name)
#        c_mod = get_content_type( model_name )
#    except  ObjectDoesNotExist:
#        raise Http404("%s does not exist" % ( model_name ))

    ct = get_content_type_id_by_modelname( model_name )
#    mod = c_mod.model_class()
    mod = get_model( ct ) 

    if mod is None:
        raise Http404("%s does not exist" % ( model_name ))

    object_list=[]

    for field in mod._meta.fields:
        if field.get_internal_type() != 'AutoField':
            object_list.append({ 'name': field.name, 'type': field.get_internal_type()})

    return HttpResponse(simplejson.dumps({'object_list':object_list}), 'text/javascript')

def model_tags_intersect( request, model_name, mode='user',
        template_name = None, 
        template_loader=loader, 
        context_processors=None):
    try:
        c_mod = ContentType.objects.get( name__exact=model_name)
        #c_mod = get_content_type( model_name )
    except  ObjectDoesNotExist:
        raise Http404("%s does not exist" % ( model_name ))

    tag_list=[]
    tags_to_find = request.GET.get('tags',"").strip()
    tags_found = Tag.objects.get_from_string( tags_to_find )
    include_name = "%s/%s_intersect.html" % ( c_mod.app_label , c_mod.name )

    if mode == 'user' and not request.user.is_anonymous():
#        tag_list = TagUserObject.objects.filter( tag__id__exact = tag.id, content_type__id__exact = c_mod.id, user__id__exact = request.user.id )
        tag_list = TagUserObject.get_tags_for_model( c_mod ).values()
        object_list = TagUserObject.intersection( tags_found, c_mod ).values()
    else:
        mode = 'central'
        tag_list = TagObject.get_tags_for_model( c_mod  ).values()
        object_list = TagObject.intersection( tags_found, c_mod ).values()

    object_list.sort()

    if not template_name:
        template_name = "tag/intersect.html"
    t = template_loader.get_template(template_name)
    c = RequestContext(request, {
            'content': c_mod, 
            'object_list': object_list,
            'title':c_mod.name, 
            'tag_list': tag_list, 
            'tags_found': tags_found, 
            'tags':tags_to_find,
            'include_name':include_name,
            }, context_processors)
    return HttpResponse(t.render(c))

def wrapped(generic):

    def _wrapper(request, queryset, mode='user', *args, **kw):
        if not kw.has_key('extra_context'):
            kw['extra_context'] = {}
        model = queryset.model
        keys = request.GET.keys()
        if keys:
            filter={}
            model = queryset.model
            meta = model._meta
            c_mod = get_content_type( model )

            for key in keys:
                if key == 'tags':
                    value =  request.GET.get(key,None)
                    tag_list = Tag.objects.get_from_string( value )
                    if mode == 'user' and not request.user.is_anonymous():
                        object_list = TagUserObject.intersection( tag_list, c_mod )
                    else:
                        object_list = TagObject.intersection( tag_list, c_mod )
                    if object_list:
                        a = [ str( z ) for z in object_list.keys() ]
                        queryset = queryset.extra( where = [ "id in (%s)" % ",".join(a) ] )

                    kw['extra_context'][key] = value
                    continue
                try:
                    meta.get_field(key)
                    value =  request.GET.get(key,None)

                    if value:
                        filter[key+'__icontains'] = value
                        kw['extra_context'][key] = value
                except:
                    pass

            return generic(request, queryset.filter(**filter), *args, **kw)
        else:
            return generic(request, queryset, *args, **kw)

    return _wrapper

object_list = wrapped(object_list)

def suggest( request, content_type_id, object_id,  hash,
        mode='user',
        suggest=False,
        template_name = None, 
        template_loader=loader, 
        context_processors=None):

    if not verify_objref_hash( content_type_id, object_id, hash ):
        raise Http404("Not Found")

    try:
        obj = get_object( content_type_id, object_id ) 
    except ObjectDoesNotExist:
        raise Http404("Can't find that object")
    s={}
    sum_tag = TagObject.objects.filter( content_type__id__exact = content_type_id, object_id__exact = object_id )
    for t in sum_tag:
        if ( t.tag.name.find(" ")>0 ):
            s["'%s'" % t.tag.name ] = ( t.tag.slug, t.weight )
        else:
            s[t.tag.name ] = ( t.tag.slug, t.weight )


    u={}
    if mode == 'user' and not request.user.is_anonymous():
        user_tag = TagUserObject.objects.filter( content_type__id__exact = content_type_id, object_id__exact = object_id )
        for t in user_tag:
            if ( t.tag.name.find(" ")>0 ):
                u["'%s'" % t.tag.name ] = ( t.tag.slug, t.weight )
            else:
                u[t.tag.name ] = ( t.tag.slug, t.weight )
    else:
        mode= 'central'
        u=s

    tag_string=""
    for name in u.keys():
        if name.find(" ")>0:
            tag_string = "%s '%s'" % ( tag_string, name )
        else:
            tag_string = "%s %s" % ( tag_string, name )

    tag_string = tag_string.strip()
    desc=""
    try:
        desc = obj.description
    except AttributeError:
        try:
            desc= strip_entities( strip_tags( obj.content ) )
        except AttributeError:
            desc=None

    suggestTags=[]
    if suggest == True:
        suggestions = tags_from_text( desc, "http://%s%s" %( Site.objects.get_current().name, obj.get_absolute_url()))
        for name in suggestions:
            if name.find(" ")>0:
                suggestTags.append( "'%s'" % name.strip("") )
            else:
                suggestTags.append( name.strip("") )

    response = HttpResponse(
                simplejson.dumps(
                    { 'result':True, 'tag_string': tag_string, 'user':u, 'summary':s, 'suggestion':suggestTags, 'mode':mode } 
                ), 'text/javascript')
    return response