from pyramid.httpexceptions import HTTPBadRequest

from planio.lib.views import RESTView
from . import schemes
from planio.serializers import set_serializer_schema, serialize


class Checks(RESTView):
    """Check list view
    """
    def get(self):
        """
        items := {plans, checklists, tasks}
        .. http:get:: /items/:id/checks

            Get checks list

            :statuscode 200: OK
        """
        objs = self.context.list()
        return self.serialize(schemes.check_strict, objs)

    def post(self):
        """
        .. http:post:: /items/:id/checks

            Create new check

            :statuscode 200: OK
        """
        if 'check_id' in self.request.json_body:
            raise HTTPBadRequest

        data = self.request.json_body.copy()
        obj = self.context.create(**data)
        return self.serialize(schemes.check_strict, obj)

    def serialize(self, schema, objs):
        if not isinstance(objs, list):
            return Check.serialize(schema, objs)

        result = []
        for obj in objs:
            result.append(Check.serialize(schema, obj))
        return result
        



class Check(RESTView):
    """Check view
    """
    def get(self):
        """
        items := {plans, checklists, tasks}
        .. http:get:: /items/:id/checks/:id

            Get check

            :statuscode 200: OK
        """
        obj = self.context.get()
        return Check.serialize(schemes.check_strict, obj)

    def delete(self):
        """
        .. items/:id/checks/:id

            Delete check

            :statuscode 200: OK
        """
        return self.context.remove()

    def patch(self):
        """
        .. items/:id/checks/:id

            Update check

            :statuscode 200: OK
        """
        if 'check_id' in self.request.json_body:
            raise HTTPBadRequest

        check = self.context.update(**self.request.json_body)
        return Check.serialize(schemes.check_strict, check)

    def put(self):
        """
        .. http:put:: items/:id/checks/:id

            Resave check

            :statuscode 200: OK
        """
        if 'check_id' in self.request.json_body:
            raise HTTPBadRequest

        check = self.context.save(**self.request.json_body)
        return Check.serialize(schemes.check_strict, check)

    @set_serializer_schema(schemes.check_info)
    def start_get(self):
        """
        .. http:get:: /items/:id/checks/:id/start

            start check

            (копируем, заполняя user и id)
            Вернётся новый id теста {'id': '8734ad2312515'}.
            :statuscode 200: OK

        """
        return self.context.start()

    @staticmethod
    def serialize(schema, obj):
        questions = []
        for question in obj.questions:
            questions.append(question.serialize())

        del obj.questions
        result = serialize(schema, obj)
        result['questions'] = questions

        return result


class ChecksInfo(RESTView):
    """Check list view which user started
    """
    serializer_schema = [schemes.check_info]

    def get(self):
        """
        .. http:get:: /checks

            Get list of tests which began user 

            :statuscode 200: OK
        """

        return self.context.list()


class CheckInfo(RESTView):
    """view for info about one test 
       which user started
    """
    serializer_schema = schemes.check_info

    def get(self):
        """
        .. http:get:: /checks/:id

            Get check test which began user 

            :statuscode 200: OK
        """

        return self.context.get()


class Question(RESTView):
    """
    """
    def get(self):
        """
        .. http:get:: /checks/:id/questions/:id

            Get question from test 

            :statuscode 200: OK
        """
        
        return self.context.get().serialize()

    def patch(self):
        """
        .. /checks/:id/questions/:id

            Update question from test

            :statuscode 200: OK
        """

        question = self.context.update(**self.request.json_body)

        return question.serialize()