from django.db.models.fields.files import ImageField
from django.db.models.fields.related import ForeignKey
from django.db import models
from django.utils import timezone
import tagulous
import tagulous.models


from django.core.files.storage import FileSystemStorage
from django.conf import settings
from django.utils.html import format_html

from django.urls import reverse

from django.utils.translation import ugettext_lazy as _
from django.utils.html import mark_safe

from sortedm2m.fields import SortedManyToManyField

import string

from anatomy.models import Modality

from generic.models import Examination, Condition, Sign
#from generic.models import Examination, Site, Condition, Sign

from easy_thumbnails.files import get_thumbnailer

image_storage = FileSystemStorage(
    # Physical file location ROOT
    location=u"{0}/longs/".format(settings.MEDIA_ROOT),
    # Url for file
    base_url=u"{0}longs/".format(settings.MEDIA_URL),
)

def image_directory_path(instance, filename):
    return u"picture/{0}".format(filename)


def findMiddle(input_list):
    middle = float(len(input_list))/2
    if middle % 2 != 0:
        return input_list[int(middle - .5)]
    else:
        return (input_list[int(middle)])
        return (input_list[int(middle)], input_list[int(middle-1)])

class Long(models.Model):
    #author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
    #image = models.ImageField()
    history = models.TextField(null=True, blank=True)

    feedback = models.TextField(null=True, blank=True)

    condition = tagulous.models.TagField(
        to=Condition,
        blank=True,
        help_text=
        "Associated condition. Will allow searching / filtering and tips / hints to be displayed. Conditions with spaces must be enclosed in quotes \"...\""
    )

    sign = tagulous.models.TagField(
        to=Sign, blank=True, help_text='Radiological signs in the question')

    # Model answers
    model_observations = models.TextField(null=True, blank=True)
    model_interpretation = models.TextField(null=True, blank=True)
    model_principle_diagnosis = models.TextField(null=True, blank=True)
    model_differential_diagnosis = models.TextField(null=True, blank=True)
    model_management = models.TextField(null=True, blank=True)


    DEFAULT_SITE_ID = 1
    #site = models.ManyToManyField(
    #    Site,
    #    blank=True,
    #    default=DEFAULT_SITE_ID,
    #    help_text=
    #    "If we know the source of the image")
    verified = models.BooleanField(default=False)
    created_date = models.DateTimeField(default=timezone.now)
    published_date = models.DateTimeField(blank=True, null=True)
    author = models.ManyToManyField(settings.AUTH_USER_MODEL,
                                    blank=True,
                                    help_text='Author of question',
                                    related_name="long_authored_questions")

    scrapped = models.BooleanField(
        default=False,
        help_text='Question has been scrapped and will not be shown')

    open_access = models.BooleanField(
        help_text="If an question should be freely available to browse", default=True
    )


    def get_absolute_url(self):
        return reverse('longs:long_detail', kwargs={'pk': self.pk})

    def get_authors(self):
        """Returns a comma seperated text list of authors"""
        authors = ", ".join([i.username for i in self.author.all()])
        return authors

    def __str__(self):
        examinations = [series.get_examination() for series in self.series.all()]
        return "{} : {}".format(self.history, ", ".join(examinations))

    def GetExams(self):
        e = self.exams.all().values_list("name", flat=True)
        exams = ", ".join(e)
        return exams


    def GetImages(self, feedback=False):
        qs = self.images.all()

        if not feedback:
            images = [i.image for i in qs if not i.feedback_image]
        else:
            images = [i.image for i in qs]

        return images

    def GetImageUrls(self):
        return ",".join(["http://penracourses.org.uk{}".format(i.url) for i in self.GetImages()])
    #def GetNonFeedbackQuestionImages(self):
        #return self.GetImages()

class LongSeriesImage(models.Model):
    image = models.ImageField(upload_to=image_directory_path, storage=image_storage)
    position = models.IntegerField(default=0)
    series = models.ForeignKey("LongSeries", related_name="images", on_delete=models.SET_NULL, null=True)


class LongSeries(models.Model):
    modality = models.ForeignKey(Modality, related_name="series_modality", on_delete=models.SET_NULL, null=True)
    examination = models.ForeignKey(
        Examination, help_text="Name of the examination", related_name="series_examination", on_delete=models.SET_NULL, null=True)
    long = models.ForeignKey("Long", help_text="The question this series should be associated with", related_name="series", on_delete=models.SET_NULL, null=True)
    description = models.TextField(blank=True, help_text="Description of stack, for admin organisation, will not be visible when taking")

    def __str__(self):
        return "{} : {} [{}]".format(self.get_examination(), self.description, self.long.pk)

    def get_examination(self):
        """Returns a comma seperated text list of regions"""
        return str(self.examination)

    def get_absolute_url(self):
        return reverse('longs:long_series_detail', kwargs={'pk': self.pk})

    def get_image_urls(self, feedback=False):
        images = ["http://penracourses.org.uk{}".format(i.image.url) for i in self.images.all()]

        return ",".join(images)

    def get_thumbnail(self):
        img = findMiddle(self.images.all()).image
        thumbnailer = get_thumbnailer(img)
        thumbnail = thumbnailer["exam-list"]
        return thumbnail



    def get_block(self):
        examination = self.get_examination()
        return format_html('<div>{}<br/><img src="/media/{}" /></div>', examination, self.get_thumbnail() )

