from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.conf import settings
from django.urls import reverse_lazy

from courses.models import Course, CourseStudent, Class
from courses.workspaces.models import Workspace

#FIXME: remove has_name dependency. Is this really needed?
from courses.utils import hash_name


class CourseCertification(models.Model):
    TYPES = (
        ('receipt', _('Receipt')),
        ('certificate', _('Certificate')),
    )

    type = models.CharField(
        _('Certificate Type'),
        choices=TYPES,
        max_length=127,
    )
    course_student = models.OneToOneField(
        CourseStudent,
        models.CASCADE,
        verbose_name=_('Enrollment'),
        related_name='certificate',
    )
    created_date = models.DateTimeField(
        _('Created'),
        auto_now_add=True,
    )
    modified_date = models.DateTimeField(
        _('Last modified'),
        auto_now=True,
    )
    is_valid = models.BooleanField(
        _('Certificate is valid'),
        default=False,
    )
    course_workload = models.TextField(
        _('Workload'),
        blank=True,
    )
    course_total_units = models.IntegerField(
        _('Total units'),
        blank=True,
    )
    link_hash = models.CharField(
        _('Hash'),
        max_length=255,
        unique=True,
    )

    @property
    def student(self):
        return self.course_student.user

    @property
    def course(self):
        return self.course_student.course

    @property
    def get_approved_process(self):
        return CertificationProcess.objects.get(course_certification=self.id,
                                                approved=True)

    @property
    def get_absolute_url(self):
        return reverse_lazy('courses_legacy:certificate', args=[self.link_hash])

    # FIXME: this is a compatibility patch and must be removed in the future
    @property
    def document_type(self):
        return self.type

    def save(self, *args, **kwargs):
        self.course_workload = self.course_student.course.workload
        self.course_total_units = self.course_student.units_done.count()
        super(CourseCertification, self).save(*args, **kwargs)

    class Meta:
        verbose_name = _("Certificate")

    def __str__(self):
        return '({0}): {1}'.format(self.course_student, self.is_valid)


class Evaluation(models.Model):
    min_grade = models.IntegerField(
        _('Evaluation grade needed'),
        blank=True,
    )
    date = models.DateTimeField(
        _('Evaluation date'),
        blank=True,
    )
    results_date = models.DateTimeField(
        _('Evaluation results date'),
        blank=True,
    )
    instructions = models.CharField(
        _('Comments'),
        max_length=255,
    )
    klass = models.ForeignKey(
        Class,
        models.CASCADE,
        verbose_name=_('Class'),
        related_name='evaluations',
    )

    class Meta:
        verbose_name = _('Evaluation')

    def __str__(self):
        return '({0}): {1}'.format(self.klass, self.instructions)


class CertificationProcess(models.Model):

    student = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        models.CASCADE,
        verbose_name=_('Student'),
        related_name='processes',
    )
    course_certification = models.ForeignKey(
        CourseCertification,
        models.CASCADE,
        null=True,
        related_name="processes",
        verbose_name=_('Certificate'),
    )
    comments = models.CharField(
        _('Comments'),
        max_length=255,
        null=True,
        blank=True,
    )
    created_date = models.DateTimeField(
        _('Created'),
        auto_now_add=True,
    )
    evaluation_grade = models.IntegerField(
        _('Evaluation grade'),
        blank=True,
        null=True,
    )
    approved = models.BooleanField(
        _('Approved'),
        default=False,
    )
    no_show = models.BooleanField(
        _('No show'),
        default=False,
    )
    evaluation = models.ForeignKey(
        Evaluation,
        models.SET_NULL,
        verbose_name=_('Evaluation'),
        blank=True,
        null=True,
        related_name='processes',
    )
    klass = models.ForeignKey(
        Class,
        models.CASCADE,
        verbose_name=_('Class'),
        related_name='processes',
    )
    active = models.BooleanField(
        _('Active'),
        default=True,
    )

    @property
    def certification_progress(self):
        return {
            'receipt': self.course_certification is not None,
            'grade': self.evaluation_grade is not None,
            'approved': self.approved
        }

    class Meta:
        verbose_name = _("Certification Process")

    def __str__(self):
        return '({0}): {1}'.format(
            self.course_certification.course_student.user, self.evaluation)


class CertificateTemplate(models.Model):
    TYPES = (
        ('receipt', _('Receipt')),
        ('certificate', _('Certificate')),
    )

    course = models.ForeignKey(
        Course,
        models.CASCADE,
        verbose_name=_('Course'),
    )
    role = models.CharField(
        _('Role'),
        max_length=128,
        blank=True,
        null=True,
    )
    name = models.CharField(
        _('Signature Name'),
        blank=True,
        max_length=255,
        null=True,
    )
    second_role = models.CharField(
        _('Second Role'),
        max_length=128,
        blank=True,
        null=True,
    )
    second_name = models.CharField(
        _('Second Signature Name'),
        blank=True,
        max_length=255,
        null=True,
    )
    cert_logo = models.ImageField(
        _('Logo'),
        null=True,
        blank=True,
        upload_to=hash_name('logo', 'organization_name'),
    )
    base_logo = models.ImageField(
        _('Logo'),
        null=True,
        blank=True,
        upload_to=hash_name('base_logo', 'organization_name'),
    )
    signature = models.ImageField(
        _('Signature'),
        null=True,
        blank=True,
        upload_to=hash_name('signature', 'organization_name'),
    )
    second_signature = models.ImageField(
        _('Second Signature'),
        null=True,
        blank=True,
        upload_to=hash_name('second_signature', 'organization_name'),
    )
    site_logo = models.ImageField(
        _('Site Logo'),
        null=True,
        blank=True,
        upload_to='certificates_files'
    )
    organization_name = models.CharField(
        _('Name'),
        max_length=255,
        blank=True,
        null=True,
    )
    text = models.TextField(_('Content'), default='')

    document_type = models.CharField(
        _('Certificate Type'),
        choices=TYPES,
        max_length=127,
        default=TYPES[0][0]
    )

    workspace = models.ForeignKey(
        Workspace,
        models.CASCADE,
        null=True
    )

    class Meta:
        verbose_name = _('Certificate Template')
        unique_together = ('workspace', 'course', 'document_type')

    def __str__(self):
        return '({0})'.format(self.course)

    @property
    def cert_logo_url(self):
        if self.cert_logo:
            return self.cert_logo.url
        return ''

    @property
    def base_logo_url(self):
        if self.base_logo:
            return self.base_logo.url
        return ''

    @property
    def signature_url(self):
        if self.signature:
            return self.signature.url
        return ''

    @property
    def second_signature_url(self):
        if self.second_signature:
            return self.second_signature.url
        return ''

    @property
    def site_logo_url(self):
        if self.site_logo:
            return self.site_logo.url
        return ''

    @property
    def contract(self):
        return self.workspace