from django.test import TestCase

from web.models import Appointment
from web.models import Visit
from web.models import StudySubject, Study
from web.tests.functions import get_test_study, create_study_subject, create_appointment, create_study_subject_with_multiple_screening_numbers
from web.tests.functions import create_visit


class SubjectModelTests(TestCase):

    def test_signal_mark_as_endpoint_reached(self):
        subject = create_study_subject()
        visit = create_visit(subject)
        appointment = create_appointment(visit)

        subject.endpoint_reached = True
        subject.save()
        appointment_status = Appointment.objects.filter(id=appointment.id)[
            0].status
        visit_finished = Visit.objects.filter(id=visit.id)[0].is_finished

        self.assertTrue(subject.endpoint_reached)
        self.assertTrue(visit_finished)
        self.assertEquals(
            Appointment.APPOINTMENT_STATUS_CANCELLED, appointment_status)

    def test_mark_as_endpoint_reached(self):
        subject = create_study_subject()
        visit = create_visit(subject)
        appointment = create_appointment(visit)

        subject.mark_as_endpoint_reached()
        appointment_status = Appointment.objects.filter(id=appointment.id)[
            0].status
        visit_finished = Visit.objects.filter(id=visit.id)[0].is_finished

        self.assertTrue(subject.endpoint_reached)
        self.assertTrue(visit_finished)
        self.assertEquals(
            Appointment.APPOINTMENT_STATUS_CANCELLED, appointment_status)

    def test_signal_mark_as_resigned(self):
        subject = create_study_subject()
        visit = create_visit(subject)
        appointment = create_appointment(visit)

        subject.resigned = True
        subject.save()
        appointment_status = Appointment.objects.filter(id=appointment.id)[
            0].status
        visit_finished = Visit.objects.filter(id=visit.id)[0].is_finished

        self.assertTrue(subject.resigned)
        self.assertTrue(visit_finished)
        self.assertEquals(
            Appointment.APPOINTMENT_STATUS_CANCELLED, appointment_status)

    def test_mark_as_resigned(self):
        subject = create_study_subject()
        visit = create_visit(subject)
        appointment = create_appointment(visit)

        subject.mark_as_resigned()
        appointment_status = Appointment.objects.filter(id=appointment.id)[
            0].status
        visit_finished = Visit.objects.filter(id=visit.id)[0].is_finished

        self.assertTrue(subject.resigned)
        self.assertTrue(visit_finished)
        self.assertEquals(
            Appointment.APPOINTMENT_STATUS_CANCELLED, appointment_status)

    def test_signal_mark_as_excluded(self):
        subject = create_study_subject()
        visit = create_visit(subject)
        appointment = create_appointment(visit)

        subject.excluded = True
        subject.save()
        appointment_status = Appointment.objects.filter(id=appointment.id)[
            0].status
        visit_finished = Visit.objects.filter(id=visit.id)[0].is_finished

        self.assertTrue(subject.excluded)
        self.assertTrue(visit_finished)
        self.assertEquals(
            Appointment.APPOINTMENT_STATUS_CANCELLED, appointment_status)

    def test_mark_as_excluded(self):
        subject = create_study_subject()
        visit = create_visit(subject)
        appointment = create_appointment(visit)

        subject.mark_as_excluded()
        appointment_status = Appointment.objects.filter(id=appointment.id)[
            0].status
        visit_finished = Visit.objects.filter(id=visit.id)[0].is_finished

        self.assertTrue(subject.excluded)
        self.assertTrue(visit_finished)
        self.assertEquals(
            Appointment.APPOINTMENT_STATUS_CANCELLED, appointment_status)

    def test_check_nd_number_regex(self):
        study = get_test_study()

        # delete everything
        StudySubject.objects.all().delete()
        # get default regex
        nd_number_study_subject_regex_default = Study._meta.get_field(
            'nd_number_study_subject_regex').get_default()

        self.assertTrue(StudySubject.check_nd_number_regex(nd_number_study_subject_regex_default, study))
        # this will add a studysubject with a NDnumber
        study_subject = create_study_subject(nd_number='ND0001')

        self.assertTrue(StudySubject.check_nd_number_regex(nd_number_study_subject_regex_default, study))
        # delete everything
        StudySubject.objects.all().delete()
        # this will add a studysubject with a NDnumber
        create_study_subject(nd_number='ND00001')
        self.assertFalse(StudySubject.check_nd_number_regex(nd_number_study_subject_regex_default, study))

    def test_sort_matched_screening_first(self):

        def create_result(phrase, subject_id=1):
            phrase = phrase.format(subject_id=subject_id)
            phrase = phrase.split(';')
            for i, r in enumerate(phrase):
                letter, num = phrase[i].strip().split('-')
                phrase[i] = (letter, int(num))
            return phrase

        subject = create_study_subject_with_multiple_screening_numbers(
            subject_id=1)
        self.assertEqual(subject.sort_matched_screening_first('L'), create_result(
            'L-00{subject_id}; E-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first(
            'L-00'), create_result('L-00{subject_id}; E-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first('E'), create_result(
            'E-00{subject_id}; L-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first(
            '-'), create_result('E-00{subject_id}; L-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first(''), create_result(
            'E-00{subject_id}; L-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first('001'), create_result(
            'E-00{subject_id}; L-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first('00'), create_result(
            'E-00{subject_id}; L-00{subject_id}', subject_id=1))
        self.assertEqual(subject.sort_matched_screening_first('potato'), create_result(
            'E-00{subject_id}; L-00{subject_id}', subject_id=1))

    def test_sort_matched_screening_first_bad_number(self):

        subject_id = 2
        screening_number = 'L-0/0{}; E-00{}; F-0/1{}'.format(subject_id, subject_id, subject_id)

        subject = create_study_subject_with_multiple_screening_numbers(
            subject_id=subject_id, screening_number=screening_number)

        self.assertEqual(subject.sort_matched_screening_first('E-'), [('E', subject_id), ('F', '0/12'), ('L', '0/02')])

        self.assertEqual(subject.sort_matched_screening_first('L-'), [('L', '0/02'), ('E', subject_id), ('F', '0/12')])

    def test_sort_matched_screening_first_bad_format(self):

        screening_number = 'potato; tomato'
        subject_id = 3
        subject = create_study_subject_with_multiple_screening_numbers(
            subject_id=subject_id, screening_number=screening_number)

        self.assertEqual(subject.sort_matched_screening_first('L-'), [('potato', None), ('tomato', None)])