# ~*~ coding: utf-8 ~*~

from __future__ import unicode_literals, absolute_import

import functools

from django.utils.translation import ugettext as _
from django.db import transaction
from django.conf import settings
from django.db.models import Q
from django.views.generic import ListView, CreateView, UpdateView
from django.views.generic.edit import DeleteView, FormView
from django.urls import reverse_lazy
from django.contrib.messages.views import SuccessMessageMixin
from django.views.generic.detail import DetailView, SingleObjectMixin

from common.utils import search_object_attr
from .hands import AdminUserRequiredMixin, User, UserGroup, SystemUser, \
    Asset, AssetGroup
from .models import AssetPermission
from .forms import AssetPermissionForm
from .utils import associate_system_users_and_assets


class AssetPermissionListView(AdminUserRequiredMixin, ListView):
    model = AssetPermission
    paginate_by = settings.CONFIG.DISPLAY_PER_PAGE
    context_object_name = 'asset_permission_list'
    template_name = 'perms/asset_permission_list.html'

    def get_context_data(self, **kwargs):
        context = {
            'app': _('Perms'),
            'action': _('Asset permission list'),
            'keyword': self.keyword,
        }
        kwargs.update(context)
        return super(AssetPermissionListView, self).get_context_data(**kwargs)

    def get_queryset(self):
        self.queryset = super(AssetPermissionListView, self).get_queryset()
        self.keyword = keyword = self.request.GET.get('keyword', '')
        self.sort = sort = self.request.GET.get('sort', '-date_created')

        if keyword:
            self.queryset = self.queryset\
                .filter(Q(users__name__contains=keyword) |
                        Q(users__username__contains=keyword) |
                        Q(user_groups__name__contains=keyword) |
                        Q(assets__ip__contains=keyword) |
                        Q(assets__hostname__contains=keyword) |
                        Q(system_users__username__icontains=keyword) |
                        Q(system_users__name__icontains=keyword) |
                        Q(asset_groups__name__icontains=keyword) |
                        Q(comment__icontains=keyword) |
                        Q(name__icontains=keyword)).distinct()
        if sort:
            self.queryset = self.queryset.order_by(sort)
        return self.queryset


