class LogoutView(APIView):
    def get(self, request, *args, **kwargs):
        logout(request)
        return Response({"status": "success"})


class LoginView(APIView):
    serializer_class = LoginUserSerializer
    queryset = User.objects.all()
    permission_classes = (AllowAny,)

    def post(self, request, *args, **kwargs):
        ser = self.serializer_class(data=request.data)
        ser.is_valid(raise_exception=True)
        user = authenticate(email=ser.validated_data['email'], password=ser.validated_data['password'])
        if user and user.is_active:
            login(request, user)
            return Response({"status": "success", "user": UserSerializer(user).data})
        else:
            raise PermissionDenied("Wrong credentials!")


class ChangeUserPasswordView(APIView):
    """
    Change password for user
    """
    queryset = User.objects.all()
    serializer_class = ChangePasswordSerializer

    def put(self, request, *args, **kwargs):
        ser = self.serializer_class(self.request.user, data=request.data)
        ser.is_valid(raise_exception=True)
        ser.save()

        return Response({"update": "status"})


class DialogEntryView(mixins.UpdateModelMixin, mixins.RetrieveModelMixin, GenericAPIView):
    queryset = DialogEntry.objects.all()
    serializer_class = DialogEntrySerializer
    lookup_url_kwarg = 'id'

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)


class DialogView(mixins.RetrieveModelMixin, mixins.UpdateModelMixin, GenericAPIView):
    """
    <p>
    available languages in dialogs: es_ES,en_GB,en_US
    </p>
    """
    queryset = Dialog.objects.all()
    serializer_class = ExtendedDialogSerializer
    lookup_url_kwarg = 'id'

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)


class DialogEntryCreateView(mixins.CreateModelMixin, GenericAPIView):
    """
    Create Entry of Dialog
    """
    queryset = DialogEntry.objects.all()
    serializer_class = DialogEntryCreateSerializer

    def post(self, request, id, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def perform_create(self, serializer):
        serializer.save()
        data = DialogEntrySerializer(serializer.instance).data
        django_fanout.publish('dialog_%s' % self.kwargs['id'], json.dumps(data))


class DialogEntryListView(mixins.ListModelMixin, GenericAPIView):
    """
    Create Entry of Dialog
    """
    queryset = DialogEntry.objects.all()
    serializer_class = DialogEntryListSerializer
    filter_backends = (DialogEntrySearchFilter,)
    mongo_fields = ('markedAsIncorrect',)

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)


class DialogsListCreateView(mixins.ListModelMixin, mixins.CreateModelMixin, GenericAPIView):
    """
    <p>
    Available languages in dialogs: es_ES,en_GB,en_US
    </p>
    """

    queryset = Dialog.objects.all()
    serializer_class = DialogSerializer

    filter_backends = (DialogSearchFilter,)
    mongo_fields = ('search', 'agent_name', 'channel', 'locale', 'agent_id', 'dateTo', 'dateFrom',)

    def get_queryset(self):
        agents = Agent.objects.get_user_agents(self.request.user, 'read')
        self.queryset = self.queryset.filter(botSetup__in=agents)
        return super(DialogsListCreateView, self).get_queryset()

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)


class PermissionRetrieveView(mixins.RetrieveModelMixin, mixins.DestroyModelMixin, mixins.UpdateModelMixin,
                             GenericAPIView):
    """

    email
    """
    queryset = Permission.objects.all()
    serializer_class = UpdatePermissionSerializer

    @staticmethod
    def check_agent_permissions(permission_id):
        permission = Permission.objects.get(id=permission_id)
        permissions = Permission.objects.filter(params=permission.params)
        can_edit = any(
            map(lambda x: 'edit' in settings.AGENT_PERMISSIONS.get(x.type, {}).get('permissions'), permissions))
        if not can_edit:
            raise ValidationError("Not enough permissions!")

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def get_queryset(self):
        return super(PermissionRetrieveView, self).get_queryset()

    def get_object(self):
        return super(PermissionRetrieveView, self).get_object()

    def put(self, request, *args, **kwargs):
        self.check_agent_permissions(kwargs['id'])
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        self.check_agent_permissions(kwargs['id'])
        return self.destroy(request, *args, **kwargs)


class PermissionsListView(mixins.ListModelMixin, mixins.CreateModelMixin, GenericAPIView):
    """
    All user permissions

    <p>
        You can search by:
        'type', 'user_email', 'agent_name'
    </p>
    """
    queryset = Permission.objects.all()
    serializer_class = UpdatePermissionSerializer

    filter_backends = (PermissionSearchFilter,)
    mongo_fields = ('type', 'user_email', 'agent_name',)

    def get_queryset(self):
        allowed_agents = Agent.objects.get_user_agents(self.request.user, 'edit')
        self.queryset = self.queryset.filter(Q(params__in=allowed_agents) | Q(user_id=self.request.user))
        return super(PermissionsListView, self).get_queryset()

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def perform_create(self, serializer):
        try:
            if 'params' in serializer.validated_data:
                agent = Agent.objects.get(id=serializer.validated_data['params'].id)
            else:
                agent = Agent.objects.get(name=serializer.validated_data['agent_name'])

            permissions = Permission.objects.filter(user_id=self.request.user, params=agent)
            can_edit = False
            for perm in permissions:
                can_edit = 'edit' in settings.AGENT_PERMISSIONS.get(perm.type, {}).get('permissions')
                if can_edit:
                    break
            if not can_edit:
                raise ValidationError("You have no permissions to edit this agent, bro!")
        except Agent.DoesNotExist:
            raise ValidationError("There is no agent with this id or you haven't enough permissions, bro!")

        serializer.save()


