# Document & Letter Issuance Center tests (letterhead, prefilled form, PDF format, B2B):
#   python manage.py test People.tests_letter_center
import io
from datetime import date
from unittest import mock

from django.core.files.uploadedfile import SimpleUploadedFile
from rest_framework.test import APITestCase

from Company.models import company_details
from Employee.models import Department, EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People import letter_data as ld, letter_format as lf
from People.letters import LEGACY_TEMPLATES, TEMPLATES
from People.models import (CompanyLetterhead, EmployeeExtra, EmployeeLetter, LetterTemplate, PromotionRequest,
                           TransferRequest)

LC = "/api/people/letter-center"
GL = "/api/people/generated-letters"
CIN = "U26939PN2013PTC146665"


def png(color=(20, 20, 20, 255), size=(120, 40), pad=0):
    from PIL import Image
    im = Image.new("RGBA", (size[0] + 2 * pad, size[1] + 2 * pad), (0, 0, 0, 0))
    im.paste(Image.new("RGBA", size, color), (pad, pad))
    b = io.BytesIO()
    im.save(b, "PNG")
    return b.getvalue()


def up(name="logo.png", data=None, ctype="image/png"):
    return SimpleUploadedFile(name, data or png(), content_type=ctype)


def pdf_text(data):
    try:
        from pypdf import PdfReader
        r = PdfReader(io.BytesIO(data))
        return "\n".join(p.extract_text() or "" for p in r.pages), len(r.pages), r
    except Exception:                                           # noqa: BLE001
        return None, None, None


