"""Tests for webapp."""

from django.test import TestCase
from django.core.files import File
from django.contrib.auth.models import User
from rest_framework.test import APITestCase
from rest_framework import status
from rest_framework.test import force_authenticate
from webapp.models import Tag, Feed
from webapp.serializers import TagSerializer, FeedSerializer

from collections import OrderedDict
from itertools import islice
import tempfile


class TagsTestCase(APITestCase):

    def setUp(self):
        self.icon = tempfile.NamedTemporaryFile(suffix=".jpg").name
        Tag.objects.create(slug='Party', name='Bileet', icon=self.icon)

    def test_get_single_tag(self):
        self.assertEqual(Tag.objects.count(), 1)
        response = self.client.get('/api/tags/', format='json')
        self.assertTrue(status.is_success(response.status_code))

        # We dont care about icon, so response is sliced
        sliced_response = OrderedDict(islice(response.data['results'][0].items(), 3))
        tag1 = Tag.objects.get(slug="Party")
        self.assertEqual(sliced_response, {'id': tag1.id, 'slug': 'Party', 'name': 'Bileet'})

    def test_get_single_tag_serializer(self):
        response = self.client.get('/api/tags/', format='json')
        self.assertTrue(status.is_success(response.status_code))

        tags = Tag.objects.all()
        serializer = TagSerializer(tags, many=True)
        # Icon on serializer is returned without protocol and domain
        # Assert these individually
        resp_icon = response.data['results'][0].pop('icon')
        serial_icon = serializer.data[0].pop('icon')
        self.assertEqual(response.data['results'], serializer.data)
        self.assertEqual(resp_icon, "http://testserver" + serial_icon)

    def test_get_multiple_tags(self):
        self.assertEqual(Tag.objects.count(), 1)
        Tag.objects.create(slug='Freshmen', name='Fuksit', icon=self.icon)
        Tag.objects.create(slug='International', name='Ulkkarit', icon=self.icon)
        self.assertEqual(Tag.objects.count(), 3)

        response = self.client.get('/api/tags/', format='json')
        self.assertTrue(status.is_success(response.status_code))

        # We dont care about icon, so response is sliced
        tag1 = Tag.objects.get(slug="Party")
        sliced_response = OrderedDict(islice(response.data['results'][0].items(), 3))
        self.assertEqual(sliced_response, {'id': tag1.id, 'slug': 'Party', 'name': 'Bileet'})
        sliced_response = OrderedDict(islice(response.data['results'][1].items(), 3))
        tag2 = Tag.objects.get(slug="Freshmen")
        self.assertEqual(sliced_response, {'id': tag2.id, 'slug': 'Freshmen', 'name': 'Fuksit'})
        sliced_response = OrderedDict(islice(response.data['results'][2].items(), 3))
        tag3 = Tag.objects.get(slug="International")
        self.assertEqual(sliced_response, {'id': tag3.id, 'slug': 'International', 'name': 'Ulkkarit'})

    def test_create_tag(self):
        self.assertEqual(Tag.objects.count(), 1)
        response = self.client.post('/api/tags/', {'slug': 'Test', 'name': 'Testinimi', 'icon': self.icon}, format='multipart')
        self.assertFalse(status.is_success(response.status_code))
        self.assertEqual(Tag.objects.count(), 1)

    def test_invalid_tag(self):
        self.assertEqual(Tag.objects.count(), 1)
        response = self.client.get('/api/tags/15', format='json', follow=True)
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)


class FeedTestCase(APITestCase):

    def setUp(self):
        self.icon = tempfile.NamedTemporaryFile(suffix=".jpg").name
        Tag.objects.create(slug='testtag1', name='test1', icon=self.icon)
        tag1 = Tag.objects.get(slug="testtag1")
        Tag.objects.create(slug="testtag2", name='test2', icon=self.icon)
        tag2 = Tag.objects.get(slug="testtag2")
        self.assertEqual(Tag.objects.count(), 2)

        Feed.objects.create(title="TestFeed", visible=True, description="diidadaapa", content="lorem ipsum")
        Feed.objects.get(title="TestFeed").tags.add(tag1)
        Feed.objects.get(title="TestFeed").tags.add(tag2)
        self.assertEqual(Feed.objects.count(), 1)
        self.assertEqual(Feed.objects.all()[0].tags.count(), 2)

        username, password = 'test_admin', 'password123'
        self.authClient = User.objects.create_superuser(username, 'myemail@test.com', password)

    def test_get_feed(self):
        response = self.client.get('/api/feed/', format='json')
        self.assertTrue(status.is_success(response.status_code))

        feeds = Feed.objects.all()
        serializer = FeedSerializer(feeds, many=True)

        # DRF extends path given by serializer with the protocol and domain for icon
        # Ignore tag on serializer and response. This is tested on TagTestCase.
        # Note that we assume the length here to be 1
        response.data['results'][0].pop('tags')
        serializer.data[0].pop('tags')
        self.assertEqual(response.data['results'], serializer.data)

    def test_post_feed(self):
        Tag.objects.create(slug="test1", name="testsds")
        Tag.objects.create(slug="test2", name="testsdsd")
        tag1_id = Tag.objects.get(slug="test1").id
        tag2_id = Tag.objects.get(slug="test2").id

        data = {'tags': [tag1_id, tag2_id], 'title': 'testtitle', 'visible': 'True', 'description': 'liirumlaarum', 'content': 'lorem ipsum'}
        # Try post without authentication
        response = self.client.post('/api/feed/', data, format='multipart')
        self.assertTrue(status.is_client_error(response.status_code))
        self.assertEqual(Feed.objects.count(), 1)
        # Authenticate
        self.client.force_authenticate(user=self.authClient)
        response = self.client.post('/api/feed/', data, format='multipart')
        # Return success and check object was created
        self.assertTrue(status.is_success(response.status_code))
        self.assertEqual(Feed.objects.count(), 2)

        created = Feed.objects.get(title="testtitle")
        print(created.tags)
        # self.assertEqual(created.tags.count(), 2)