def login_register_view(request, register=False, modal=False):
    csrf_tk = {}
    csrf_tk.update(csrf(request))

    login_error = False
    if request.method == 'POST' and not register:
        login_form = LoginForm(request.POST)
        if login_form.is_valid():
            username = request.POST['username']
            password = request.POST['password']
            user = authenticate(username=username, password=password)
            if user is not None:
                login(request, user)
                request.session['get_token'] = generate_token()
                if not 'remember' in request.POST:
                    request.session.set_expiry(0)
                if 'next' in request.POST:
                    return redirect(request.POST['next'] or '/')
                else:
                    return redirect('/')
            else:
                login_error = 'Bad user/password'
        else:
            if request.POST['username'] and request.POST['password']:
                login_error = 'Form invalid'
            else:
                login_error = 'Please enter username and password'

    login_form = LoginForm()
    register_form = RegisterForm()

    if request.method == 'POST' and register:
        register_form = RegisterForm(request.POST)
        if register_form.is_valid():
            data = register_form.data
            user = User.objects.create_user(
                data['username'],
                data['email'],
                data['password'])
            profile = Profile(user=user)
            profile.save()
            user.backend = 'django.contrib.auth.backends.ModelBackend'
            login(request, user)
            return redirect('/user/register/success')

    csrf_tk['register_form'] = register_form
    csrf_tk['login_error'] = login_error
    csrf_tk['login_form']  = login_form
    csrf_tk['register'] = register
    if 'next' in request.GET:
        csrf_tk['next']  = request.GET.get('next')
    if not modal:
        return render_template('user/login_register.html', csrf_tk)
    else:
        return render_template('user/login_register_modal.html', csrf_tk)

def search(request, tags=None, operand=None, excludes=None, lang_filter=[1]):
    tags_csv = cache.get("tags_csv")
    if tags_csv is None:
        from taggit.models import Tag

        tags_csv = '","'.join(Tag.objects.all().values_list("name", flat=True))
        tags_csv = '"%s"' % tags_csv
        cache.set("tags_csv", tags_csv, 60 * 15)
    if operand is not None:
        return render_template("pages/search.html", {"tags": tags_csv, "stags": tags, "sop": operand, "sex": excludes})
    else:
        return render_template("pages/search.html", {"tags": tags_csv})

def search(request, tags=None, operand=None, excludes=None, lang_filter=[1]):
    from taggit.models import Tag
    all_tags = Tag.objects.all().values_list('name', flat=True)
    tags_json = json.dumps([{'tag': tag} for tag in all_tags])

    if operand is not None:
        return render_template('pages/search.html', {
            'stags': tags,
            'sop': operand,
            'sex': excludes,
            'tags_json': tags_json,
        })
    else:
        return render_template('pages/search.html', {
            'tags_json': tags_json,
        })

def lists_page(request):
    from resrc.vote.models import Vote

    lang_filter = [1]
    if request.user.is_authenticated():
        from resrc.userprofile.models import Profile

        profile = Profile.objects.get(user=request.user)
        lang_filter = profile.languages.all().order_by("name").values_list("pk", flat=True)
    latest = List.objects.latest(limit=25, lang_filter=lang_filter)
    most_viewed = List.objects.most_viewed(limit=25, lang_filter=lang_filter)
    hottest = Vote.objects.hottest_lists(limit=25, days=7, lang_filter=lang_filter)
    most_voted = Vote.objects.hottest_lists(limit=25, days=30, lang_filter=lang_filter)

    if request.user.is_authenticated():
        user_upvoted = Vote.objects.my_upvoted_lists(request.user)
        user_upvoted_pk = [x["alist__pk"] for x in user_upvoted]
    else:
        user_upvoted = []
        user_upvoted_pk = []

    return render_template(
        "lists/lists.html",
        {
            "latest": latest,
            "most_viewed": most_viewed,
            "hottest": hottest,
            "most_voted": most_voted,
            "upvoted": user_upvoted,
            "upvoted_pk": user_upvoted_pk,
        },
    )

