import graphene
from graphene import relay
from graphene_django import DjangoObjectType
from graphene_django.filter import DjangoFilterConnectionField

from api.utils import get_object
from books.models import Book, Topic, Module, Chapter, ContentBlock
from books.schema.queries import BookNode, TopicNode, ModuleNode, ContentBlockNode


class FilteredChapterNode(DjangoObjectType):
    content_blocks = DjangoFilterConnectionField(ContentBlockNode)

    class Meta:
        model = Chapter
        only_fields = [
            'slug', 'title',
        ]
        filter_fields = [
            'slug', 'title',
        ]
        interfaces = (relay.Node,)

    def resolve_content_blocks(self, *args, **kwargs):
        return ContentBlock.get_by_parent(self)


class BookQuery(object):
    book = relay.Node.Field(BookNode)
    topic = relay.Node.Field(TopicNode)
    module = graphene.Field(ModuleNode, slug=graphene.String())
    chapter = relay.Node.Field(FilteredChapterNode)
    content_block = relay.Node.Field(ContentBlockNode)

    books = DjangoFilterConnectionField(BookNode)
    topics = DjangoFilterConnectionField(TopicNode)
    modules = DjangoFilterConnectionField(ModuleNode)
    chapters = DjangoFilterConnectionField(FilteredChapterNode)

    def resolve_books(self, *args, **kwargs):
        return Book.objects.filter(**kwargs).live()

    def resolve_topics(self, *args, **kwargs):
        return Topic.objects.filter(**kwargs).live()

    def resolve_modules(self, *args, **kwargs):
        return Module.objects.filter(**kwargs).live()

    def resolve_chapters(self, *args, **kwargs):
        return Chapter.objects.filter(**kwargs).live()

    def resolve_module(self, info, **kwargs):
        slug = kwargs.get('slug')
        id = kwargs.get('id')

        if id is not None:
            return get_object(Module, id)
        if slug is not None:
            return Module.objects.get(slug=slug)
        return None