class AssetPermissionCreateView(AdminUserRequiredMixin,
                                SuccessMessageMixin,
                                CreateView):
    model = AssetPermission
    form_class = AssetPermissionForm
    template_name = 'perms/asset_permission_create_update.html'
    success_url = reverse_lazy('perms:asset-permission-list')

    @transaction.atomic
    def post(self, request, *args, **kwargs):
        return super(AssetPermissionCreateView, self).post(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = {
            'app': _('Perms'),
            'action': _('Create asset permission'),
        }
        kwargs.update(context)
        return super(AssetPermissionCreateView, self).get_context_data(**kwargs)

    def get_success_message(self, cleaned_data):
        url = reverse_lazy('perms:asset-permission-detail',
                           kwargs={'pk': self.object.pk})
        success_message = _(
            'Create asset permission <a href="{url}"> {name} </a> '
            'successfully.'.format(url=url, name=self.object.name))
        return success_message

    def form_valid(self, form):
        assets = form.cleaned_data['assets']
        asset_groups = form.cleaned_data['asset_groups']
        system_users = form.cleaned_data['system_users']
        associate_system_users_and_assets(system_users, assets, asset_groups)
        response = super(AssetPermissionCreateView, self).form_valid(form)
        self.object.created_by = self.request.user.name
        self.object.save()
        return response


class AssetPermissionUpdateView(AdminUserRequiredMixin, UpdateView):
    model = AssetPermission
    form_class = AssetPermissionForm
    template_name = 'perms/asset_permission_create_update.html'
    success_message = _(
        'Update asset permission <a href="{url}"> {name} </a> successfully.'
    )
    success_url = reverse_lazy("perms:asset-permission-list")

    def get_context_data(self, **kwargs):
        context = {
            'app': _('Perms'),
            'action': _('Update asset permission')
        }
        kwargs.update(context)
        return super(AssetPermissionUpdateView, self).get_context_data(**kwargs)

    def get_success_message(self):
        url = reverse_lazy('perms:asset-permission-detail',
                           kwargs={'pk': self.object.pk})
        return self.success_message.format(
            url=url, name=self.object.name
        )

    def form_valid(self, form):
        assets = form.cleaned_data['assets']
        asset_groups = form.cleaned_data['asset_groups']
        system_users = form.cleaned_data['system_users']
        associate_system_users_and_assets(system_users, assets, asset_groups)
        return super(AssetPermissionUpdateView, self).form_valid(form)


class AssetPermissionDetailView(AdminUserRequiredMixin, DetailView):
    template_name = 'perms/asset_permission_detail.html'
    context_object_name = 'asset_permission'
    model = AssetPermission

    def get_context_data(self, **kwargs):
        context = {
            'app': _('Perms'),
            'action': _('Asset permission detail'),
            'system_users_remain': [
                system_user for system_user in SystemUser.objects.all()
                if system_user not in self.object.system_users.all()],
            'system_users': self.object.system_users.all(),
        }
        kwargs.update(context)
        return super(AssetPermissionDetailView, self).get_context_data(**kwargs)


class AssetPermissionDeleteView(AdminUserRequiredMixin, DeleteView):
    model = AssetPermission
    template_name = 'perms/delete_confirm.html'
    success_url = reverse_lazy('perms:asset-permission-list')


class AssetPermissionUserView(AdminUserRequiredMixin,
                              SingleObjectMixin,
                              ListView):
    template_name = 'perms/asset_permission_user.html'
    context_object_name = 'asset_permission'
    paginate_by = settings.CONFIG.DISPLAY_PER_PAGE

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=AssetPermission.objects.all())
        self.keyword = self.request.GET.get('keyword', '')
        return super(AssetPermissionUserView, self).get(request, *args, **kwargs)

    def get_queryset(self):
        queryset = self.object.get_granted_users()
        if self.keyword:
            search_func = functools.partial(
                search_object_attr,
                value=self.keyword,
                attr_list=['username', 'name', 'email'],
                ignore_case=True)
            queryset = filter(search_func, queryset)
        return queryset

    def get_context_data(self, **kwargs):
        users_granted = self.get_queryset()
        user_groups_granted = self.object.user_groups.all()
        context = {
            'app': _('Perms'),
            'action': _('Asset permission user list'),
            'users_remain': [
                user for user in User.objects.all()
                if user not in users_granted],
            'user_groups': self.object.user_groups.all(),
            'user_groups_remain': [
                user_group for user_group in UserGroup.objects.all()
                if user_group not in user_groups_granted],
            'keyword': self.keyword,
        }
        kwargs.update(context)
        return super(AssetPermissionUserView, self).get_context_data(**kwargs)


class AssetPermissionAssetView(AdminUserRequiredMixin,
                               SingleObjectMixin,
                               ListView):
    template_name = 'perms/asset_permission_asset.html'
    context_object_name = 'asset_permission'
    paginate_by = settings.CONFIG.DISPLAY_PER_PAGE

    def get(self, request, *args, **kwargs):
        self.object = self.get_object(queryset=AssetPermission.objects.all())
        self.keyword = self.request.GET.get('keyword', '')
        return super(AssetPermissionAssetView, self)\
            .get(request, *args, **kwargs)

    def get_queryset(self):
        queryset = self.object.get_granted_assets()
        if self.keyword:
            search_func = functools.partial(
                search_object_attr, value=self.keyword,
                attr_list=['hostname', 'ip'],
                ignore_case=True)
            queryset = filter(search_func, queryset)
        return queryset

    def get_context_data(self, **kwargs):
        assets_granted = self.get_queryset()
        asset_groups_granted = self.object.user_groups.all()
        context = {
            'app': _('Perms'),
            'action': _('Asset permission asset list'),
            'assets_remain': [
                asset for asset in Asset.objects.all()
                if asset not in assets_granted],
            'asset_groups': self.object.asset_groups.all(),
            'asset_groups_remain': [
                asset_group for asset_group in AssetGroup.objects.all()
                if asset_group not in asset_groups_granted],
            'keyword': self.keyword,
        }
        kwargs.update(context)
        return super(AssetPermissionAssetView, self).get_context_data(**kwargs)