def new(request):
    from resrc.vote.models import Vote
    from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

    lang_filter = [1]
    if request.user.is_authenticated():
        from resrc.userprofile.models import Profile

        profile = Profile.objects.get(user=request.user)
        lang_filter = profile.languages.all().order_by("name").values_list("pk", flat=True)

    links = Vote.objects.latest_links(limit=None, days=60, lang_filter=lang_filter)

    paginator = Paginator(links, 15)
    page = request.GET.get("page")
    try:
        links = paginator.page(page)
    except PageNotAnInteger:
        links = paginator.page(1)
    except EmptyPage:
        links = paginator.page(paginator.num_pages)

    user = request.user
    if user.is_authenticated():
        user_upvoted_links = Vote.objects.my_upvoted_links(user)
        user_upvoted_links = [x["link__pk"] for x in user_upvoted_links]
    else:
        user_upvoted_links = []

    return render_template("pages/new.html", {"links": links, "upvoted_links": user_upvoted_links})

def upvoted_list(request):
    from resrc.vote.models import Vote

    upvoted_links = Vote.objects.my_upvoted_links(request.user)
    upvoted_lists = Vote.objects.my_upvoted_lists(request.user)

    return render_template("links/upvoted_list.html", {"upvoted_links": upvoted_links, "upvoted_lists": upvoted_lists})

def home(request):
    from resrc.vote.models import Vote
    hot_lk_cache = 'hot_lk_15_10'

    lang_filter = [1]
    user = request.user
    if user.is_authenticated():
        from resrc.userprofile.models import Profile
        profile = Profile.objects.get(user=user)
        lang_filter = profile.languages.all().order_by('name').values_list('pk', flat=True)
        hot_lk_cache = 'hot_lk_10_7_%s' % '_'.join(map(str, lang_filter))

        user_upvoted_links = Vote.objects.my_upvoted_links(user)
        user_upvoted_links = [x['link__pk'] for x in user_upvoted_links]
    else:
        user_upvoted_links = []

    hottest_links = cache.get(hot_lk_cache)
    if hottest_links is None:
        hottest_links = Vote.objects.hottest_links(limit=15, days=10, lang_filter=lang_filter)
        cache.set(hot_lk_cache, list(hottest_links), 60*2)

    tags_csv = cache.get('tags_csv')
    if tags_csv is None:
        from taggit.models import Tag
        tags_csv = '","'.join(Tag.objects.all().values_list('name', flat=True))
        tags_csv = '"%s"' % tags_csv
        cache.set('tags_csv', tags_csv, 60*15)

    return render_template('home.html', {
        'hottest_links': hottest_links,
        'upvoted_links': user_upvoted_links,
        'csvtags': tags_csv,
    })

def register_view(request):
    csrf_tk = {}
    csrf_tk.update(csrf(request))

    login_error = False

    register_form = RegisterForm()

    if request.method == 'POST':
        register_form = RegisterForm(request.POST)
        if register_form.is_valid():
            data = register_form.data
            user = User.objects.create_user(
                data['username'],
                data['email'],
                data['password'])
            profile = Profile(user=user)
            profile.save()
            user.backend = 'django.contrib.auth.backends.ModelBackend'
            login(request, user)
            return redirect('/user/register/success')

    csrf_tk['register_form'] = register_form
    csrf_tk['login_error'] = login_error
    if 'next' in request.GET:
        csrf_tk['next']  = request.GET.get('next')
    return render_template('user/register.html', csrf_tk)

def register_view(request):
    csrf_tk = {}
    csrf_tk.update(csrf(request))

    login_error = False

    login_form = LoginForm()
    register_form = RegisterForm()

    if request.method == "POST":
        register_form = RegisterForm(request.POST)
        if register_form.is_valid():
            data = register_form.data
            user = User.objects.create_user(data["username"], data["email"], data["password"])
            profile = Profile(user=user)
            profile.save()
            user.backend = "django.contrib.auth.backends.ModelBackend"
            login(request, user)
            return redirect("/user/register/success")

    csrf_tk["register_form"] = register_form
    csrf_tk["login_error"] = login_error
    csrf_tk["login_form"] = login_form
    if "next" in request.GET:
        csrf_tk["next"] = request.GET.get("next")
    return render_template("user/register.html", csrf_tk)

def my_lists(request, user_name):
    upvoted_count = 0
    from django.db.models import Count
    if request.user.username == user_name:
        user = request.user
        only_public = False
        owner = True
        from resrc.vote.models import Vote
        upvoted_count = len(
            list(Vote.objects.exclude(link=None).filter(user=user).values_list('pk')))

    else:
        user = get_object_or_404(User, username=user_name)
        only_public = True
        owner = False

    lists = List.objects.user_lists(user, only_public=only_public) \
        .annotate(c=Count('links'))

    return render_template('lists/lists_list.html', {
        'lists': lists,
        'owner': owner,
        'username': user_name,
        'upvoted_count': upvoted_count,
    })