class AgentPermissionsListView(mixins.ListModelMixin, GenericAPIView):
    """
    Agent permissions

    <p>
        You can search by:
        'type', 'user_email', 'agent_name'
    </p>
    """

    queryset = Permission.objects.all()
    serializer_class = UpdatePermissionSerializer

    filter_backends = (PermissionSearchFilter,)
    mongo_fields = ('type', 'user_email', 'agent_name',)

    def get_queryset(self):
        try:
            agents = Agent.objects.get_user_agents(self.request.user, 'read')
            if self.kwargs.get('agent_id') not in map(lambda x: str(x.id), agents):
                raise Exception
            self.queryset = self.queryset.filter(params=self.kwargs.get('agent_id'))
            return super(AgentPermissionsListView, self).get_queryset()
        except Exception:
            raise ValidationError("No such agent sorry!")

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)


class AgentsListView(mixins.ListModelMixin, mixins.CreateModelMixin, GenericAPIView):
    """
    For search use <b>search</b> GET param.

    You can also search for:
    'billing', 'permission', 'email', 'id', 'name'

    <p>
    Available Permisions:
    AGENT_OWNER = 'agentOwner'
    AGENT_SUPERVISOR = 'agentSupervisorIM'
    AGENT_SUPERVISOR_WEB = 'agentSupervisorWeb'
    AGENT_ADMINISTRATION = 'agentAdministration'
    AGENT_SUPERVISOR_PARSING = 'agentSupervisorParsing'
    </p>
    """

    queryset = Agent.objects.all()
    serializer_class = AgentSerializer

    filter_backends = (MongoSearchFilter, AgentsFieldsFilter)
    search_fields = ('name', 'description')
    mongo_fields = ('billing', 'permission', 'email', 'id', 'name')

    def get_queryset(self):
        self.queryset = Agent.objects.get_user_agents(self.request.user, 'read')
        return super(AgentsListView, self).get_queryset()

    def get(self, request, *args, **kwargs):
        return self.list(request, *args, **kwargs)

    def post(self, request, *args, **kwargs):
        return self.create(request, *args, **kwargs)

    def perform_create(self, serializer):
        try:
            Agent.objects.get(name=serializer.validated_data['name'])
            raise ValidationError("Can't create user with same name")
        except Agent.DoesNotExist:
            agent = serializer.save()
            Permission.objects.create(user_id=self.request.user, params=agent, type=AGENT_OWNER)

    def paginate_queryset(self, queryset):
        return super(AgentsListView, self).paginate_queryset(queryset)


class AgentView(mixins.RetrieveModelMixin, mixins.UpdateModelMixin, mixins.DestroyModelMixin, GenericAPIView):
    """
    Get or update or delete agent.
    <p>Depends on the method you use, there will be different actions.</p>
    """
    queryset = Agent.objects.all()
    serializer_class = AgentSerializer

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

    def perform_destroy(self, instance):
        instance.removed = True


class UpdateUserView(mixins.UpdateModelMixin, GenericAPIView):
    """
    Update user model.

    """
    queryset = User.objects.all()
    serializer_class = UserSerializer

    def put(self, request, *args, **kwargs):
        return self.update(request, *args, **kwargs)

    def get_object(self):
        queryset = self.filter_queryset(self.get_queryset())
        if not self.request.user.is_active:
            raise ValidationError("Can't delete")
        try:
            obj = queryset.get(**{'id': self.request.user.id})
        except (queryset._document.DoesNotExist, ValidationError):
            from django.http import Http404
            raise Http404('No %s matches the given query.' % queryset._document._class_name)
        self.check_object_permissions(self.request, obj)
        return obj


class DestroyView(mixins.DestroyModelMixin, GenericAPIView):
    queryset = User.objects.all()

    def delete(self, request, *args, **kwargs):
        return self.destroy(request, *args, **kwargs)

    def get_object(self):
        queryset = self.filter_queryset(self.get_queryset())
        if not self.request.user.is_active:
            raise ValidationError("Can't delete")
        try:
            obj = queryset.get(**{'id': self.request.user.id})
        except (queryset._document.DoesNotExist, ValidationError):
            from django.http import Http404
            raise Http404('No %s matches the given query.' % queryset._document._class_name)
        self.check_object_permissions(self.request, obj)
        return obj


class BotUserView(ListAPIView):
    queryset = BotUser.objects.all()
    serializer_class = BotUserSerializer


class UserDetailView(GenericAPIView):
    queryset = User.objects.all()
    serializer_class = UserDetailSerializer

    def retrieve(self, request, *args, **kwargs):
        instance = User.objects.get(id=request.user.id)
        serializer = self.get_serializer(instance)
        return Response(serializer.data)

    def get(self, request, *args, **kwargs):
        return self.retrieve(request, *args, **kwargs)