import pytz
from datetime import datetime, timedelta

from rest_framework.test import APITestCase
from rest_framework import status
from http.cookies import SimpleCookie

from account.models import User
from news.models import News, NewsType

from django.test import TestCase
from translation.models import Language
from django.core import exceptions
from .serializers import validate_tjson

from establishment.models import Establishment, EstablishmentType, Employee


class BaseTestCase(APITestCase):

    def setUp(self):

        self.username = 'sedragurda'
        self.password = 'sedragurdaredips19'
        self.email = 'sedragurda@desoz.com'
        self.newsletter = True
        self.user = User.objects.create_user(
            username=self.username, email=self.email, password=self.password)

        # get tokkens
        tokkens = User.create_jwt_tokens(self.user)
        self.client.cookies = SimpleCookie(
            {'access_token': tokkens.get('access_token'),
             'refresh_token': tokkens.get('refresh_token'),
             'locale': "en"
             })


class TranslateFieldTests(BaseTestCase):

    def setUp(self):
        super().setUp()

        self.news_type = NewsType.objects.create(name="Test news type")

        self.news_item = News.objects.create(
            created_by=self.user,
            modified_by=self.user,
            title={
                "en-GB": "Test news item",
                "ru-RU": "Тестовая новость"
            },
            description={"en-GB": "Test description"},
            playlist=1,
            start=datetime.now(pytz.utc) + timedelta(hours=-13),
            end=datetime.now(pytz.utc) + timedelta(hours=13),
            is_publish=True,
            news_type=self.news_type,
            slug='test',
        )

    def test_model_field(self):
        self.assertIsNotNone(getattr(self.news_item, "title_translated", None))

    def test_read_locale(self):
        response = self.client.get(f"/api/web/news/slug/{self.news_item.slug}/", format='json')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        news_data = response.json()

        self.assertIn("title_translated", news_data)

        self.assertEqual(news_data['title_translated'], "Test news item")


class BaseAttributeTests(BaseTestCase):

    def setUp(self):
        super().setUp()

        self.establishment_type = EstablishmentType.objects.create(name="Test establishment type")
        self.establishment = Establishment.objects.create(
            name="Test establishment",
            establishment_type_id=self.establishment_type.id,
            is_publish=True
        )

    def test_base_attr_api(self):
        data = {
            'user': self.user.id,
            'name': 'Test name'
        }

        response = self.client.post('/api/back/establishments/employees/', data=data)
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

        response_data = response.json()
        self.assertIn("id", response_data)

        employee = Employee.objects.get(id=response_data['id'])

        self.assertEqual(self.user, employee.created_by)
        self.assertEqual(self.user, employee.modified_by)

        modify_user = User.objects.create_user(
            username='sedragurda2',
            password='sedragurdaredips192',
            email='sedragurda2@desoz.com',
        )

        modify_tokkens = User.create_jwt_tokens(modify_user)
        self.client.cookies = SimpleCookie(
            {'access_token': modify_tokkens.get('access_token'),
             'refresh_token': modify_tokkens.get('refresh_token'),
             'locale': "en"
             })

        update_data = {
            'name': 'Test new name'
        }

        response = self.client.patch('/api/back/establishments/employees/1/', data=update_data)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        employee.refresh_from_db()
        self.assertEqual(modify_user, employee.modified_by)
        self.assertEqual(self.user, employee.created_by)


class ValidJSONTest(TestCase):

    def test_valid_json(self):
        lang = Language.objects.create(title='English', locale='en-GB')
        lang.save()

        data = 'str'

        with self.assertRaises(exceptions.ValidationError) as err:
            validate_tjson(data)

        self.assertEqual(err.exception.code, 'invalid_json')

        data = {
            "string": "value"
        }

        with self.assertRaises(exceptions.ValidationError) as err:
            validate_tjson(data)

        self.assertEqual(err.exception.code, 'invalid_translated_keys')

        data = {
            "en-GB": "English"
        }

        try:
            validate_tjson(data)
            self.assertTrue(True)
        except exceptions.ValidationError:
            self.assert_(False, "Test json translated FAILED")