from datetime import timedelta

from django.test import TestCase
from django.utils import timezone

from jobs.models import Job
from jobs.status import (
    job_accepts_applications,
    job_is_closed,
    job_is_expired,
    job_is_ongoing,
    job_needs_deadline_to_reactivate,
    open_jobs_q,
)


class JobStatusTests(TestCase):
    def test_expired_job_is_closed_but_can_stay_active_flag(self):
        deadline = timezone.localdate() - timedelta(days=1)
        self.assertTrue(job_is_expired(deadline))
        self.assertTrue(job_is_closed(is_active=True, deadline=deadline))
        self.assertFalse(job_accepts_applications(is_active=True, deadline=deadline))

    def test_manual_close_without_deadline(self):
        self.assertFalse(job_is_expired(None))
        self.assertTrue(job_is_closed(is_active=False, deadline=None))
        self.assertFalse(job_accepts_applications(is_active=False, deadline=None))

    def test_open_job_with_future_deadline(self):
        deadline = timezone.localdate() + timedelta(days=7)
        self.assertFalse(job_is_closed(is_active=True, deadline=deadline))
        self.assertTrue(job_accepts_applications(is_active=True, deadline=deadline))

    def test_open_ongoing_job_stays_open_until_company_closes(self):
        self.assertTrue(job_is_ongoing(None))
        self.assertFalse(job_is_closed(is_active=True, deadline=None))
        self.assertTrue(job_accepts_applications(is_active=True, deadline=None))
        self.assertFalse(job_needs_deadline_to_reactivate(is_active=True, deadline=None))

    def test_ongoing_job_only_closed_when_company_deactivates(self):
        self.assertTrue(job_is_closed(is_active=False, deadline=None))
        self.assertFalse(job_needs_deadline_to_reactivate(is_active=False, deadline=None))

    def test_open_jobs_q_supports_related_prefix(self):
        q = open_jobs_q('jobs')
        self.assertIn('jobs__is_active', str(q))
        self.assertIn('jobs__deadline__isnull', str(q))

    def test_expired_job_needs_new_deadline_to_reactivate(self):
        deadline = timezone.localdate() - timedelta(days=1)
        self.assertTrue(job_needs_deadline_to_reactivate(is_active=True, deadline=deadline))

    def test_job_model_properties(self):
        job = Job(
            title='Test',
            slug='test-job',
            company_name='Co',
            company_initials='C',
            location='Lusaka',
            description='Desc',
            responsibilities='A',
            requirements='B',
            deadline=timezone.localdate() - timedelta(days=2),
            is_active=True,
        )
        self.assertTrue(job.is_expired)
        self.assertTrue(job.is_closed)
        self.assertFalse(job.accepts_applications)

    def test_ongoing_job_model_properties(self):
        job = Job(
            title='Ongoing',
            slug='ongoing-job',
            company_name='Co',
            company_initials='C',
            location='Lusaka',
            description='Desc',
            responsibilities='A',
            requirements='B',
            deadline=None,
            is_active=True,
        )
        self.assertTrue(job.is_ongoing)
        self.assertFalse(job.is_closed)
        self.assertTrue(job.accepts_applications)