from django.db.models import Q, Avg
from django.contrib.auth.models import User
import graphene
from graphene_django import DjangoObjectType
from graphql import GraphQLError

from .models import Regex, Rating
from .util import get_re_explanation


class UserType(DjangoObjectType):
    class Meta:
        model = User
        only_fields = ('id', 'username', 'email')


class RegexType(DjangoObjectType):
    class Meta:
        model = Regex
        only_fields = ('id', 'expression', 'explanation', 'date', 'author')


class RatingType(DjangoObjectType):
    class Meta:
        model = Rating


class CreateUser(graphene.Mutation):
    user = graphene.Field(UserType)

    class Arguments:
        username = graphene.String()
        password = graphene.String()
        email = graphene.String()

    def mutate(self, info, username, password, email):
        user = User(
            username=username,
            email=email
        )

        user.set_password(password)
        user.save()

        return CreateUser(user=user)


class CreateRegex(graphene.Mutation):
    id = graphene.Int()
    expression = graphene.String()
    explanation = graphene.String()
    date = graphene.String()
    author = graphene.Field(UserType)

    class Arguments:
        expression = graphene.String()

    def mutate(self, info, expression):
        user = info.context.user
        if user.is_anonymous:
            raise GraphQLError('You must be logged in!')
        explanation = get_re_explanation(expression)
        if explanation:
            regex = Regex(expression=expression, explanation=explanation, author=user)
            regex.save()

            return CreateRegex(
                id=regex.id,
                expression=regex.expression,
                explanation=regex.explanation,
                date=regex.date,
                author=regex.author
            )
        else:
            raise GraphQLError('Invalid expression')


class DeleteRegex(graphene.Mutation):
    result = graphene.String()

    class Arguments:
        id = graphene.Int()

    def mutate(self, info, id):
        user = info.context.user
        if user.is_anonymous:
            raise GraphQLError('You must be logged in!')
        item = Regex.objects.get(id=id)
        if item.author != user:
            raise GraphQLError('Wrong user!')
        else:
            item.delete()
            return DeleteRegex(result="Regex was deleted")


class CreateOrUpdateRating(graphene.Mutation):
    result = graphene.String()

    class Arguments:
        id = graphene.Int()
        mark = graphene.Int()

    def mutate(self, info, id, mark):
        user = info.context.user
        if user.is_anonymous:
            raise GraphQLError('You must be logged in!')
        r = Regex.objects.filter(id=id).first()
        if user == r.author:
            raise GraphQLError('Author cannot add mark to regex')
        obj, created = Rating.objects.get_or_create(user=user, regex=r)
        obj.mark = mark
        obj.save()
        if created:
            return CreateOrUpdateRating(result="Mark created")
        else:
            return CreateOrUpdateRating(result="Mark updated")


class Query(graphene.ObjectType):
    regex = graphene.List(
        RegexType,
        search=graphene.String(),
        first=graphene.Int(),
        skip=graphene.Int()
    )
    me = graphene.Field(UserType)
    get_rating = graphene.Field(graphene.Float, id=graphene.NonNull(graphene.Int))
    user_mark = graphene.Field(graphene.Float, id=graphene.NonNull(graphene.Int))

    def resolve_regex(self, info, search=None, first=None, skip=None, **kwargs):
        qs = Regex.objects.all()
        if search:
            qs = qs.filter(Q(expression__contains=search))
        if skip:
            qs = qs[skip:]
        if first:
            qs = qs[first:]
        return qs

    def resolve_me(self, info, **kwargs):
        user = info.context.user
        if user.is_anonymous:
            raise GraphQLError('Not logged in!')
        return user

    def resolve_get_rating(self, info, id=None, **kwargs):
        res = Rating.objects.filter(regex__id=id).aggregate(Avg('mark'))['mark__avg'] or 0.
        return res

    def resolve_user_mark(self, info, id=None, **kwargs):
        user = info.context.user
        if user.is_anonymous:
            raise GraphQLError('Not logged in!')
        res = Rating.objects.filter(user=user, regex__id=id).first()
        if res:
            return float(res.mark)
        return 0.


class Mutation(graphene.ObjectType):
    create_user = CreateUser.Field()
    create_regex = CreateRegex.Field()
    delete_regex = DeleteRegex.Field()
    set_mark = CreateOrUpdateRating.Field()