#class LongImage(models.Model):
#    long = models.ForeignKey(Long,
#                              related_name="images",
#                              on_delete=models.CASCADE)
#    image = models.ImageField(upload_to=image_directory_path, storage=image_storage)
#
#    feedback_image = models.BooleanField(default=False)
#
#    def image_tag(self):
#        if self.image:
#            return mark_safe(
#                '<img src="{}" class="admin-long-image" /><span class="admin-long-image-info">Click and hold to zoom<span>'
#                .format(self.image.url))
#        else:
#            return ""
#
#    image_tag.short_description = 'Image'


class Note(models.Model):
    long = models.ForeignKey(Long,
                              related_name="long_notes",
                              on_delete=models.CASCADE,
                              null=True)
    #author = models.ForeignKey(User,
    author = models.ForeignKey( settings.AUTH_USER_MODEL,
                               related_name="long_notes",
                               on_delete=models.CASCADE)
    note = models.TextField()
    created_on = models.DateTimeField(auto_now_add=True)

    def get_absolute_url(self):
        self.pk = self.long_id
        return reverse('longs:long_detail', kwargs={'pk': self.pk})

    def __str__(self):
        return "{} [{}] {}".format(self.long, self.author, self.created_on)


class LongCreationDefault(models.Model):
    #author = models.OneToOneField(User,
    author = models.OneToOneField(
        settings.AUTH_USER_MODEL,
                                  related_name="long_default",
                                  on_delete=models.CASCADE)

    #site = models.ManyToManyField(
    #    Site,
    #    blank=True,
    #    default=1,
    #    help_text="Default site to use when creating a new long")

    def get_absolute_url(self):
        return reverse('longs:long_create')


class Exam(models.Model):
    name = models.CharField(max_length=200)
    exam_questions = SortedManyToManyField(
        Long, related_name="exams", blank="true"
    )

    active = models.BooleanField(
        help_text="If an exam should be available", default=True
    )

    publish_results = models.BooleanField(
        help_text="If an exams results should be available", default=True
    )

    recreate_json = models.BooleanField(
        help_text="If the json cache needs updating", default=False
    )

    time_limit = models.IntegerField(
        help_text="Exam time limit (in seconds). Default is 2100 secondse (35 minutes)", default=2100
    )

    def __str__(self):
        return self.name

    def get_absolute_url(self):
        return reverse("longs:exam_overview", kwargs={"pk": self.pk})

    def get_exam_name(self):
        return self.name

    def get_json_url(self):
        return reverse("longs:exam_json", args=(self.pk,))

    def get_question_index(self, question):
        return list(self.exam_questions.all()).index(question)

class CidUserAnswer(models.Model):
    """User answers by candidate"""

    question = models.ForeignKey(
        Long, related_name="cid_user_answers", on_delete=models.CASCADE
    )


    # Answers
    answer_observations = models.TextField(null=True, blank=True)
    answer_interpretation = models.TextField(null=True, blank=True)
    answer_principle_diagnosis = models.TextField(null=True, blank=True)
    answer_differential_diagnosis = models.TextField(null=True, blank=True)
    answer_management = models.TextField(null=True, blank=True)

    cid = models.BigIntegerField(blank=True, null=True, help_text="Candidate ID (limitied by BigIntegerField size)")

    # Each user answer is associated with a particular exam
    exam = models.ForeignKey(
        Exam, related_name="cid_user_answers", on_delete=models.CASCADE, null=True
    )

    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    def __str__(self):
        try:
            exam = self.exam
        except (Exam.DoesNotExist, KeyError) as e:
            exam = "None"
        return "{}/{}/{}: {}".format(
            exam, self.cid, self.question.GetPrimaryAnswer(), self.answer
        )

    def save(self, *args, **kwargs):
        self.clean()
        return super(CidUserAnswer, self).save(*args, **kwargs)

    def clean(self):
        if self.answer:
            self.answer = self.answer.strip()

            s = self.answer.lower()
            s = s.translate(str.maketrans('', '', string.punctuation))

            self.answer_compare = s

    # def get_compare_string(self):
    #     # strip here should be unneccasry (providing clean is now working)
    #     s = self.answer.lower().strip()
    #     s = s.translate(str.maketrans('', '', string.punctuation))
    #     return s

    def get_answer_score(self):
        q = self.question

        # First step we check that the normal/abnormal states match
        if q.normal != self.normal:
            # If they don't match the answer is wrong (score is 0)
            return 0
        # If both are normal full marks
        elif q.normal and self.normal:
            return 2

        # Then compare answer strings (as per anatomy questions)
        ans = self.answer_compare
        if (
            q.answers.filter(
                answer_compare__iexact=ans, status=Answer.MarkOptions.CORRECT
            ).first()
            is not None
        ):
            mark = 2
        elif (
            q.answers.filter(
                answer_compare__iexact=ans, status=Answer.MarkOptions.HALF_MARK
            ).first()
            is not None
        ):
            mark = 1
        elif q.answers.filter(
            answer_compare__iexact=ans, status=Answer.MarkOptions.INCORRECT
        ).first():
            mark = 0
        else:
            mark = "unmarked"
        return mark