def links_page(request):
    from resrc.vote.models import Vote
    lang_filter = [1]
    if request.user.is_authenticated():
        from resrc.userprofile.models import Profile
        profile = Profile.objects.get(user=request.user)
        lang_filter = profile.languages.all().order_by('name').values_list('pk', flat=True)
    latest = Vote.objects.latest_links(limit=25, days=7, lang_filter=lang_filter)
    hottest = Vote.objects.hottest_links(limit=15, days=10, lang_filter=lang_filter)
    most_voted = Vote.objects.hottest_links(limit=10, days=30, lang_filter=lang_filter)

    if request.user.is_authenticated():
        user_upvoted = Vote.objects.my_upvoted_links(request.user)
        user_upvoted_pk = [x['link__pk'] for x in user_upvoted]
    else:
        user_upvoted = []
        user_upvoted_pk = []

    return render_template('links/links.html', {
        'latest': latest,
        'hottest': hottest,
        'most_voted': most_voted,
        'upvoted': user_upvoted,
        'upvoted_pk': user_upvoted_pk,
    })

def settings_profile(request):
    profile = Profile.objects.get(user=request.user)
    if request.method == 'POST':
        form = ProfileForm(request.POST)
        if form.is_valid():
            profile.about = form.data['about']
            request.user.email = form.data['email']
            languages = request.POST.getlist('languages')
            if 'show_email' in form.data:
                profile.show_email = form.data['show_email']
            else:
                profile.show_email = False

            # Save the profile
            # and redirect the user to the configuration space
            # with message indicate the state of the operation
            try:
                profile.languages.clear()
                from resrc.language.models import Language
                for lang in languages:
                    profile.languages.add(Language.objects.get(pk=lang))
                profile.save()
                request.user.save()
            except:
                messages.error(request, 'Error')
                return redirect(reverse('user-settings'))

            messages.success(
                request, 'Update successful.')
            return redirect(reverse('user-settings'))
        else:
            return render_template('user/settings_profile.html', {
                'usr': request.user,
                'form': form,
            })
    else:
        form = ProfileForm(initial={
            'about': profile.about,
            'email': request.user.email,
            'languages': profile.languages.all(),
            'show_email': profile.show_email
            }
        )
        return render_template('user/settings_profile.html', {
            'usr': request.user,
            'form': form
        })

def settings_account(request):
    if request.method == "POST":
        form = ChangePasswordForm(request.user, request.POST)
        if form.is_valid():
            try:
                request.user.set_password(form.data["password_new"])
                request.user.save()
                messages.success(request, "Password updated.")
                return redirect(reverse("user-settings"))
            except:
                messages.error(request, "Error while updating your password.")
                return redirect(reverse("user-settings"))
        else:
            return render_template("user/settings_account.html", {"usr": request.user, "form": form})
    else:
        form = ChangePasswordForm(request.user, request.POST)
        return render_template("user/settings_account.html", {"usr": request.user, "form": form})

def ajax_own_lists(request, link_pk):
    if not request.user.is_authenticated():
        raise PermissionDenied

    all_lists = List.objects.personal_lists(request.user)
    titles = list(List.objects.my_list_titles(request.user, link_pk).values_list("title", flat=True))

    return render_template("lists/ajax_own_lists.html", {"lists": all_lists, "titles": titles, "link_pk": link_pk})

