import json

from django.contrib.auth import get_user_model

from django.core.urlresolvers import reverse

from renkanmanager.models import Renkan, Revision

from rest_framework import status

from rest_framework.test import APITestCase

User = get_user_model()

class RenkanTests(APITestCase):

    def setUp(self):

        User.objects.create_superuser("blop", "blop@blop.com", "blop")

        self.user = User.objects.get_by_natural_key(username="blop")

        # POSTing test workspace

        post_url = reverse("v1.0:workspace_list")

        test_title = "bleh_title"

        data = {"title": test_title}

        post_response = self.client.post(post_url, data, format="json")

        self.test_workspace_guid = json.loads(post_response.content.decode()).get("id")

        self.first_test_title = "test_title_1"

        self.first_test_content_dict = {

            "id": "",

            "title": "test_title_1",

            "description": "test_description_1",

            "created": "2016-03-11 15:10:10.645193+00:00",

            "updated": "2016-03-11 15:10:10.645193+00:00",

            "edges": [],

            "nodes": [],

            "users": [],

            "space_id": "",

            "views": []

        }

        self.first_test_content = json.dumps(self.first_test_content_dict)

        self.second_test_title = "test_title_2"

        self.second_test_content_dict = {

            "id": "",

            "title": "test_title_2",

            "description": "test_description_2",

            "created": "2016-03-11 15:10:10.645193+00:00",

            "updated": "2016-03-12 15:10:10.645193+00:00",

            "edges": [],

            "nodes": [],

            "users": [],

            "space_id": "",

            "views": []

        }

        self.second_test_content = json.dumps(self.second_test_content_dict)

        self.third_test_title = "test_title_3"

        self.third_test_content_dict = {

            "id": "",

            "title": "test_title_3",

            "description": "test_description_3",

            "created": "2016-03-11 15:10:10.645193+00:00",

            "updated": "2016-03-13 15:10:10.645193+00:00",

            "edges": [],

            "nodes": [],

            "users": [],

            "space_id": "",

            "views": []

        }

        self.third_test_content = json.dumps(self.third_test_content_dict)

    def test_create_renkan(self):

        ###################################################

        # POSTing new Renkan

        ###################################################

        post_url = reverse("v1.0:renkan_list")

        data = {"title": self.first_test_title, "content": self.first_test_content}

        post_response = self.client.post(post_url, data, format="json")

        self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)

        self.assertEqual(Renkan.objects.count(), 1)

        self.assertEqual(Revision.objects.count(), 1)

        # Checking POSTed Renkan data

        post_response_dict = json.loads(post_response.content.decode())

        post_response_content_dict = json.loads(post_response_dict.get("content", "{}"))

        new_renkan_guid = post_response_dict.get("id", "")

        new_renkan = Renkan.objects.get(renkan_guid=new_renkan_guid)

        # GUIDs and username

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), post_response_dict.get("created_by", ""))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), post_response_dict.get("last_updated_by", ""))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), getattr(new_renkan.creator, User.USERNAME_FIELD))

        # Content and title extracted from revision

        self.assertEqual(new_renkan.title, self.first_test_title)

        new_renkan_content_dict = json.loads(new_renkan.content)

        for key in list(self.first_test_content_dict.keys()) + list(set(new_renkan_content_dict.keys()) - set(self.first_test_content_dict.keys())):

            if key != "updated" and key != "created" and key != "id":

                self.assertEqual(new_renkan_content_dict.get(key, ""), self.first_test_content_dict.get(key, ""))

        # Revision count

        self.assertEqual(new_renkan.revision_count, 1)

        self.assertEqual(post_response_dict.get("revision_count", ""), 1)

        # Checking POSTed Renkan revision data

        new_renkan_revision_guid = post_response_dict.get("current_revision_id", "")

        new_renkan_revision = Revision.objects.get(revision_guid = new_renkan_revision_guid)

        # GUIDs and username

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), getattr(new_renkan_revision.creator, User.USERNAME_FIELD))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), getattr(new_renkan_revision.last_updated_by, User.USERNAME_FIELD))

        # Title and content

        #    in the response

        self.assertEqual(post_response_dict.get("title", ""), self.first_test_title)

        for key in list(self.first_test_content_dict.keys()) + list(set(post_response_content_dict.keys()) - set(self.first_test_content_dict.keys())):

            if key != "updated" and key != "created" and key != "id":

                self.assertEqual(post_response_content_dict.get(key, ""), self.first_test_content_dict.get(key, ""))

        #    in the database

        self.assertEqual(new_renkan_revision.title, self.first_test_title)

        new_revision_content_dict = json.loads(new_renkan_revision.content)

        for key in list(self.first_test_content_dict.keys()) + list(set(new_revision_content_dict.keys()) - set(self.first_test_content_dict.keys())):

            if key != "updated" and key != "created" and key != "id":

                self.assertEqual(new_revision_content_dict.get(key, ""), self.first_test_content_dict.get(key, ""))

        # Checking permission

        self.assertTrue(self.user.has_perm("view_renkan", new_renkan))

        ###################################################

        # POSTing new Renkan into workspace

        ###################################################

        post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})

        data = {"title": self.second_test_title, "content": self.second_test_content}

        post_response = self.client.post(post_url, data, format="json")

        self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)

        self.assertEqual(Renkan.objects.count(), 2)

        self.assertEqual(Revision.objects.count(), 2)

        # Checking POSTed Renkan data

        post_response_dict = json.loads(post_response.content.decode())

        new_renkan_guid = post_response_dict.get("id", "")

        new_renkan = Renkan.objects.get(renkan_guid=new_renkan_guid)

        # GUIDs and username

        self.assertEqual(self.test_workspace_guid, post_response_dict.get("workspace_id", ""))

        self.assertEqual(self.test_workspace_guid, new_renkan.workspace.workspace_guid)

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), post_response_dict.get("created_by", ""))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), post_response_dict.get("last_updated_by", ""))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), getattr(new_renkan.creator, User.USERNAME_FIELD))

        # Content and title extracted from revision

        self.assertEqual(new_renkan.title, self.second_test_title)

        new_renkan_content_dict = json.loads(new_renkan.content)

        for key in list(self.second_test_content_dict.keys()) + list(set(new_renkan_content_dict.keys()) - set(self.second_test_content_dict.keys())):

            if key != "updated" and key != "created" and key != "id" and key != "space_id":

                self.assertEqual(new_renkan_content_dict.get(key, ""), self.second_test_content_dict.get(key, ""))

        # Revision count

        self.assertEqual(new_renkan.revision_count, 1)

        self.assertEqual(post_response_dict.get("revision_count", ""), 1)

        ###################################################

        # POSTing new Renkan with no content

        ###################################################

        post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})

        test_title = "bleh_title_2"

        data = {"title": test_title}

        post_response = self.client.post(post_url, data, format="json")

        self.assertEqual(post_response.status_code, status.HTTP_201_CREATED)

        self.assertEqual(Renkan.objects.count(), 3)

        self.assertEqual(Revision.objects.count(), 3)

        ###################################################

        # POSTing with wrong workspace_guid

        ###################################################

        post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": "bleh-bad-workspace-guid"})

        data = {"title": self.third_test_title, "content": self.third_test_content}

        post_response = self.client.post(post_url, data, format="json")

        self.assertEqual(post_response.status_code, status.HTTP_404_NOT_FOUND)

        ###################################################

        # POSTing with non-JSON serializable content

        ###################################################

        post_url = reverse("v1.0:renkan_list")

        data = {"title": self.third_test_title, "content": "notJson(Serializable}"}

        post_response = self.client.post(post_url, data, format="json")

        self.assertEqual(post_response.status_code, status.HTTP_400_BAD_REQUEST)

    def test_get_renkan(self):

        ###################################################

        # POSTing new Renkan

        ###################################################

        post_url = reverse("v1.0:renkan_list")

        data = {}

        post_response = self.client.post(post_url, data, format="json")

        post_response_dict = json.loads(post_response.content.decode())

        new_renkan_guid = post_response_dict.get("id", "")

        new_revision_guid = post_response_dict.get("current_revision_id", "")

        ###################################################

        # GETting posted Renkan

        ###################################################

        get_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid":new_renkan_guid})

        get_response = self.client.get(get_url, format="json")

        self.assertEqual(get_response.status_code, status.HTTP_200_OK)

        # Checking GET data

        get_response_dict = json.loads(get_response.content.decode())

        self.assertEqual(new_renkan_guid, get_response_dict.get("id", ""))

        self.assertEqual(new_revision_guid, get_response_dict.get("current_revision_id", ""))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), get_response_dict.get("created_by", ""))

        self.assertEqual(getattr(self.user, User.USERNAME_FIELD), get_response_dict.get("last_updated_by", ""))

        ###################################################

        # GETting with wrong guid

        ###################################################

        get_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": "bad-id"})

        get_response = self.client.get(get_url, format="json")

        self.assertEqual(get_response.status_code, status.HTTP_404_NOT_FOUND)

    def test_get_renkan_list(self):

        ###################################################

        # POSTing new Renkans

        ###################################################

        post_url = reverse("v1.0:renkan_list")

        first_data = {"title": self.first_test_title, "content": self.first_test_content}

        second_data = {"title": self.second_test_title, "content": self.second_test_content}

        self.client.post(post_url, first_data, format="json")

        self.client.post(post_url, second_data, format="json")

        ###################################################

        # GETting posted Renkans

        ###################################################

        get_url = post_url

        get_response = self.client.get(get_url, format="json")

        self.assertEqual(get_response.status_code, status.HTTP_200_OK)

        get_response_content = json.loads(get_response.content.decode()) # Should be a list

        self.assertTrue(isinstance(get_response_content, list))

        self.assertEqual(len(get_response_content), 2)

        ###################################################

        # POSTing new Renkan into workspace

        ###################################################

        post_url = reverse("v1.0:renkan_list_workspace", kwargs={"workspace_guid": self.test_workspace_guid})

        third_data = {"title": self.third_test_title, "content": self.third_test_content}

        self.client.post(post_url, third_data, format="json")

        ###################################################

        # GETting posted Renkans

        ###################################################

        get_url = post_url

        get_response = self.client.get(get_url, format="json")

        self.assertEqual(get_response.status_code, status.HTTP_200_OK)

        get_response_content = json.loads(get_response.content.decode()) # Should be a list

        self.assertTrue(isinstance(get_response_content, list))

        self.assertEqual(len(get_response_content), 1)

    def test_update_renkan(self):

        ###################################################

        # POSTing new Renkan

        ###################################################

        post_url = reverse("v1.0:renkan_list")

        data = {}

        post_response = self.client.post(post_url, data, format="json")

        post_response_dict = json.loads(post_response.content.decode())

        post_response_ts = json.loads(post_response_dict.get("content"), "{}").get("updated", "")

        renkan_guid = post_response_dict.get("id", "")

        revision_guid = post_response_dict.get("current_revision_id", "")

        ###################################################

        # PUTting by updating current revision

        ###################################################

        put_url = reverse("v1.0:renkan_detail", kwargs={"renkan_guid": renkan_guid})

        put_content_dict = json.loads(self.first_test_content)

        put_content_dict["updated"] = post_response_ts

        put_data = {

            "title" : self.first_test_title,

            "content" : json.dumps(put_content_dict),

            "create_new_revision": False

        }

        put_response = self.client.put(put_url, put_data, format="json")

        self.assertEqual(put_response.status_code, status.HTTP_200_OK)

        put_response_dict = json.loads(put_response.content.decode())

        put_response_content_dict = json.loads(put_response_dict.get("content", "{}"))

        put_response_ts = put_response_content_dict.get("updated", "")

        # checking we"re still on the same revision as the initial one

        updated_project = Renkan.objects.get(renkan_guid=renkan_guid)

        self.assertEqual(revision_guid, put_response_dict.get("current_revision_id", ""))

        self.assertEqual(put_response_dict.get("revision_count", ""), 1)

        self.assertEqual(updated_project.revision_count, 1)

        self.assertEqual(revision_guid, updated_project.current_revision.revision_guid)

        # checking data was updated

        #     in the reponse

        self.assertEqual(put_response_dict.get("title", ""), self.first_test_title)

        for key in list(self.first_test_content_dict.keys()) + list(set(put_response_content_dict.keys()) - set(self.first_test_content_dict.keys())):

            if key != "updated" and key!= "id" and key != "space_id":

                self.assertEqual(put_response_content_dict.get(key, ""), self.first_test_content_dict.get(key, ""))

        #     in the database

        updated_revision = Revision.objects.get(revision_guid=revision_guid)

        updated_revision_content_dict = json.loads(updated_revision.content)

        self.assertEqual(updated_revision.title, self.first_test_title)

        for key in list(self.first_test_content_dict.keys()) + list(set(updated_revision_content_dict.keys()) - set(self.first_test_content_dict.keys())):

            if key != "updated" and key!= "id" and key != "space_id":

                self.assertEqual(updated_revision_content_dict.get(key, ""), self.first_test_content_dict.get(key, ""))

        ###################################################

        # PUTting by creating a new revision

        ###################################################

        put_content_dict = json.loads(self.second_test_content)

        put_content_dict["updated"] = put_response_ts

        put_data = {

            "title" : self.second_test_title,

            "content" : json.dumps(put_content_dict),

            "create_new_revision": True

        }

        put_response = self.client.put(put_url, put_data, format="json")