class Story(models.Model):
    title = models.CharField(max_length=200)
    story = models.CharField(max_length=1000)
    name = models.CharField(max_length=200)
    longitude = models.FloatField()
    latitude = models.FloatField()
    location = models.CharField(max_length=200)
    tag = models.CharField(max_length=200)
    date = models.DateTimeField(auto_now_add=True)
    notifyAdmin = models.BooleanField(default=False)

    def __str__(self):
        return self.title

class Translation(models.Model):
    story_id = models.ForeignKey('Story', on_delete=models.CASCADE)
    language = models.CharField(max_length=3)
    title_trans = models.CharField(max_length=200)
    story_trans = models.CharField(max_length=1000)
    
    class Meta:
        unique_together = (("story_id", "language"),)
    
    def __str__(self):
        return self.title_trans

from django.http.response import HttpResponse
from rest_framework.response import Response
from ..models import *
import requests
import environ
import json
from rest_framework import status
from ..serializers import *
from rest_framework.generics import GenericAPIView

env = environ.Env()
environ.Env.read_env('.env')

class TranslationView(GenericAPIView):
    """ 
    Retrieves translation of a story 
    Target is specified as a language code: 'de', 'en','tr' etc.
    """
    queryset = Story.objects.all()
    serializer_class = StorySerializer
    def retrieve_translation(story_id, target):
        """ Retrieves translation if it exists in the database."""
        try:
            translation = Translation.objects.get(story_id = story_id, language = target)
        except:
            return False        
        return translation

    def get(self, request, pk, target):
        try:
            story = Story.objects.get(pk=pk)
            story_dict = StorySerializer(story).data
        except:
            return Response("Story does not exist.",status=status.HTTP_404_NOT_FOUND)

        check_translation = TranslationView.retrieve_translation(pk,target)
        if check_translation: 
            # translation is retrieved from the database
            story_dict['title'] = check_translation.title_trans
            story_dict['story'] = check_translation.story_trans
            return Response(story_dict)
        else:
            new_trans = translate(story,target) # request translation from external API
            if 'error' in new_trans:
                return Response(new_trans['error'],new_trans['status'])
            else:
                story_dict['title'] = new_trans['title_trans']
                story_dict['story'] = new_trans['story_trans']     
                return Response(story_dict) # return translated story
            
def check_story_length(title,body):
    """ Returns false for short stories. """
    if len(title) < 6 or len(title.split()) < 2:
        return False
    if len(body) < 10 or len(body.split()) < 2:  
        return False
    return True


def translate(story, target):
    """ Sends post request to IBM Watson Translator API. The source language is automatically detected. 
        The API may not be able to identify the source language if the string is too short (1 word)
        Returns a JSON of the translated story if the request is successful.
        target : language code, e.g. "de","es","tr"
    """
    headers = {
        'Content-Type': 'application/json',
        'charset' : 'utf-8'
    }
    URL = 'https://api.eu-gb.language-translator.watson.cloud.ibm.com/instances/b2d14a2d-97d0-4b45-8f44-b3b993729db1'
    version = '2018-05-01'
    apikey = env('TRANSLATE_KEY')
    auth = ('apikey', apikey)

    if not check_story_length(story.title,story.story):
        return {'error':"Too short to translate.",'status' : status.HTTP_400_BAD_REQUEST}

    data = json.dumps({"text": [story.title,story.story],"target":target})    
    response = requests.post(f'{URL}/v3/translate?version={version}', headers=headers, data=data, auth=auth)
    
    if response.status_code == 200:
        response_json = response.json()
        title_trans = response_json['translations'][0]['translation'] # translation of title
        story_trans = response_json['translations'][1]['translation']         
        translated_fields = {'title_trans':title_trans, 'story_trans':story_trans}
        return translated_fields
    else :
       return {'error':response.json()['error'], 'status':status.HTTP_404_NOT_FOUND} # return the error response of IBM Translator API
       

from django.test import TestCase,Client
from ..views.view_translationAPI_niyazi import * 


class CheckStoryLengthTest(TestCase):

    def test_short_title(self):
        title = "hey"
        body = "It was a sunny day."
        self.assertFalse(check_story_length(title,body))
    
    def test_short_body(self):
        title = "We went to the cinema."
        body = "beautiful"
        self.assertFalse(check_story_length(title,body))

    def test_false_title_type(self):
        title = 1957
        body = "What a nice year!"
        self.assertRaises(TypeError, check_story_length, title, body)
        
    def test_false_body_type(self):
        title = "We went to the cinema."
        body = 23.948429
        self.assertRaises(TypeError, check_story_length, title, body)
    
    def test_correct_input(self):
        title = "We went to the cinema."
        body = "It was a sunny day."
        self.assertTrue(check_story_length(title,body))

class TranslationTest(TestCase):
    def setUp(self):
        Story.objects.create(id = 1,
            title = "Title",
            story = "Story",
            name = "User1",
            longitude = 41,
            latitude = 28,
            location = "Istanbul",
            tag = "Tag1",
            notifyAdmin = False
        )
        Story.objects.create(id = 2,
            title = "Hello World!",
            story = "I am very happy today!",
            name = "User2",
            longitude = 33,
            latitude = 40,
            location = "Ankara",
            tag = "Tag2",
            notifyAdmin = True
        )

    def test_only_get_requests(self):
        c=Client()
        resp_1=c.post("/api/story/2/translate_es/")
        resp_2=c.put("/api/story/2/translate_es/")
        resp_3=c.delete("/api/story/2/translate_es/")
        self.assertEqual(resp_1.status_code,405)
        self.assertEqual(resp_2.status_code,405)
        self.assertEqual(resp_3.status_code,405)

    def test_when_story_does_not_exist(self):
        c=Client()
        resp=c.get("/api/story/3/translate_ne/")
        self.assertEqual(resp.status_code,404)
    
    def test_when_translator_api_fails(self):
        c=Client()
        resp=c.get("/api/story/2/translate_nosuchlanguage/")
        self.assertEqual(resp.status_code,404)

    def test_short_story(self):
        c=Client()
        resp=c.get("/api/story/1/translate_jp/")
        self.assertEqual(resp.status_code,400)
        
    def test_works_correct(self):  
        c=Client()  
        resp=c.get("/api/story/2/translate_tr/")
        self.assertEqual(resp.status_code,200)