def home(request):
    from resrc.vote.models import Vote
    hot_lk_cache = 'hot_lk_5_7'
    hot_ls_cache = 'hot_ls_14_7'
    lang_filter = [1]
    user = request.user
    if user.is_authenticated():
        from resrc.userprofile.models import Profile
        profile = Profile.objects.get(user=user)
        lang_filter = profile.languages.all().order_by('name').values_list('pk', flat=True)
        hot_lk_cache = 'hot_lk_10_7_%s' % '_'.join(map(str, lang_filter))
        hot_ls_cache = 'hot_ls_10_14_%s' % '_'.join(map(str, lang_filter))

        user_upvoted_lists = Vote.objects.my_upvoted_lists(user)
        user_upvoted_lists = [x['alist__pk'] for x in user_upvoted_lists]
        user_upvoted_links = Vote.objects.my_upvoted_links(user)
        user_upvoted_links = [x['link__pk'] for x in user_upvoted_links]
    else:
        user_upvoted_lists = []
        user_upvoted_links = []

    hottest_links = cache.get(hot_lk_cache)
    if hottest_links is None:
        hottest_links = Vote.objects.hottest_links(limit=5, days=7, lang_filter=lang_filter)
        cache.set(hot_lk_cache, list(hottest_links), 60*2)

    latest_links = Vote.objects.latest_links(limit=5, days=7, lang_filter=lang_filter)

    hottest_lists = cache.get(hot_ls_cache)
    if hottest_lists is None:
        hottest_lists = Vote.objects.hottest_lists(limit=5, days=14, lang_filter=lang_filter)
        cache.set(hot_ls_cache, list(hottest_lists), 60*2+2)

    tags = cache.get('tags_all')
    if tags is None:
        from taggit.models import Tag
        from django.db.models import Count
        tags = Tag.objects.select_related('links') \
            .annotate(c=Count('link')).order_by('-c') \
            .all()
        cache.set('tags_all', list(tags), 60*15)

    tags_csv = cache.get('tags_csv')
    if tags_csv is None:
        from taggit.models import Tag
        tags_csv = '","'.join(Tag.objects.all().values_list('name', flat=True))
        tags_csv = '"%s"' % tags_csv
        cache.set('tags_csv', tags_csv, 60*15)

    return render_template('home.html', {
        'latest_links': latest_links,
        'hottest_links': hottest_links,
        'tags': tags[:25],
        'csvtags': tags_csv,
        'hottest_lists': hottest_lists,
        'upvoted_links': user_upvoted_links,
        'upvoted_lists': user_upvoted_lists,
    })

def search(request, tags=None, operand=None, excludes=None, lang_filter=[1]):
    tags_csv = cache.get('tags_csv')
    if tags_csv is None:
        from taggit.models import Tag
        tags_csv = '","'.join(Tag.objects.all().values_list('name', flat=True))
        tags_csv = '"%s"' % tags_csv
        cache.set('tags_csv', tags_csv, 60*15)
    if operand is not None:
        return render_template('pages/search.html', {
            'tags': tags_csv,
            'stags': tags,
            'sop': operand,
            'sex': excludes,
        })
    else:
        return render_template('pages/search.html', {
            'tags': tags_csv,
        })

def upvoted_list(request):
    from resrc.vote.models import Vote
    upvoted_links = Vote.objects.my_upvoted_links(request.user)
    upvoted_lists = Vote.objects.my_upvoted_lists(request.user)

    return render_template('links/upvoted_list.html', {
        'upvoted_links': upvoted_links,
        'upvoted_lists': upvoted_lists,
    })

def login_view(request, modal=False):
    csrf_tk = {}
    csrf_tk.update(csrf(request))

    login_error = False
    if request.method == 'POST':
        login_form = LoginForm(request.POST)
        if login_form.is_valid():
            username = request.POST['username']
            password = request.POST['password']
            user = authenticate(username=username, password=password)
            if user is not None:
                login(request, user)
                request.session['get_token'] = generate_token()
                if not 'remember' in request.POST:
                    request.session.set_expiry(0)
                if 'next' in request.POST:
                    return redirect(request.POST['next'] or '/')
                else:
                    return redirect('/')
            else:
                login_error = 'Bad user/password'
        else:
            if request.POST['username'] and request.POST['password']:
                login_error = 'Form invalid'
            else:
                login_error = 'Please enter username and password'

    next = '/'
    if 'next' in request.GET:
        next = request.GET['next']

    login_form = LoginForm(({'next': next}),)
    register_form = RegisterForm()

    csrf_tk['register_form'] = register_form
    csrf_tk['login_error'] = login_error
    csrf_tk['login_form']  = login_form
    if 'next' in request.GET:
        csrf_tk['next']  = request.GET.get('next')
    if not modal:
        return render_template('user/login.html', csrf_tk)
    else:
        return render_template('user/login_register_modal.html', csrf_tk)

def details(request, user_name):
    """Displays details about a profile"""
    usr = get_object_or_404(User, username=user_name)

    try:
        profile = Profile.objects.get(user=usr)
    except Profile.DoesNotExist:
        raise Http404

    return render_template("user/profile.html", {"usr": usr, "profile": profile})

def single(request, tag_slug):
    tag = get_object_or_404(Tag, slug=tag_slug)

    links = Link.objects.filter(tags=tag)

    return render_template('tags/show_single.html', {
        'tag': tag,
        'links': links,
        'request': request,
    })