class Base(APITestCase):
    def mk_company(self, n, name, **kw):
        return company_details.objects.create(email=f"lc{n}@x.com", password="pw", contact_no=f"97100000{n:02d}", status=True,
                                              is_verified=True, Registered_Company_Name=name, Company_address="Pune", **kw)

    def mk(self, co, code, name, email, role=None, gender="Male", desig="Software Programmer", dept=None, doj=date(2025, 5, 27), **kw):
        e = EmployeeDT.objects.create(company=co, employee_code=code, name=name, email=email, Gender=gender, Designation=desig,
                                      department=dept, Date_of_Joining=doj, is_active=True, **kw)
        EmployeeAccount.objects.create(employee=e, role=role)
        EmployeeExtra.objects.create(company=co, employee=e)
        return e

    def setUp(self):
        self.A = self.mk_company(1, "Glaze Rocks Private Limited", Website="www.glazerocks.com", REGISTERED_OFFICE_add="Wakad, Pune 411057")
        self.B = self.mk_company(2, "Beta Industries Ltd")
        hr = EmployeeRole.objects.create(company=self.A, role_name="HR", role_code="hr", can_view_employees=True,
                                         can_create_employees=True, can_edit_employees=True)
        ro = EmployeeRole.objects.create(company=self.A, role_name="RO", role_code="ro", can_view_employees=True)
        self.it = Department.objects.create(company=self.A, name="IT Department", code="IT")
        self.hr_e = self.mk(self.A, "HR001", "Hina HR", "hina@a.com", hr, "Female", "HR Manager", self.it)
        self.ro_e = self.mk(self.A, "RO001", "Rita RO", "rita@a.com", ro, "Female", "Analyst", self.it)
        self.div = self.mk(self.A, "EMP002", "Divyesh Patil", "div@a.com", None, "Male", "Software Programmer", self.it,
                           Work_Location="Pune, Maharashtra.", Current_Address="Pune Maharashtra.", Basic_Salary=20000)
        self.neha = self.mk(self.A, "EMP003", "Neha Singh", "neha@a.com", None, "Female", "Tester", self.it)
        self.bob = self.mk(self.B, "BOB001", "Bob Other", "bob@b.com", None, "Male", "Engineer")
        self.admin, self.admin_b = client_for(company_token(self.A)), client_for(company_token(self.B))
        self.hr, self.ro = client_for(employee_token(self.hr_e)), client_for(employee_token(self.ro_e))
        self.emp = client_for(employee_token(self.div))

    def letterhead(self, **kw):
        body = {"legal_name": "GLAZE ROCKS PVT LTD", "footer_name": "GLAZE ROCKS PRIVATE LIMITED", "short_name": "Glaze Rocks Pvt. Ltd.",
                "cin": CIN, "website": "www.glazerocksinterio.com", "place": "Pune",
                "registered_office": "Office # 206 & 207, Sonigara Landmark, Chatrapati Chowk Rd, Wakad, Pune 411057"}
        body.update(kw)
        return body

    def gen(self, lt, code="EMP002", variables=None, client=None, **kw):
        r = (client or self.admin).post(f"{GL}/generate/", {"letter_type": lt, "recipient_code": code, "variables": variables or {}, **kw}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        return r.json()["data"]

    def pdf_of(self, letter):
        l = EmployeeLetter.objects.get(pk=letter["id"])
        return l.pdf_file.read()


class Helpers(APITestCase):
    def test_indian_number_format_and_words(self):
        self.assertEqual(ld.inr(360000), "3,60,000.00")
        self.assertEqual(ld.inr("2,40,000"), "2,40,000.00")
        self.assertEqual(ld.inr(Decimal("1234567.5")) if False else ld.inr(1234567.5), "12,34,567.50")
        self.assertEqual(ld.inr("4.5"), "4,50,000.00")                                   # plain numbers below 1000 are lakhs
        self.assertEqual(ld.inr(None), "-")
        self.assertEqual(ld.words_indian(20000), "Twenty Thousand")
        self.assertEqual(ld.words_indian(240000), "Two Lakh Forty Thousand")
        self.assertEqual(ld.words_indian(10050000), "One Crore Fifty Thousand")
        self.assertEqual(ld.words_indian(0), "Zero")
        self.assertEqual(str(ld.parse_money("₹3,60,000.00 LPA")), "360000.00")

    def test_ordinal_and_dates(self):
        self.assertEqual([lf.ordinal_suffix(n) for n in (1, 2, 3, 4, 11, 12, 13, 21, 22, 23, 24, 30, 31)],
                         ["st", "nd", "rd", "th", "th", "th", "th", "st", "nd", "rd", "th", "th", "st"])
        self.assertEqual(ld.ordinal_date(date(2026, 4, 1)), "1st April 2026")
        self.assertIn("1<super>st</super> April 2026", lf.inline("01 April 2026", True))
        self.assertEqual(lf.inline("01 April 2026", False), "1 April 2026")
        self.assertEqual(lf.inline("a <b> & c"), "a &lt;b&gt; &amp; c")                  # text is always escaped

    def test_conditionals_and_plain_text(self):
        t = "A\n[[if x]]\nHAS X\n[[endif]]\n[[ifnot x]]\nNO X\n[[endif]]\nB"
        self.assertEqual(lf.apply_conditionals(t, {"x": "1"}).split("\n"), ["A", "HAS X", "B"])
        self.assertEqual(lf.apply_conditionals(t, {"x": "-"}).split("\n"), ["A", "NO X", "B"])
        self.assertEqual(lf.apply_conditionals(t, {}).split("\n"), ["A", "NO X", "B"])
        txt = lf.plain_text("[[ordinal_dates]]\n# TITLE\n>> **Date:** 1 May\n- point\n[[stampsign]]\nEnd ++u++")
        self.assertEqual(txt.split("\n"), ["TITLE", "Date: 1 May", "- point", "End u"])

    def test_user_values_cannot_inject_layout(self):
        self.assertTrue(ld.clean_value("[[image:stamp]]").startswith("[ ["))
        self.assertTrue(ld.clean_value("# Big title").startswith("\u200b"))
        self.assertTrue(ld.clean_value(">> right").startswith("\u200b"))
        self.assertEqual(ld.clean_value("line1\nline2"), "line1 line2")
        self.assertEqual(ld.clean_value("**bold** ok"), "**bold** ok")


from decimal import Decimal  # noqa: E402


class Letterhead(Base):
    def test_defaults_come_from_the_company_master(self):
        d = self.admin.get(f"{LC}/letterhead/").json()["data"]
        self.assertFalse(d["settings"]["configured"])
        self.assertEqual(d["effective"]["legal_name"], "Glaze Rocks Private Limited")
        self.assertEqual(d["effective"]["website"], "www.glazerocks.com")
        self.assertEqual(d["effective"]["registered_office"], "Wakad, Pune 411057")
        self.assertEqual(d["source"]["website"], "company master")
        self.assertEqual(d["source"]["cin"], "not set")
        self.assertEqual(d["effective"]["signatory_title"], "Authorized Signatory")
        self.assertEqual(d["images"]["logo"], {"url": None, "from": "none"})
        self.assertEqual(d["settings"]["policy_defaults"]["probation_months"], 3)

    def test_edit_json_then_multipart_images(self):
        r = self.admin.post(f"{LC}/letterhead/", self.letterhead(header_style="LOGO_ONLY", page_size="LETTER", body_font_size=10,
                                                                  footer_enabled=False, show_ref_no=True), format="json")
        self.assertEqual(r.status_code, 200, r.content)
        s = r.json()["data"]
        self.assertEqual((s["settings"]["cin"], s["settings"]["header_style"], s["settings"]["page_size"], s["settings"]["body_font_size"]),
                         (CIN, "LOGO_ONLY", "LETTER", 10))
        self.assertEqual((s["effective"]["legal_name"], s["source"]["legal_name"], s["source"]["website"]), ("GLAZE ROCKS PVT LTD", "letterhead", "letterhead"))
        r = self.admin.post(f"{LC}/letterhead/", {"logo": up("logo.png"), "stamp": up("stamp.png", png((200, 0, 0, 255), (60, 60), 20)),
                                                  "signature": up("sig.jpg", png((0, 0, 0, 255), (80, 30)), "image/jpeg"), "place": "Mumbai"},
                            format="multipart")
        self.assertEqual(r.status_code, 200, r.content)
        im = r.json()["data"]["images"]
        self.assertTrue(all(im[k]["from"] == "letterhead" and im[k]["url"] for k in ("logo", "stamp", "signature")))
        lh = CompanyLetterhead.objects.get(company=self.A)
        self.assertIn(f"letterheads/{self.A.pk}/", lh.logo.name)                           # per-company folder
        self.assertEqual(lh.place, "Mumbai")
        old = lh.logo.name
        r = self.admin.post(f"{LC}/letterhead/", {"logo": up("logo2.png", png((5, 5, 5, 255), (150, 50)))}, format="multipart")
        self.assertEqual(r.status_code, 200)
        lh.refresh_from_db()
        self.assertNotEqual(lh.logo.name, old)
        r = self.admin.post(f"{LC}/letterhead/", {"remove_logo": "true", "remove_stamp": True}, format="json")
        im = r.json()["data"]["images"]
        self.assertEqual((im["logo"]["from"], im["stamp"]["from"], im["signature"]["from"]), ("none", "none", "letterhead"))

    def test_company_master_logo_is_the_fallback(self):
        company_details.objects.filter(pk=self.A.pk).update(Company_logo="company_logos/master.png")
        d = self.admin.get(f"{LC}/letterhead/").json()["data"]
        self.assertEqual(d["images"]["logo"]["from"], "company master")

    def test_validation(self):
        for body in ({"cin": "123"}, {"header_style": "BIG"}, {"page_size": "A3"}, {"body_font_size": 5}, {"body_font_size": "x"},
                     {"legal_name": "x" * 201}, {"website": "javascript:alert(1)"}, {"website": "a b"},
                     {"policy_defaults": {"probation_months": 99}}, {"policy_defaults": {"nope": 1}}, {"policy_defaults": {"salary_disbursal": ""}},
                     {"policy_defaults": "not json"}, {"policy_defaults": [1]}, {"registered_office": "x" * 501}):
            self.assertEqual(self.admin.post(f"{LC}/letterhead/", body, format="json").status_code, 400, body)
        self.assertFalse(CompanyLetterhead.objects.exists())
        for f in (up("x.gif", b"GIF89a", "image/gif"), up("x.png", b"not an image"), up("big.png", b"0" * 1_600_000)):
            r = self.admin.post(f"{LC}/letterhead/", {"logo": f}, format="multipart")
            self.assertEqual(r.status_code, 400, f.name)
        self.assertFalse(CompanyLetterhead.objects.exists())

    def test_policy_and_cin_normalisation(self):
        r = self.admin.post(f"{LC}/letterhead/", {"cin": CIN.lower(), "policy_defaults": {"probation_months": 6, "salary_disbursal": "1st to 5th"}}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        s = r.json()["data"]["settings"]
        self.assertEqual((s["cin"], s["policy_defaults"]["probation_months"], s["policy_defaults"]["notice_confirmed_days"]), (CIN, 6, 30))

    def test_cin_cannot_be_registered_by_two_companies(self):
        self.admin.post(f"{LC}/letterhead/", self.letterhead(), format="json")
        r = self.admin_b.post(f"{LC}/letterhead/", {"cin": CIN}, format="json")
        self.assertEqual((r.status_code, r.json()["code"]), (409, "DUPLICATE"))
        self.assertNotIn("Glaze", r.content.decode())                                      # nothing about the other company
        self.assertEqual(self.admin_b.post(f"{LC}/letterhead/", {"cin": "L12345MH2000PLC123456"}, format="json").status_code, 200)
        self.assertEqual(self.admin.post(f"{LC}/letterhead/", {"cin": CIN, "place": "Pune"}, format="json").status_code, 200)   # own CIN again is fine

    def test_permissions_and_isolation(self):
        self.assertEqual(self.ro.get(f"{LC}/letterhead/").status_code, 200)
        self.assertEqual(self.ro.post(f"{LC}/letterhead/", {"place": "X"}, format="json").status_code, 403)
        self.assertEqual(self.hr.post(f"{LC}/letterhead/", self.letterhead(), format="json").status_code, 200)
        self.assertEqual(self.emp.get(f"{LC}/letterhead/").status_code, 403)
        self.assertEqual(self.client.get(f"{LC}/letterhead/").status_code, 401)
        self.assertEqual(self.admin_b.get(f"{LC}/letterhead/").json()["data"]["effective"]["legal_name"], "Beta Industries Ltd")
        self.assertFalse(CompanyLetterhead.objects.filter(company=self.B).exists())

    def test_sample_preview_pdf(self):
        self.admin.post(f"{LC}/letterhead/", {**self.letterhead(), "logo": up(), "stamp": up("s.png", png((200, 0, 0, 255), (60, 60)))}, format="multipart")
        r = self.admin.get(f"{LC}/letterhead/preview/")
        self.assertEqual((r.status_code, r["Content-Type"]), (200, "application/pdf"))
        self.assertTrue(r.content.startswith(b"%PDF"))
        text, pages, _ = pdf_text(r.content)
        if text is not None:
            self.assertIn("SAMPLE LETTER", text)
            self.assertIn(CIN, text)
            self.assertIn("GLAZE ROCKS PRIVATE LIMITED", text)


class Variables(Base):
    def test_revision_form_is_prefilled_from_the_models(self):
        EmployeeExtra.objects.filter(employee=self.div).update(reporting_manager=self.hr_e)
        EmployeeLetter.objects.create(company=self.A, employee=self.div, letter_type="OFFER", letter_no="OFF-2025-0001", body="x",
                                      issued_on=date(2025, 5, 27))
        d = self.admin.get(f"{LC}/variables/?letter_type=COMPENSATION_REVISION&recipient_code=EMP002").json()["data"]
        f = {x["key"]: x for x in d["fields"]}
        self.assertEqual((f["designation"]["value"], f["designation"]["source"]), ("Software Programmer", "Employee profile"))
        self.assertEqual(f["department"]["value"], "IT Department")
        self.assertEqual((f["work_location"]["value"], f["reporting_manager"]["value"], f["reporting_manager"]["source"]),
                         ("Pune, Maharashtra.", "Hina HR", "Reporting line"))
        self.assertEqual((f["offer_letter_date"]["value"], f["offer_letter_date"]["source"]), ("27 May 2025", "Earlier offer letter"))
        self.assertTrue(f["current_ctc"]["required"] and f["current_ctc"]["value"] == "")
        self.assertEqual(sorted(d["missing"]), ["current_ctc", "effective_date", "revision_title"][:0] or sorted(d["missing"]))
        self.assertIn("current_ctc", d["missing"])
        self.assertEqual(d["values"]["title_name"], "Mr Divyesh Patil")
        self.assertEqual(d["values"]["he_she"], "he")
        self.assertEqual(d["recipient"]["employee_code"], "EMP002")

    def test_hike_computes_the_revised_ctc(self):
        d = self.admin.post(f"{LC}/preview/", {"letter_type": "COMPENSATION_REVISION", "recipient_code": "EMP002",
                                               "variables": {"current_ctc": "300000", "hike_percent": "20", "effective_date": "1 April 2026"}}, format="json").json()["data"]
        v = d["variables"]
        self.assertEqual((v["revised_ctc_inr"], d["sources"]["revised_ctc"]), ("3,60,000.00", "Computed from current CTC and hike %"))
        self.assertIn("Previous CTC: ", d["body"])
        self.assertIn("3,00,000.00", d["body"])
        d2 = self.admin.post(f"{LC}/preview/", {"letter_type": "COMPENSATION_REVISION", "recipient_code": "EMP002",
                                                "variables": {"current_ctc": "300000", "revised_ctc": "345000"}}, format="json").json()["data"]
        self.assertEqual(d2["variables"]["hike_percent"], "15")                       # the other way round

    def test_promotion_transfer_and_exit_data_are_read(self):
        PromotionRequest.objects.create(company=self.A, employee=self.div, proposed_designation="Senior Programmer", proposed_grade="G5",
                                        hike_percent=Decimal("12.5"), effective_date=date(2026, 4, 1), status="Executed")
        TransferRequest.objects.create(company=self.A, employee=self.neha, effective_date=date(2026, 5, 1), reason="Team need")
        d = self.admin.get(f"{LC}/variables/?letter_type=PROMOTION&recipient_code=EMP002").json()["data"]
        f = {x["key"]: x for x in d["fields"]}
        self.assertEqual((f["new_designation"]["value"], f["new_grade"]["value"], f["hike_percent"]["value"], f["effective_date"]["value"]),
                         ("Senior Programmer", "G5", "12.5", "01 April 2026"))
        self.assertEqual(f["new_designation"]["source"], "Latest promotion record")
        t = self.admin.get(f"{LC}/variables/?letter_type=TRANSFER&recipient_code=EMP003").json()["data"]
        tf = {x["key"]: x for x in t["fields"]}
        self.assertEqual((tf["transfer_reason"]["value"], tf["effective_date"]["value"]), ("Team need", "01 May 2026"))

    def test_errors_and_isolation(self):
        for qs in ("letter_type=NOPE&recipient_code=EMP002", "recipient_code=EMP002", "letter_type=OFFER"):
            self.assertEqual(self.admin.get(f"{LC}/variables/?{qs}").status_code, 400, qs)
        self.assertEqual(self.admin.get(f"{LC}/variables/?letter_type=RELIEVING_EXPERIENCE&recipient_code=NOPE").status_code, 404)
        self.assertEqual(self.admin.get(f"{LC}/variables/?letter_type=RELIEVING_EXPERIENCE&recipient_code=BOB001").status_code, 404)     # other company
        self.assertEqual(self.ro.get(f"{LC}/variables/?letter_type=RELIEVING_EXPERIENCE&recipient_code=EMP002").status_code, 200)
        self.assertEqual(self.emp.get(f"{LC}/variables/?letter_type=RELIEVING_EXPERIENCE&recipient_code=EMP002").status_code, 403)

    def test_offer_for_a_candidate_uses_the_recruitment_offer(self):
        cand = EmployeeDT.objects.create(company=self.A, employee_code="CND900", name="Priti Candidate", email="priti@a.com", Employee_Status="Candidate",
                                         candidate_status="OFFERED", applied_position="Analyst", is_active=False, Gender="Female")
        r = self.admin.get(f"{LC}/variables/?letter_type=OFFER&recipient_code={cand.candidate_id or cand.employee_code}")
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(r.json()["data"]["values"]["title_name"], "Ms Priti Candidate")


class PdfFormat(Base):
    def setUp(self):
        super().setUp()
        self.admin.post(f"{LC}/letterhead/", {**self.letterhead(), "logo": up(), "stamp": up("s.png", png((200, 0, 0, 255), (60, 60), 20)),
                                              "signature": up("g.png", png((0, 0, 0, 255), (80, 30)))}, format="multipart")

    def issue(self, lt, day=date(2026, 9, 30), code="EMP002", **vars_):
        with mock.patch("django.utils.timezone.localdate", return_value=day):
            return self.gen(lt, code, vars_)

    def test_relieving_letter_has_the_letterhead_and_the_wording(self):
        l = self.issue("RELIEVING_EXPERIENCE", last_working_day=date(2026, 9, 30))
        data = self.pdf_of(l)
        self.assertTrue(data.startswith(b"%PDF"))
        text, pages, rd = pdf_text(data)
        self.assertEqual(l["body"].count("Dear Mr Divyesh Patil,"), 1)
        self.assertIn("30 September 2026", l["body"])
        self.assertIn("where you were employed as a **Software Programmer** from **27 May 2025** to **30 September 2026**", l["body"])
        if text is not None:
            self.assertEqual(pages, 1)
            self.assertRegex(text, r"CIN:\s*" + CIN)
            self.assertIn("Date: 30 September 2026", text)                                 # the letter date stays plain ...
            self.assertIn("from 27th May 2025 to 30th September 2026", text.replace("\n", " "))   # ... dates in the text are ordinal
            for part in ("GLAZE ROCKS PVT LTD", "Registered Office", "RELIEVING LETTER", "Dear Mr Divyesh Patil,",
                         "formally acknowledge and confirm your release from Glaze Rocks Pvt Ltd", "Software Programmer",
                         "For Glaze Rocks Pvt Ltd,", "Authorized Signatory", "Place: Pune", "GLAZE ROCKS PRIVATE LIMITED",
                         f"CIN# {CIN}", "URL : www.glazerocksinterio.com"):
                self.assertIn(part, text, part)
            self.assertIn("/XObject", str(rd.pages[0]["/Resources"]))                    # the logo image is drawn

    def test_revision_letter_matches_the_company_format(self):
        l = self.issue("COMPENSATION_REVISION", day=date(2026, 4, 24), revision_title="Mid Year appraisal", designation_line="Sr. Software Developer (Team Lead)",
                       effective_date=date(2026, 4, 1), current_ctc="300000", revised_ctc="360000", reporting_manager="Director / EA / HR",
                       offer_letter_date=date(2025, 5, 27), revision_note="Extra paragraph with **bold** text.")
        b = l["body"]
        for part in ("#~ Revision Letter", "**Subject: Compensation Revision : Mid Year appraisal**", "**A. Designation:** Sr. Software Developer (Team Lead)",
                     "**B. Department:** IT Department", "**C. Date of Revision:** 01 April 2026", "- Previous CTC: ", "3,00,000.00 LPA", "- Revised CTC: ",
                     "3,60,000.00 LPA", "**E. Work Location:** Pune, Maharashtra.", "**F. Reporting Manager:** Director / EA / HR",
                     "original offer letter dated 27 May 2025", "Extra paragraph with **bold** text.", "Date: 24/04/2026", "**Employee Acceptance**",
                     "I am Divyesh Patil, accept the revised terms"):
            self.assertIn(part, b, part)
        self.assertEqual(b.count("[[if"), 0)                                              # conditionals are resolved
        text, pages, rd = pdf_text(self.pdf_of(l))
        if text is not None:
            for part in ("Revision Letter", "Subject: Compensation Revision : Mid Year appraisal", "Previous CTC", "Revised CTC",
                         "Employee Acceptance", "Signature:", "Authorized Signatory", "Glaze Rocks Pvt. Ltd."):
                self.assertIn(part, text, part)
            self.assertIn("Date: 24/04/2026", text)
            self.assertNotIn("Registered Office", text)                                   # revision letter = logo-only header
            self.assertGreaterEqual(pages, 1)
            self.assertIn("CIN#", text)                                                   # but the footer is on every page

    def test_experience_certificate_uses_gender_and_titles(self):
        l = self.issue("EXPERIENCE_CERTIFICATE", code="EMP003", last_working_day=date(2026, 9, 30))
        self.assertIn("**Ms. Neha Singh**", l["body"])
        self.assertIn("During her tenure, she was actively involved", l["body"])
        self.assertIn("wish her every success in her future career endeavors", l["body"])
        m = self.issue("EXPERIENCE_CERTIFICATE", code="EMP002", last_working_day=date(2026, 9, 30))
        self.assertIn("**Mr. Divyesh Patil**", m["body"])
        self.assertIn("During his tenure, he was", m["body"])
        text, _, _ = pdf_text(self.pdf_of(m))
        if text is not None:
            self.assertIn("EXPERIENCE CERTIFICATE", text)
            self.assertIn("TO WHOMSOEVER IT MAY CONCERN", text)
            self.assertIn("For Glaze Rocks Private Limited", text)

    def test_offer_letter_salary_words_and_responsibilities(self):
        l = self.issue("OFFER", day=date(2026, 9, 15), ctc_annual="240000", joining_date=date(2026, 9, 16), designation="Executive HR",
                       responsibilities=[{"title": "Performance Management", "points": ["Design the framework", "Run appraisal cycles"]}])
        b = l["body"]
        self.assertIn("### Performance Management", b)
        self.assertIn("- Design the framework", b)
        self.assertIn("annual compensation of 2,40,000.00 per annum", b.replace("₹", "").replace("Rs. ", ""))
        self.assertIn("20,000.00 per month (Twenty Thousand Only)", b)
        self.assertIn("probation for a period of three (3) months", b)
        self.assertIn("seven (7) days' notice", b)
        self.assertIn("1st to 10th of every month", b)
        text, pages, _ = pdf_text(self.pdf_of(l))
        if text is not None:
            self.assertIn("OFFER LETTER", text)
            self.assertIn("Performance Management", text)
            self.assertIn("Design the framework", text)

    def test_offer_without_responsibilities_omits_that_section(self):
        b = self.issue("OFFER", ctc_annual="240000")["body"]
        self.assertNotIn("Roles and Responsibilities", b)
        self.assertIn("### Salary", b)

    def test_policy_defaults_change_the_offer_text(self):
        self.admin.post(f"{LC}/letterhead/", {"policy_defaults": {"probation_months": 6, "notice_confirmed_days": 60, "salary_disbursal": "last working day"}}, format="json")
        b = self.issue("OFFER", ctc_annual="240000")["body"]
        self.assertIn("six (6) months", b)
        self.assertIn("sixty (60) days' notice", b)
        self.assertIn("between the last working day", b)

    def test_every_standard_letter_renders(self):
        for lt in TEMPLATES:
            l = self.issue(lt, warning_level="Final Warning", warning_reason="Late reporting", new_designation="Lead", to_department="QA")
            data = self.pdf_of(l)
            self.assertTrue(data.startswith(b"%PDF"), lt)
            self.assertNotIn("{", l["body"].replace("{", "", 0) if False else "")
            self.assertNotIn("[[if", l["body"], lt)
            self.assertNotIn("[[endif", l["body"], lt)

    def test_other_company_gets_its_own_letterhead_and_templates(self):
        self.admin_b.post(f"{LC}/letterhead/", {"legal_name": "BETA INDUSTRIES LTD", "cin": "L12345MH2000PLC123456", "website": "www.beta.in"}, format="json")
        l = self.gen("RELIEVING_EXPERIENCE", "BOB001", {"last_working_day": "30 September 2026"}, client=self.admin_b)
        text, _, _ = pdf_text(self.pdf_of(l))
        if text is not None:
            self.assertIn("BETA INDUSTRIES LTD", text)
            self.assertIn("L12345MH2000PLC123456", text)
            self.assertNotIn("GLAZE", text)
            self.assertNotIn(CIN, text)
        self.assertEqual(self.admin_b.post(f"{GL}/generate/", {"letter_type": "OFFER", "recipient_code": "EMP002"}, format="json").status_code, 400)

    def test_custom_company_template_and_legacy_plain_body_still_work(self):
        LetterTemplate.objects.create(company=self.A, code="CONFIRMATION", subject="Confirmed {employee_name}",
                                      body="# CUSTOM\n\nHello **{first_name}**, confirmed from {confirmation_date}.\n[[stampsign]]\n{signatory_title}")
        l = self.gen("CONFIRMATION", variables={"confirmation_date": "1 Jan 2027"})
        self.assertIn("Hello **Divyesh**, confirmed from 1 Jan 2027.", l["body"])
        legacy = LEGACY_TEMPLATES["APPOINTMENT"][1]                                          # an OLD plain text template
        LetterTemplate.objects.create(company=self.A, code="APPOINTMENT", subject="Old", body=legacy)
        l2 = self.gen("APPOINTMENT")
        self.assertTrue(self.pdf_of(l2).startswith(b"%PDF"))
        self.assertIn("Glaze Rocks Private Limited", l2["body"])

    def test_user_values_do_not_break_the_layout(self):
        l = self.issue("TRANSFER", to_department="[[image:stamp]]\n# HACK", transfer_reason=">> evil")
        self.assertNotIn("\n# HACK", l["body"])
        self.assertIn("[ [image:stamp]]", l["body"])
        self.assertTrue(self.pdf_of(l).startswith(b"%PDF"))

    def test_no_installed_font_falls_back_to_helvetica_and_rs(self):
        with mock.patch.dict(lf._cache, {"f": ("Helvetica", "Helvetica-Bold", 1.0, False)}, clear=False):
            self.assertEqual(lf.currency_symbol(), "Rs. ")
            l = self.issue("OFFER", ctc_annual="240000")
            self.assertIn("Rs. 2,40,000.00", l["body"])
            self.assertTrue(self.pdf_of(l).startswith(b"%PDF"))

    def test_long_letters_get_the_header_and_footer_on_every_page(self):
        points = ["Point number %d of the long responsibilities list for pagination" % i for i in range(60)]
        l = self.issue("OFFER", ctc_annual="240000", responsibilities=[{"title": "Duties", "points": points}])
        text, pages, _ = pdf_text(self.pdf_of(l))
        if text is not None:
            self.assertGreaterEqual(pages, 3)
            self.assertEqual(text.count(f"CIN# {CIN}"), pages)
            self.assertEqual(text.count("GLAZE ROCKS PVT LTD"), pages)

    def test_letter_size_and_font_follow_the_letterhead(self):
        self.admin.post(f"{LC}/letterhead/", {"page_size": "LETTER", "body_font_size": 9}, format="json")
        _, _, rd = pdf_text(self.pdf_of(self.issue("CONFIRMATION")))
        if rd is not None:
            box = rd.pages[0].mediabox
            self.assertEqual((round(float(box.width)), round(float(box.height))), (612, 792))


class PreviewAndRegenerate(Base):
    def test_preview_json_and_pdf(self):
        r = self.admin.post(f"{LC}/preview/", {"letter_type": "RELIEVING_EXPERIENCE", "recipient_code": "EMP002", "variables": {"last_working_day": "30 September 2026"}}, format="json")
        d = r.json()["data"]
        self.assertEqual(r.status_code, 200)
        self.assertIn("30 September 2026", d["body"])
        self.assertTrue(d["body_plain"].startswith("Date:"))
        self.assertNotIn("**", d["body_plain"])
        self.assertEqual(d["sources"]["designation"], "Employee profile")
        self.assertNotIn("responsibilities_block", d["variables"])
        self.assertFalse(EmployeeLetter.objects.exists())                                  # nothing saved
        p = self.admin.post(f"{LC}/preview-pdf/", {"letter_type": "CONFIRMATION", "recipient_code": "EMP002", "variables": {"confirmation_date": "1 Jan 2027"}}, format="json")
        self.assertEqual((p.status_code, p["Content-Type"]), (200, "application/pdf"))
        self.assertTrue(p.content.startswith(b"%PDF"))
        self.assertFalse(EmployeeLetter.objects.exists())
        for bad in ({"letter_type": "X", "recipient_code": "EMP002"}, {"letter_type": "OFFER"}, {"letter_type": "OFFER", "recipient_code": "BOB001"}):
            self.assertEqual(self.admin.post(f"{LC}/preview/", bad, format="json").status_code, 400, bad)
        self.assertEqual(self.ro.post(f"{LC}/preview-pdf/", {"letter_type": "CONFIRMATION", "recipient_code": "EMP002"}, format="json").status_code, 403)
        self.assertEqual(self.hr.post(f"{LC}/preview-pdf/", {"letter_type": "CONFIRMATION", "recipient_code": "EMP002"}, format="json").status_code, 200)

    def test_existing_preview_api_resolves_the_new_markup(self):
        d = self.admin.post(f"{GL}/preview/", {"letter_type": "COMPENSATION_REVISION", "recipient_code": "EMP002", "variables": {"current_ctc": "300000"}}, format="json").json()["data"]
        self.assertNotIn("[[if", d["body"])
        self.assertIn("body_plain", d)
        self.assertNotIn("**", d["body_plain"])

    def test_regenerate_uses_the_current_letterhead(self):
        l = self.gen("CONFIRMATION", variables={"confirmation_date": "1 Jan 2027"})
        old = self.pdf_of(l)
        self.admin.post(f"{LC}/letterhead/", {**self.letterhead(), "legal_name": "NEW NAME LTD", "header_style": "FULL"}, format="json")
        r = self.admin.post(f"{LC}/letters/{l['id']}/regenerate/", {}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        new = self.pdf_of(l)
        self.assertNotEqual(old, new)
        text, _, _ = pdf_text(new)
        if text is not None:
            self.assertIn("NEW NAME LTD", text)
        self.assertEqual(self.admin_b.post(f"{LC}/letters/{l['id']}/regenerate/", {}, format="json").status_code, 404)    # B2B
        self.assertEqual(self.ro.post(f"{LC}/letters/{l['id']}/regenerate/", {}, format="json").status_code, 403)
        self.assertEqual(self.admin.post(f"{LC}/letters/99999/regenerate/", {}, format="json").status_code, 404)
        self.assertEqual(self.admin.get(f"{GL}/{l['id']}/pdf/").status_code, 200)                                          # still downloadable

    def test_markup_and_defaults_endpoints(self):
        m = self.admin.get(f"{LC}/markup/").json()["data"]
        self.assertIn("[[stampsign]]", m["directives"])
        self.assertIn("employee_name", m["base_placeholders"])
        self.assertIn("company_short_name", m["base_placeholders"])
        d = self.admin.get(f"{LC}/defaults/").json()["data"]
        self.assertEqual(len(d), 9)
        self.assertTrue(all("[[" in x["body"] or "#" in x["body"] for x in d))
        self.assertEqual({x["code"] for x in d}, set(TEMPLATES))
        self.assertEqual(self.emp.get(f"{LC}/markup/").status_code, 403)
        self.assertEqual(self.client.get(f"{LC}/defaults/").status_code, 401)

    def test_employee_still_downloads_their_own_letter(self):
        l = self.gen("CONFIRMATION", variables={"confirmation_date": "1 Jan 2027"})
        r = self.emp.get("/employee/letters/")
        self.assertIn(r.status_code, (200, 404))
