# The 4 "Create / Add / Schedule" buttons: full CRUD behaviour
import json
from datetime import timedelta

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase
from django.utils import timezone

from Employee.models import Department, EmployeeDT
from Recruitment.tests import cl, mk_company, mk_emp


class FourFormsTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("f1@x.com"), mk_company("f2@x.com")
        self.a, self.b = cl(self.co), cl(self.other)
        self.mgr = mk_emp(self.co, "MGR00001", "Amit")
        self.iv = mk_emp(self.co, "INT00001", "Rahul")

    def j(self, r, code=None):
        if code:
            self.assertEqual(r.status_code, code, r.content)
        return r.json()

    # 1 + 2  Requisition and JD together
    def test_requisition_with_jd_in_one_call(self):
        Department.objects.create(company=self.co, name="Technology & Engineering")
        r = self.j(self.a.post("/api/recruitment/requisitions/", {
            "position_title": "Backend Dev", "department": "technology & engineering", "vacancies": 2,
            "hiring_manager": "MGR00001", "budget_min_lpa": 10, "budget_max_lpa": 20,
            "job_description": {"required_skills": ["Django", "Docker"], "experience_min_years": 3,
                                "experience_max_years": 6, "responsibilities": "Build APIs"}}, format="json"), 201)["data"]
        self.assertEqual(r["job_description"]["jd_code"], "JD-001")
        self.assertIsNotNone(r["department_id"])                      # name matched to Department
        # picker for "Create New JD via Requisition"
        r2 = self.j(self.a.post("/api/recruitment/requisitions/", {"position_title": "QA"}, format="json"), 201)["data"]
        no_jd = self.j(self.a.get("/api/recruitment/requisitions/?without_jd=true"), 200)["data"]
        self.assertEqual([x["id"] for x in no_jd], [r2["id"]])
        jd = self.j(self.a.post("/api/recruitment/job-descriptions/", {"requisition": r2["requisition_id"],
                                "required_skills": "Selenium"}, format="json"), 201)["data"]
        self.assertEqual(jd["jd_code"], "JD-002")
        self.assertEqual(self.j(self.a.get("/api/recruitment/requisitions/?without_jd=true"))["data"], [])
        # bad nested payload rolls the whole requisition back
        before = len(self.j(self.a.get("/api/recruitment/requisitions/"))["data"])
        bad = self.a.post("/api/recruitment/requisitions/", {"position_title": "X",
                          "job_description": {"experience_min_years": "abc"}}, format="json")
        self.assertEqual(bad.status_code, 400)
        self.assertEqual(len(self.j(self.a.get("/api/recruitment/requisitions/"))["data"]), before)
        self.assertEqual(self.a.post("/api/recruitment/requisitions/", {"position_title": "Y",
                         "budget_min_lpa": 30, "budget_max_lpa": 10}, format="json").status_code, 400)

    # 3  Add candidate: all 8 steps (multipart, nested JSON strings, files) + child CRUD
    def test_add_candidate_8_steps_and_child_crud(self):
        a = self.a
        req = self.j(a.post("/api/recruitment/requisitions/", {"position_title": "Dev"}, format="json"), 201)["data"]
        c = self.j(a.post("/api/recruitment/candidates/", {
            "name": "Meera S", "email": "meera@x.com", "phone_number": "9000011111",
            "date_of_birth": "1996-05-04", "gender": "Female", "marital_status": "Single",
            "current_address": "Pune", "same_as_current_address": "true",
            "requisition": req["requisition_id"], "recruiter": "MGR00001", "source": "Referral",
            "current_company": "Wipro", "total_experience_years": 4.2, "notice_period_days": 30,
            "current_ctc_lpa": 8, "expected_ctc_lpa": 11.5, "priority": "High",
            "education": json.dumps([{"highest_qualification": "B.Tech", "college_institute": "COEP", "passing_year": 2018}]),
            "experience": json.dumps([{"company_name": "Wipro", "designation": "TA", "start_date": "2019-01-01",
                                       "end_date": "2024-01-01", "previous_ctc": 8.0}]),
            "resume": SimpleUploadedFile("cv.pdf", b"%PDF-1"),
            "passport_photo": SimpleUploadedFile("p.png", b"\x89PNG")}, format="multipart"), 201)["data"]
        self.assertEqual(len(c["education"]), 1)
        self.assertEqual(len(c["experience"]), 1)
        self.assertEqual(c["personal"]["permanent_address"], "Pune")
        self.assertEqual(c["personal"]["date_of_birth"], "1996-05-04")
        self.assertIsNotNone(c["files"]["resume"])
        self.assertEqual(c["expected_ctc_lpa"], 11.5)
        # bad nested JSON -> clean 400 and nothing saved
        n = EmployeeDT.objects.count()
        bad = a.post("/api/recruitment/candidates/", {"name": "Z", "email": "z@x.com", "education": "{nope"}, format="multipart")
        self.assertEqual(bad.status_code, 400)
        self.assertEqual(EmployeeDT.objects.count(), n)
        # child CRUD: education
        e = self.j(a.post("/api/recruitment/candidate-education/", {"candidate": c["candidate_id"],
                   "highest_qualification": "M.Tech", "passing_year": 2021}, format="json"), 201)["data"]
        self.j(a.patch(f"/api/recruitment/candidate-education/{e['id']}/", {"percentage_cgpa": "8.4"}, format="json"), 200)
        self.assertEqual(len(self.j(a.get(f"/api/recruitment/candidate-education/?candidate={c['id']}"))["data"]), 2)
        self.assertEqual(a.post("/api/recruitment/candidate-education/", {"candidate": c["id"], "passing_year": "xx"},
                                format="json").status_code, 400)
        self.j(a.delete(f"/api/recruitment/candidate-education/{e['id']}/"), 200)
        self.assertEqual(a.get(f"/api/recruitment/candidate-education/{e['id']}/").status_code, 404)
        # child CRUD: experience (date validation)
        x = self.j(a.post("/api/recruitment/candidate-experience/", {"candidate": c["id"], "company_name": "TCS",
                   "start_date": "2015-01-01", "end_date": "2018-01-01"}, format="json"), 201)["data"]
        self.assertEqual(a.patch(f"/api/recruitment/candidate-experience/{x['id']}/",
                                 {"end_date": "2010-01-01"}, format="json").status_code, 400)
        self.j(a.delete(f"/api/recruitment/candidate-experience/{x['id']}/"), 200)
        # PATCH candidate step data
        up = self.j(a.patch(f"/api/recruitment/candidates/{c['id']}/", {"blood_group": "O+", "gender": "F"},
                            format="json"), 200)["data"]
        self.assertEqual(up["personal"]["blood_group"], "O+")
        # tenant isolation on the child endpoints
        self.assertEqual(self.b.get(f"/api/recruitment/candidate-education/?candidate={c['id']}").json()["data"], [])
        self.assertEqual(self.b.post("/api/recruitment/candidate-education/", {"candidate": c["id"]},
                                     format="json").status_code, 404)

    # 4  Schedule new round
    def test_schedule_round_extras(self):
        a = self.a
        c = self.j(a.post("/api/recruitment/candidates/", {"name": "R", "email": "r@x.com"}, format="json"), 201)["data"]
        nxt = self.j(a.get(f"/api/recruitment/interviews/next-round/?candidate={c['candidate_id']}"), 200)["data"]
        self.assertEqual((nxt["round_no"], nxt["suggested_round_name"]), (1, "HR Screening"))
        day = (timezone.now() + timedelta(days=3)).replace(hour=11, minute=0, second=0, microsecond=0)
        # schedule using the CAN-xxx code, with invite mail request
        i = self.j(a.post("/api/recruitment/interviews/", {"candidate": c["candidate_id"], "round_name": "HR Screening",
                   "interviewer": "INT00001", "scheduled_at": day.isoformat(), "mode": "Meet",
                   "notify": True}, format="json"), 201)
        self.assertIn(i["email_sent"], (True, False))
        av = self.j(a.get(f"/api/recruitment/interviews/availability/?interviewer=INT00001&date={day.date()}"), 200)["data"]
        self.assertEqual(len(av["busy"]), 1)
        self.assertEqual(self.j(a.get("/api/recruitment/interviews/availability/"))["code"], "VALIDATION")
        # reschedule
        iid = i["data"]["id"]
        later = (day + timedelta(hours=3)).isoformat()
        rs = self.j(a.post(f"/api/recruitment/interviews/{iid}/reschedule/", {"scheduled_at": later,
                   "reason": "Panel busy"}, format="json"), 200)
        self.assertEqual(self.j(a.get(f"/api/recruitment/interviews/{iid}/"))["data"]["notes"], "Rescheduled: Panel busy")
        self.assertEqual(a.post(f"/api/recruitment/interviews/{iid}/reschedule/", {}, format="json").status_code, 400)
        nxt2 = self.j(a.get(f"/api/recruitment/interviews/next-round/?candidate={c['id']}"))["data"]
        self.assertEqual(nxt2["suggested_round_name"], "Technical Round 1")
        # cancel then delete
        self.j(a.post(f"/api/recruitment/interviews/{iid}/cancel/"), 200)
        self.j(a.delete(f"/api/recruitment/interviews/{iid}/"), 200)
        self.assertEqual(a.get(f"/api/recruitment/interviews/{iid}/").status_code, 404)
        # other company cannot schedule for this candidate
        self.assertEqual(self.b.post("/api/recruitment/interviews/", {"candidate": c["candidate_id"], "round_name": "X",
                         "scheduled_at": later}, format="json").status_code, 404)
