# Per-company SMTP tests (CRUD, duplicates, B2B isolation, routing, send, logs):  python manage.py test People.tests_mail
import json
from datetime import date

from django.core import mail as djmail
from django.test import override_settings
from rest_framework.test import APITestCase

from Company.models import company_details
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole
from Employee.tests_leave_hub import client_for, company_token, employee_token
from People import mail_crypto, mail_engine as me
from People.mail_testing import FakeSMTPServer
from People.models import CompanyEmailConfig, CompanyEmailLog

M = "/api/people/mail"
FAKE = dict(COMPANY_SMTP_ALLOW_PRIVATE_HOSTS=True, COMPANY_SMTP_VERIFY_DNS=False, COMPANY_SMTP_ALLOWED_PORTS=None)


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

    def mk(self, co, code, name, email, role=None, candidate=False):
        kw = dict(Employee_Status="Candidate", candidate_status="APPLIED", applied_position="Dev", is_active=False) if candidate else {}
        e = EmployeeDT.objects.create(company=co, employee_code=code, name=name, email=email, **kw)
        if not candidate:
            EmployeeAccount.objects.create(employee=e, role=role)
        return e

    def setUp(self):
        cm = override_settings(**FAKE)
        cm.enable()
        self.addCleanup(cm.disable)
        self.A, self.B = self.mk_company(1, "Alpha Corp"), self.mk_company(2, "Beta Corp")
        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, can_delete_employees=True)
        ro = EmployeeRole.objects.create(company=self.A, role_name="RO", role_code="ro", can_view_employees=True)
        self.hr_e = self.mk(self.A, "HR001", "Hina HR", "hina@alpha.com", hr)
        self.ro_e = self.mk(self.A, "RO001", "Rita RO", "rita@alpha.com", ro)
        self.asha = self.mk(self.A, "EMP001", "Asha Rao", "asha@alpha.com")
        self.ravi = self.mk(self.A, "EMP002", "Ravi Nair", "ravi@alpha.com")
        self.cand = self.mk(self.A, "CND001", "Anita Candidate", "anita@alpha.com", candidate=True)
        self.bela = self.mk(self.B, "BEL001", "Bela Shah", "bela@beta.com")
        self.cand_b = self.mk(self.B, "CNDB01", "Chirag Candidate", "chirag@beta.com", candidate=True)
        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.asha))
        self.srv_a = self.server({"mail@alpha.com": "pwA"})
        self.srv_a2 = self.server({"jobs@alpha.com": "pwA2"})
        self.srv_b = self.server({"mail@beta.com": "pwB"})

    def server(self, users, **kw):
        s = FakeSMTPServer(users, **kw).start()
        self.addCleanup(s.stop)
        return s

    def body(self, srv, name="Alpha HR", user=None, pw=None, **kw):
        user = user or next(iter(srv.users))
        b = {"name": name, "host": srv.host, "port": srv.port, "security": "NONE", "username": user,
             "password": pw or srv.users[user], "from_email": user, "from_name": name}
        b.update(kw)
        return b

    def add(self, client, srv, name="Alpha HR", expect=201, **kw):
        r = client.post(f"{M}/settings/", self.body(srv, name, **kw), format="json")
        self.assertEqual(r.status_code, expect, r.content)
        return r.json().get("data") if expect == 201 else r.json()

    def routing(self, srv_fallback=None):
        """Use the company-aware backend; the 'global' fallback is another fake SMTP server."""
        fb = srv_fallback or self.server({}, require_auth=False)
        cm = override_settings(EMAIL_BACKEND="People.mail_backend.CompanyAwareEmailBackend",
                               COMPANY_MAIL_FALLBACK_BACKEND="django.core.mail.backends.smtp.EmailBackend",
                               EMAIL_HOST=fb.host, EMAIL_PORT=fb.port, EMAIL_USE_SSL=False, EMAIL_USE_TLS=False,
                               EMAIL_HOST_USER="", EMAIL_HOST_PASSWORD="", DEFAULT_FROM_EMAIL="platform@hrnexus.test")
        cm.enable()
        self.addCleanup(cm.disable)
        return fb


class Crud(MailBase):
    def test_create_read_update_delete_and_password_never_returned(self):
        d = self.add(self.admin, self.srv_a)
        self.assertEqual((d["name"], d["audience"], d["is_default"], d["enabled"]), ("Alpha HR", "ALL", True, True))
        self.assertTrue(d["password_set"])
        self.assertEqual(d["password_status"], "saved")
        self.assertNotIn("pwA", json.dumps(d))
        row = CompanyEmailConfig.objects.get(pk=d["id"])
        self.assertNotIn("pwA", row.password_enc)                          # encrypted at rest
        self.assertEqual(mail_crypto.decrypt(row.password_enc), "pwA")
        self.assertEqual(row.company_id, self.A.pk)
        self.assertTrue(row.created_by.startswith("admin:"))
        lst = self.admin.get(f"{M}/settings/").json()
        self.assertEqual([x["id"] for x in lst["data"]], [d["id"]])
        self.assertNotIn("pwA", json.dumps(lst))
        one = self.admin.get(f"{M}/settings/{d['id']}/").json()["data"]
        self.assertEqual(one["from_email"], "mail@alpha.com")
        r = self.admin.post(f"{M}/settings/{d['id']}/update/", {"from_name": "People Team", "daily_limit": 50}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        up = r.json()["data"]
        self.assertEqual((up["from_name"], up["daily_limit"]), ("People Team", 50))
        self.assertEqual(mail_crypto.decrypt(CompanyEmailConfig.objects.get(pk=d["id"]).password_enc), "pwA")   # kept
        r = self.admin.patch(f"{M}/settings/{d['id']}/", {"password": "newpw"}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(mail_crypto.decrypt(CompanyEmailConfig.objects.get(pk=d["id"]).password_enc), "newpw")
        r = self.admin.post(f"{M}/settings/{d['id']}/delete/", {}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertFalse(CompanyEmailConfig.objects.exists())
        self.assertEqual(self.admin.get(f"{M}/settings/{d['id']}/").status_code, 404)
        self.add(self.admin, self.srv_a)
        self.assertEqual(self.admin.delete(f"{M}/settings/{CompanyEmailConfig.objects.get().pk}/").status_code, 200)

    def test_validation(self):
        base = self.body(self.srv_a)
        cases = {
            "name": {"name": "x"}, "host": {"host": "https://smtp.gmail.com"}, "host2": {"host": "bad host!"},
            "port": {"port": 70000}, "port2": {"port": "abc"}, "security": {"security": "MAYBE"},
            "audience": {"audience": "EVERYONE"}, "from_email": {"from_email": "not-an-email"},
            "reply_to": {"reply_to": "nope"}, "timeout": {"timeout_seconds": 1}, "limit": {"daily_limit": -1},
            "from_name": {"from_name": "Evil\nBcc: x@y.com"}, "nopass": {"password": ""}}
        for k, patch in cases.items():
            r = self.admin.post(f"{M}/settings/", {**base, "name": f"N-{k}", **patch}, format="json")
            self.assertEqual(r.status_code, 400, (k, r.content))
            self.assertEqual(r.json()["code"], "VALIDATION")
        self.assertFalse(CompanyEmailConfig.objects.exists())
        r = self.admin.post(f"{M}/settings/", {**base, "port": 70000}, format="json")
        self.assertIn("port", r.json()["errors"])

    def test_warnings_and_relay_without_login(self):
        d = self.add(self.admin, self.srv_a)
        self.assertTrue(any("clear text" in w for w in d["warnings"]))
        relay = self.server({}, require_auth=False)
        r = self.admin.post(f"{M}/settings/", {"name": "Relay", "host": relay.host, "port": relay.port, "security": "NONE",
                                               "from_email": "noreply@alpha.com"}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.assertEqual(r.json()["data"]["password_status"], "not_set")

    def test_list_filters_meta_and_resolve_helpers(self):
        a = self.add(self.admin, self.srv_a, "All-purpose")
        b = self.add(self.admin, self.srv_a2, "Candidates", audience="CANDIDATE")
        self.assertEqual([x["name"] for x in self.admin.get(f"{M}/settings/?audience=CANDIDATE").json()["data"]], ["Candidates"])
        self.assertEqual(len(self.admin.get(f"{M}/settings/?q=jobs").json()["data"]), 1)
        self.assertEqual(self.admin.get(f"{M}/settings/?audience=X").status_code, 400)
        self.admin.post(f"{M}/settings/{b['id']}/disable/", {}, format="json")
        self.assertEqual([x["name"] for x in self.admin.get(f"{M}/settings/?enabled=false").json()["data"]], ["Candidates"])
        meta = self.admin.get(f"{M}/settings/meta/").json()["data"]
        self.assertIn("smtp.gmail.com", [p["host"] for p in meta["providers"]])
        self.assertEqual([s["value"] for s in meta["security_modes"]], ["SSL", "STARTTLS", "NONE"])
        self.assertTrue(meta["has_configuration"])


class Duplicates(MailBase):
    def test_same_name_same_mailbox_and_defaults(self):
        a = self.add(self.admin, self.srv_a, "Main")
        r = self.add(self.admin, self.srv_a2, "main", expect=409)                       # name, case-insensitive
        self.assertEqual((r["code"], list(r["errors"])), ("DUPLICATE", ["name"]))
        r = self.add(self.admin, self.srv_a, "Second name", audience="CANDIDATE", expect=409)      # same mailbox
        self.assertEqual(list(r["errors"]), ["mailbox"])
        self.assertIn("already configured as 'Main'", r["message"])
        r = self.add(self.admin, self.srv_a, "Other name", port=self.srv_a.port, host=self.srv_a.host.upper(), expect=409)   # host case
        self.assertEqual(CompanyEmailConfig.objects.count(), 1)
        b = self.add(self.admin, self.srv_a2, "Jobs")
        self.assertEqual((a["is_default"], b["is_default"]), (True, False))             # one default per audience
        r = self.admin.post(f"{M}/settings/{b['id']}/set-default/", {}, format="json")
        self.assertEqual(r.status_code, 200)
        self.assertEqual(sorted(CompanyEmailConfig.objects.filter(is_default=True).values_list("name", flat=True)), ["Jobs"])
        self.assertEqual(self.admin.post(f"{M}/settings/{b['id']}/set-default/", {}, format="json").status_code, 409)
        r = self.admin.post(f"{M}/settings/{a['id']}/update/", {"name": "JOBS"}, format="json")                # rename clash
        self.assertEqual(r.status_code, 409)
        r = self.admin.post(f"{M}/settings/{a['id']}/update/", {"name": "MAIN"}, format="json")               # own name is fine
        self.assertEqual(r.status_code, 200)

    def test_update_into_a_duplicate_mailbox(self):
        self.add(self.admin, self.srv_a, "One")
        b = self.add(self.admin, self.srv_a2, "Two")
        r = self.admin.post(f"{M}/settings/{b['id']}/update/", {"username": "mail@alpha.com", "host": self.srv_a.host}, format="json")
        self.assertEqual(r.status_code, 409, r.content)
        self.assertEqual(CompanyEmailConfig.objects.get(pk=b["id"]).username, "jobs@alpha.com")

    def test_defaults_are_repaired_on_delete_and_disable(self):
        a = self.add(self.admin, self.srv_a, "Mail A")
        b = self.add(self.admin, self.srv_a2, "Mail B")
        self.admin.post(f"{M}/settings/{a['id']}/delete/", {}, format="json")
        self.assertTrue(CompanyEmailConfig.objects.get(pk=b["id"]).is_default)          # promoted automatically
        r = self.admin.post(f"{M}/settings/{b['id']}/disable/", {}, format="json")
        self.assertFalse(r.json()["data"]["is_default"])
        self.assertEqual(self.admin.post(f"{M}/settings/{b['id']}/disable/", {}, format="json").status_code, 409)
        self.assertEqual(self.admin.post(f"{M}/settings/{b['id']}/set-default/", {}, format="json").status_code, 400)
        self.assertEqual(self.admin.post(f"{M}/settings/{b['id']}/enable/", {}, format="json").status_code, 200)
        self.assertTrue(CompanyEmailConfig.objects.get(pk=b["id"]).is_default)
        self.assertEqual(self.admin.post(f"{M}/settings/{b['id']}/enable/", {}, format="json").status_code, 409)

    def test_database_itself_refuses_duplicates(self):
        from django.db import IntegrityError, transaction
        a = self.add(self.admin, self.srv_a, "Main")
        row = CompanyEmailConfig.objects.get(pk=a["id"])
        with self.assertRaises(IntegrityError), transaction.atomic():
            CompanyEmailConfig.objects.create(company=self.A, name="x", name_key=row.name_key, host="h", from_email="a@b.com",
                                              mailbox_key="other|x")
        with self.assertRaises(IntegrityError), transaction.atomic():
            CompanyEmailConfig.objects.create(company=self.A, name="y", name_key="y", host="h", from_email="a@b.com",
                                              mailbox_key=row.mailbox_key)

    def test_same_name_is_fine_in_another_company_but_same_mailbox_is_not(self):
        self.add(self.admin, self.srv_a, "Main")
        self.add(self.admin_b, self.srv_b, "Main")                                       # same NAME, different company: ok
        self.assertEqual(CompanyEmailConfig.objects.filter(name="Main").count(), 2)
        r = self.add(self.admin_b, self.srv_a, "Stolen", expect=409)                     # Alpha's mailbox
        self.assertEqual(list(r["errors"]), ["mailbox"])
        self.assertIn("another company", r["message"])
        self.assertNotIn("Alpha", r["message"])                                          # never reveals who
        with self.settings(COMPANY_SMTP_ALLOW_SHARED_MAILBOX=True):
            self.add(self.admin_b, self.srv_a, "Shared ok")


class Security(MailBase):
    def test_internal_hosts_and_ports_are_blocked_by_default(self):
        with self.settings(COMPANY_SMTP_ALLOW_PRIVATE_HOSTS=False, COMPANY_SMTP_ALLOWED_PORTS=(25, 465, 587, 2525)):
            for host in ("127.0.0.1", "localhost", "10.0.0.5", "192.168.1.9", "169.254.169.254", "db.internal", "::1"):
                r = self.admin.post(f"{M}/settings/", {**self.body(self.srv_a, "H-" + host), "host": host, "port": 587}, format="json")
                self.assertEqual(r.status_code, 400, host)
                self.assertIn("host", r.json()["errors"])
            r = self.admin.post(f"{M}/settings/", {**self.body(self.srv_a), "host": "smtp.gmail.com", "port": 22}, format="json")
            self.assertIn("port", r.json()["errors"])
            self.assertEqual(self.admin.post(f"{M}/settings/", {**self.body(self.srv_a), "host": "8.8.8.8", "port": 587}, format="json").status_code, 201)

    def test_dns_names_pointing_inside_are_blocked(self):
        import socket
        from unittest import mock
        fake = lambda *a, **k: [(2, 1, 6, "", ("10.1.2.3", 0))]
        with self.settings(COMPANY_SMTP_ALLOW_PRIVATE_HOSTS=False, COMPANY_SMTP_VERIFY_DNS=True, COMPANY_SMTP_ALLOWED_PORTS=None):
            with mock.patch("socket.getaddrinfo", fake):
                r = self.admin.post(f"{M}/settings/", {**self.body(self.srv_a), "host": "mail.evil-tenant.com"}, format="json")
                self.assertEqual(r.status_code, 400)
                self.assertIn("private", r.json()["message"])
            with mock.patch("socket.getaddrinfo", side_effect=socket.gaierror):
                r = self.admin.post(f"{M}/settings/", {**self.body(self.srv_a), "host": "no-such-host.example"}, format="json")
                self.assertIn("could not be resolved", r.json()["message"])

    def test_test_endpoint_rechecks_the_host(self):
        d = self.add(self.admin, self.srv_a)
        with self.settings(COMPANY_SMTP_ALLOW_PRIVATE_HOSTS=False):
            r = self.admin.post(f"{M}/settings/{d['id']}/test/", {}, format="json")
            self.assertEqual(r.status_code, 400)
            self.assertEqual(self.srv_a.messages, [])

    def test_changed_encryption_key_is_reported_not_crashing(self):
        d = self.add(self.admin, self.srv_a)
        with self.settings(COMPANY_SMTP_ENCRYPTION_KEY="Tm90LXRoZS1zYW1lLWtleS1Ob3QtdGhlLXNhbWUta2V5MQ=="):
            one = self.admin.get(f"{M}/settings/{d['id']}/").json()["data"]
            self.assertEqual(one["password_status"], "needs_reentry")
            r = self.admin.post(f"{M}/settings/{d['id']}/test/", {}, format="json")
            self.assertEqual(r.status_code, 400)
            self.assertIn("Re-enter the password", r.json()["message"])

    def test_error_text_never_contains_the_password(self):
        d = self.add(self.admin, self.srv_a, pw="wrong-secret-pw")
        r = self.admin.post(f"{M}/settings/{d['id']}/test/", {}, format="json")
        self.assertEqual(r.status_code, 400)
        self.assertNotIn("wrong-secret-pw", r.content.decode())
        self.assertIn("rejected the login", r.json()["message"])
        self.assertEqual(set(self.srv_a.failed_logins), {"mail@alpha.com"})


class TestConnection(MailBase):
    def test_success_failure_and_test_mail(self):
        d = self.add(self.admin, self.srv_a)
        r = self.admin.post(f"{M}/settings/{d['id']}/test/", {}, format="json")
        self.assertEqual((r.status_code, r.json()["code"]), (200, "SMTP_TEST_OK"), r.content)
        self.assertTrue(r.json()["data"]["connected"])
        last = self.admin.get(f"{M}/settings/{d['id']}/").json()["data"]["last_test"]
        self.assertTrue(last["ok"] and last["at"])
        r = self.admin.post(f"{M}/settings/{d['id']}/test/", {"send_to": "me@alpha.com"}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        m = self.srv_a.messages[-1]
        self.assertEqual((m["rcpt_to"], m["from"], m["subject"]), (["me@alpha.com"], "Alpha HR <mail@alpha.com>", "SMTP test message"))
        self.assertEqual(self.admin.post(f"{M}/settings/{d['id']}/test/", {"send_to": "bad"}, format="json").status_code, 400)
        bad = self.add(self.admin, self.srv_a2, "Wrong", pw="nope")
        r = self.admin.post(f"{M}/settings/{bad['id']}/test/", {}, format="json")
        self.assertEqual((r.status_code, r.json()["code"]), (400, "SMTP_TEST_FAILED"))
        self.assertFalse(r.json()["data"]["ok"])
        self.assertFalse(self.admin.get(f"{M}/settings/{bad['id']}/").json()["data"]["last_test"]["ok"])

    def test_unreachable_server_gives_a_friendly_error_and_editing_resets_the_test(self):
        s = self.server({"x@alpha.com": "p"})
        d = self.add(self.admin, s, "Gone")
        s.stop()
        r = self.admin.post(f"{M}/settings/{d['id']}/test/", {}, format="json")
        self.assertEqual(r.status_code, 400)
        self.assertIn("Could not connect", r.json()["message"])
        self.admin.post(f"{M}/settings/{d['id']}/update/", {"port": self.srv_a.port}, format="json")
        self.assertIsNone(self.admin.get(f"{M}/settings/{d['id']}/").json()["data"]["last_test"]["ok"])

    def test_test_mail_rate_limit(self):
        d = self.add(self.admin, self.srv_a)
        codes = [self.admin.post(f"{M}/settings/{d['id']}/test/", {"send_to": "t@alpha.com"}, format="json").status_code for _ in range(6)]
        self.assertEqual(codes, [200] * 5 + [400])


class Routing(MailBase):
    def setUp(self):
        super().setUp()
        self.fb = self.routing()
        self.cfg_a = self.add(self.admin, self.srv_a, "Alpha employees", audience="EMPLOYEE", from_name="Alpha People")
        self.cfg_ac = self.add(self.admin, self.srv_a2, "Alpha careers", audience="CANDIDATE", from_name="Alpha Careers")
        self.cfg_b = self.add(self.admin_b, self.srv_b, "Beta all", from_name="Beta HR")

    def send(self, to, subject="Hello", **kw):
        return djmail.send_mail(subject, "Body text", "platform@hrnexus.test", to, **kw)

    def test_each_recipient_uses_the_smtp_of_their_own_company(self):
        self.assertEqual(self.send(["asha@alpha.com"]), 1)
        self.assertEqual(self.send(["bela@beta.com"]), 1)
        self.assertEqual(self.send(["anita@alpha.com"]), 1)
        self.assertEqual(self.send(["chirag@beta.com"]), 1)
        a, ac, b = self.srv_a.messages, self.srv_a2.messages, self.srv_b.messages
        self.assertEqual([m["rcpt_to"] for m in a], [["asha@alpha.com"]])
        self.assertEqual(a[0]["from"], "Alpha People <mail@alpha.com>")                   # From rewritten to the company mailbox
        self.assertEqual(a[0]["auth_user"], "mail@alpha.com")
        self.assertEqual([m["rcpt_to"] for m in ac], [["anita@alpha.com"]])               # candidate -> candidate mailbox
        self.assertEqual(ac[0]["from"], "Alpha Careers <jobs@alpha.com>")
        self.assertEqual([m["rcpt_to"] for m in b], [["bela@beta.com"], ["chirag@beta.com"]])   # ALL audience covers both
        self.assertEqual(self.fb.messages, [])
        self.assertNotIn("X-HRN-Kind", a[0]["headers"])

    def test_platform_mailbox_only_serves_platform_mail(self):
        self.send(["someone@gmail.com"])                                    # no company involved -> platform SMTP (settings.py)
        self.send(["mail1@x.com"], "Welcome to the platform")               # a COMPANY ADMIN's address (SuperAdmin registration mail)
        self.assertEqual([m["rcpt_to"] for m in self.fb.messages], [["someone@gmail.com"], ["mail1@x.com"]])
        self.assertEqual(self.fb.messages[0]["from"], "platform@hrnexus.test")
        self.assertEqual((self.srv_a.messages, self.srv_b.messages), ([], []))

    def test_company_people_without_smtp_never_go_through_the_platform_mailbox(self):
        self.admin_b.post(f"{M}/settings/{self.cfg_b['id']}/disable/", {}, format="json")
        with self.assertRaises(me.MailConfigError) as cm:
            self.send(["bela@beta.com"])
        self.assertIn("no enabled SMTP configuration for employees", str(cm.exception))
        self.assertEqual(self.send(["chirag@beta.com"], fail_silently=True), 0)
        self.assertEqual(self.fb.messages, [])                                # nothing leaked to the SuperAdmin mailbox
        self.assertEqual(self.srv_b.messages, [])
        rows = list(CompanyEmailLog.objects.order_by("id"))
        self.assertEqual([(r.status, r.via, r.company_id, r.recipient_type) for r in rows],
                         [("FAILED", "NONE", self.B.pk, "EMPLOYEE"), ("FAILED", "NONE", self.B.pk, "CANDIDATE")])
        self.assertIn("never used", rows[0].error)

    def test_platform_fallback_can_be_switched_on(self):
        self.admin_b.post(f"{M}/settings/{self.cfg_b['id']}/disable/", {}, format="json")
        with self.settings(COMPANY_MAIL_ALLOW_PLATFORM_FALLBACK=True):
            self.assertEqual(self.send(["bela@beta.com"]), 1)
        self.assertEqual([m["rcpt_to"] for m in self.fb.messages], [["bela@beta.com"]])
        self.assertEqual(CompanyEmailLog.objects.get().via, "GLOBAL_FALLBACK")

    def test_company_users_mail_to_outside_addresses_uses_the_company_smtp(self):
        r = self.admin.post("/api/recruitment/hiring-plus/candidate-links/", {
            "name": "Meena Joshi", "email": "meena@gmail.com", "phone_number": "9876543210", "applied_position": "Dev",
            "send_to": "meena.personal@outlook.com"}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.assertTrue(r.json()["email_sent"])
        self.assertEqual([m["rcpt_to"] for m in self.srv_a.messages], [["meena.personal@outlook.com"]])   # company A's mailbox
        self.assertEqual(self.fb.messages, [])
        self.assertEqual(CompanyEmailLog.objects.get().recipient_type, "OTHER")

    def test_context_middleware_trusts_only_valid_company_and_employee_tokens(self):
        from django.test import RequestFactory
        from rest_framework_simplejwt.tokens import RefreshToken
        from People.mail_context import CompanyMailContextMiddleware, current_company
        seen = []
        mw = CompanyMailContextMiddleware(lambda req: seen.append(getattr(current_company(), "company_id", None)) or None)
        rf = RequestFactory()

        def tok(kind, **claims):
            t = RefreshToken()
            t["type"] = kind
            for k, v in claims.items():
                t[k] = v
            return "Bearer " + str(t.access_token)
        mw(rf.get("/", HTTP_AUTHORIZATION=tok("company", user_id=self.A.company_id)))
        mw(rf.get("/", HTTP_AUTHORIZATION=tok("employee", user_id="EMP001", company_id=self.B.company_id)))
        mw(rf.get("/", HTTP_AUTHORIZATION=tok("superadmin", user_id=1)))                 # SuperAdmin: platform mail
        mw(rf.get("/", HTTP_AUTHORIZATION="Bearer not.a.token"))
        mw(rf.get("/"))
        self.assertEqual(seen, [self.A.company_id, self.B.company_id, None, None, None])
        from People.mail_context import current_company as cc
        self.assertIsNone(cc())                                                          # reset after every request

    def test_mixed_audiences_are_split_and_never_cross_companies(self):
        self.assertEqual(self.send(["anita@alpha.com", "asha@alpha.com"], "Interview scheduled - HR round"), 1)
        self.assertEqual([m["rcpt_to"] for m in self.srv_a2.messages], [["anita@alpha.com"]])
        self.assertEqual([m["rcpt_to"] for m in self.srv_a.messages], [["asha@alpha.com"]])
        self.assertNotIn("asha@alpha.com", self.srv_a2.messages[0]["to"])
        self.send(["asha@alpha.com", "bela@beta.com"])                                      # two companies in one mail
        self.assertEqual(self.srv_a.messages[-1]["rcpt_to"], ["asha@alpha.com"])
        self.assertEqual(self.srv_b.messages[-1]["rcpt_to"], ["bela@beta.com"])
        self.assertEqual(CompanyEmailLog.objects.filter(kind="interview").count(), 2)

    def test_one_all_audience_mailbox_keeps_a_single_message(self):
        self.admin.post(f"{M}/settings/{self.cfg_ac['id']}/delete/", {}, format="json")
        self.admin.post(f"{M}/settings/{self.cfg_a['id']}/update/", {"audience": "ALL"}, format="json")
        self.send(["anita@alpha.com", "asha@alpha.com"])
        self.assertEqual(len(self.srv_a.messages), 1)
        self.assertEqual(sorted(self.srv_a.messages[0]["rcpt_to"]), ["anita@alpha.com", "asha@alpha.com"])

    def test_reply_to_and_logs(self):
        self.admin.post(f"{M}/settings/{self.cfg_a['id']}/update/", {"reply_to": "hr@alpha.com"}, format="json")
        self.send(["asha@alpha.com"], "Welcome aboard")
        self.assertEqual(self.srv_a.messages[0]["reply_to"], "hr@alpha.com")
        log = CompanyEmailLog.objects.get()
        self.assertEqual((log.status, log.via, log.recipient_type, log.kind, log.config_name, log.from_email),
                         ("SENT", "COMPANY_SMTP", "EMPLOYEE", "welcome", "Alpha employees", "mail@alpha.com"))
        self.assertEqual(log.employee_id, self.asha.id)
        self.assertFalse(hasattr(log, "body"))

    def test_failures_are_logged_and_raised_unless_fail_silently(self):
        CompanyEmailConfig.objects.filter(pk=self.cfg_a["id"]).update(password_enc=mail_crypto.encrypt("wrong"))
        with self.assertRaises(Exception):
            self.send(["asha@alpha.com"])
        self.assertEqual(self.send(["ravi@alpha.com"], fail_silently=True), 0)
        rows = list(CompanyEmailLog.objects.order_by("id"))
        self.assertEqual([r.status for r in rows], ["FAILED", "FAILED"])
        self.assertIn("rejected the login", rows[0].error)
        self.assertNotIn("wrong", rows[0].error)

    def test_daily_limit(self):
        self.admin.post(f"{M}/settings/{self.cfg_a['id']}/update/", {"daily_limit": 2}, format="json")
        self.assertEqual(self.send(["asha@alpha.com"]), 1)
        self.assertEqual(self.send(["ravi@alpha.com"]), 1)
        with self.assertRaises(me.MailLimitError):
            self.send(["asha@alpha.com"])
        self.assertEqual(len(self.srv_a.messages), 2)
        self.assertEqual(CompanyEmailLog.objects.filter(status="FAILED").count(), 1)
        self.assertEqual(self.admin.get(f"{M}/settings/{self.cfg_a['id']}/").json()["data"]["sent_today"], 2)
        self.admin.post(f"{M}/settings/{self.cfg_a['id']}/update/", {"daily_limit": 0}, format="json")      # 0 = unlimited
        self.assertEqual(self.send(["asha@alpha.com"]), 1)

    def test_bulk_messages_in_one_call(self):
        msgs = [djmail.EmailMessage("S1", "b", "x@y.com", ["asha@alpha.com"]), djmail.EmailMessage("S2", "b", "x@y.com", ["bela@beta.com"]),
                djmail.EmailMessage("S3", "b", "x@y.com", ["out@side.com"]), djmail.EmailMessage("S4", "b", "x@y.com", [])]
        self.assertEqual(djmail.get_connection().send_messages(msgs), 3)
        self.assertEqual((len(self.srv_a.messages), len(self.srv_b.messages), len(self.fb.messages)), (1, 1, 1))

    def test_existing_recruitment_flow_now_uses_the_company_mailbox(self):
        r = self.admin.post("/api/recruitment/hiring-plus/candidate-links/", {
            "name": "Meena Joshi", "email": "meena@gmail.com", "phone_number": "9876543210", "applied_position": "Dev",
            "send_email": True}, format="json")
        self.assertEqual(r.status_code, 201, r.content)
        self.assertTrue(r.json()["email_sent"])
        self.assertEqual([m["rcpt_to"] for m in self.srv_a2.messages], [["meena@gmail.com"]])       # candidate mailbox of company A
        self.assertEqual(self.srv_a2.messages[0]["subject"], "Please complete your application details")
        self.assertEqual(self.srv_a2.messages[0]["from"], "Alpha Careers <jobs@alpha.com>")
        self.assertEqual(self.fb.messages, [])
        log = CompanyEmailLog.objects.get(to_email="meena@gmail.com")
        self.assertEqual((log.recipient_type, log.kind, log.company_id), ("CANDIDATE", "candidate_portal", self.A.pk))


class Compose(MailBase):
    def setUp(self):
        super().setUp()
        self.cfg_e = self.add(self.admin, self.srv_a, "Employees", audience="EMPLOYEE")
        self.cfg_c = self.add(self.admin, self.srv_a2, "Candidates", audience="CANDIDATE")

    def send(self, body, client=None):
        return (client or self.admin).post(f"{M}/send/", body, format="json")

    def test_send_to_employees_and_candidates(self):
        r = self.send({"subject": "Holiday notice", "message": "Hi {name}, office is closed. - {company}",
                       "employee_codes": ["EMP001", "EMP002"], "candidate_ids": [self.cand.id], "kind": "Holiday Notice",
                       "html": "<p>Hi {name}</p>"})
        self.assertEqual(r.status_code, 200, r.content)
        d = r.json()["data"]
        self.assertEqual((d["requested"], d["sent"], d["failed"]), (3, 3, 0))
        self.assertEqual(d["configurations_used"], ["Candidates", "Employees"])
        self.assertEqual(sorted(m["rcpt_to"][0] for m in self.srv_a.messages), ["asha@alpha.com", "ravi@alpha.com"])
        self.assertEqual(self.srv_a2.messages[0]["rcpt_to"], ["anita@alpha.com"])
        first = next(m for m in self.srv_a.messages if m["rcpt_to"] == ["asha@alpha.com"])
        self.assertEqual(first["body"].strip(), "Hi Asha Rao, office is closed. - Alpha Corp")
        self.assertTrue(first["multipart"])
        self.assertEqual(CompanyEmailLog.objects.filter(kind="holiday_notice", status="SENT").count(), 3)

    def test_validation_and_b2b_recipients(self):
        good = {"subject": "S", "message": "M", "employee_codes": ["EMP001"]}
        for patch in ({"subject": ""}, {"subject": "a\nb"}, {"message": ""}, {"employee_codes": [], "candidate_ids": []},
                      {"employee_codes": "EMP001"}, {"candidate_ids": ["x"]}, {"html": "x" * 50001},
                      {"employee_codes": [f"E{i}" for i in range(101)]}):
            self.assertEqual(self.send({**good, **patch}).status_code, 400, patch)
        r = self.send({**good, "employee_codes": ["BEL001"]})                                       # other company's employee
        self.assertEqual(r.status_code, 400)
        self.assertEqual(r.json()["errors"]["employee_codes"], ["BEL001"])
        r = self.send({**good, "employee_codes": ["EMP001"], "candidate_ids": [self.cand_b.id, self.asha.id]})
        self.assertEqual(r.status_code, 400)                                                         # foreign candidate + an employee id
        self.assertEqual(sorted(r.json()["errors"]["candidate_ids"]), sorted([self.cand_b.id, self.asha.id]))
        self.assertEqual(self.srv_a.messages, [])

    def test_no_configuration_forced_config_and_skipped(self):
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP001"]}, self.admin_b)
        self.assertEqual(r.status_code, 400)
        self.assertEqual(self.admin_b.post(f"{M}/send/", {"subject": "S", "message": "M", "employee_codes": ["BEL001"]}, format="json").json()["code"], "NO_SMTP_CONFIG")
        EmployeeDT.objects.filter(pk=self.ravi.pk).update(email="")
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP001", "EMP002"]})
        self.assertEqual(r.json()["data"]["skipped"][0]["employee_code"], "EMP002")
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP001"], "config_id": self.cfg_c["id"]})
        self.assertEqual(r.status_code, 400)                                                         # candidate-only config
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP001"], "config_id": 99999})
        self.assertEqual(r.status_code, 400)
        other_cfg = self.add(self.admin_b, self.srv_b, "Beta")
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP001"], "config_id": other_cfg["id"]})
        self.assertEqual(r.status_code, 400)                                                         # another company's config
        self.assertEqual(self.srv_b.messages, [])

    def test_partial_and_total_failure(self):
        srv = self.server({"p@alpha.com": "p"}, reject_rcpt=["ravi@alpha.com"])
        CompanyEmailConfig.objects.filter(pk=self.cfg_e["id"]).delete()
        self.add(self.admin, srv, "Strict", audience="EMPLOYEE")
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP001", "EMP002"]})
        self.assertEqual(r.status_code, 200)
        d = r.json()["data"]
        self.assertEqual((d["sent"], d["failed"]), (1, 1))
        self.assertEqual([x["status"] for x in d["results"]], ["SENT", "FAILED"])
        self.assertIn("refused", d["results"][1]["error"])
        r = self.send({"subject": "S", "message": "M", "employee_codes": ["EMP002"]})
        self.assertEqual((r.status_code, r.json()["code"]), (502, "SEND_FAILED"))

    def test_permissions(self):
        body = {"subject": "S", "message": "M", "employee_codes": ["EMP001"]}
        self.assertEqual(self.send(body, self.hr).status_code, 200)                                  # HR: create right
        self.assertEqual(self.send(body, self.ro).status_code, 403)                                  # read-only HR
        self.assertEqual(self.send(body, self.emp).status_code, 403)                                 # plain employee
        self.assertEqual(self.send(body, self.client).status_code, 401)


class LogsAndSelf(MailBase):
    def setUp(self):
        super().setUp()
        self.routing()
        self.add(self.admin, self.srv_a, "Alpha")
        self.add(self.admin_b, self.srv_b, "Beta")
        djmail.send_mail("Interview scheduled", "b", "x@y.com", ["anita@alpha.com"])
        djmail.send_mail("Welcome", "b", "x@y.com", ["asha@alpha.com"])
        djmail.send_mail("Payslip", "b", "x@y.com", ["ravi@alpha.com"])
        djmail.send_mail("Welcome", "b", "x@y.com", ["bela@beta.com"])

    def test_logs_filters_and_isolation(self):
        d = self.admin.get(f"{M}/logs/").json()
        self.assertEqual(d["meta"]["total"], 3)
        self.assertNotIn("bela@beta.com", json.dumps(d))
        self.assertEqual([r["to_email"] for r in self.admin.get(f"{M}/logs/?audience=CANDIDATE").json()["data"]], ["anita@alpha.com"])
        self.assertEqual(len(self.admin.get(f"{M}/logs/?q=welcome").json()["data"]), 1)
        self.assertEqual(self.admin.get(f"{M}/logs/?kind=interview").json()["data"][0]["candidate_id"], self.cand.id)
        self.assertEqual(self.admin.get(f"{M}/logs/?status=BOUNCED").status_code, 400)
        self.assertEqual(self.admin.get(f"{M}/logs/?date_from=bad").status_code, 400)
        self.assertEqual(self.admin_b.get(f"{M}/logs/").json()["meta"]["total"], 1)
        s = self.admin.get(f"{M}/logs/summary/").json()["data"]
        self.assertEqual((s["total"], s["sent"], s["failed"], s["sent_today"]), (3, 3, 0, 3))
        self.assertEqual(s["by_recipient_type"], {"CANDIDATE": 1, "EMPLOYEE": 2})
        self.assertEqual(self.ro.get(f"{M}/logs/").status_code, 200)

    def test_employee_sees_only_their_own_mail(self):
        d = self.emp.get("/employee/my-emails/").json()
        self.assertEqual([r["subject"] for r in d["data"]], ["Welcome"])
        self.assertEqual(d["data"][0]["from_email"], "mail@alpha.com")
        self.assertNotIn("anita@alpha.com", json.dumps(d))
        self.assertEqual(self.client.get("/employee/my-emails/").status_code, 401)
        self.assertEqual(client_for(company_token(self.A)).get("/employee/my-emails/").status_code, 401)


class PermissionsAndB2B(MailBase):
    def test_rights(self):
        d = self.add(self.admin, self.srv_a)
        i = d["id"]
        self.assertEqual(self.hr.post(f"{M}/settings/", self.body(self.srv_a2, "Jobs"), format="json").status_code, 201)       # create
        self.assertEqual(self.hr.post(f"{M}/settings/{i}/update/", {"from_name": "HR"}, format="json").status_code, 200)       # edit
        self.assertEqual(self.hr.post(f"{M}/settings/{i}/test/", {}, format="json").status_code, 200)
        self.assertEqual(self.ro.get(f"{M}/settings/").status_code, 200)                                                        # view
        self.assertEqual(self.ro.get(f"{M}/settings/{i}/").status_code, 200)
        self.assertEqual(self.ro.post(f"{M}/settings/", self.body(self.srv_b, "X"), format="json").status_code, 403)
        self.assertEqual(self.ro.post(f"{M}/settings/{i}/update/", {"name": "Y"}, format="json").status_code, 403)
        self.assertEqual(self.ro.post(f"{M}/settings/{i}/delete/", {}, format="json").status_code, 403)
        self.assertEqual(self.ro.post(f"{M}/settings/{i}/test/", {}, format="json").status_code, 403)
        self.assertEqual(self.ro.post(f"{M}/settings/{i}/set-default/", {}, format="json").status_code, 403)
        self.assertEqual(self.emp.get(f"{M}/settings/").status_code, 403)
        self.assertEqual(self.emp.get(f"{M}/logs/").status_code, 403)
        self.assertEqual(self.client.get(f"{M}/settings/").status_code, 401)
        self.assertEqual(self.hr.post(f"{M}/settings/{i}/delete/", {}, format="json").status_code, 200)       # delete right

    def test_company_b_cannot_touch_company_a(self):
        d = self.add(self.admin, self.srv_a)
        i = d["id"]
        self.add(self.admin_b, self.srv_b, "Beta")
        self.assertEqual([x["name"] for x in self.admin_b.get(f"{M}/settings/").json()["data"]], ["Beta"])
        for call in (lambda: self.admin_b.get(f"{M}/settings/{i}/"),
                     lambda: self.admin_b.post(f"{M}/settings/{i}/update/", {"name": "Hacked"}, format="json"),
                     lambda: self.admin_b.patch(f"{M}/settings/{i}/", {"enabled": False}, format="json"),
                     lambda: self.admin_b.post(f"{M}/settings/{i}/delete/", {}, format="json"),
                     lambda: self.admin_b.post(f"{M}/settings/{i}/test/", {"send_to": "a@b.com"}, format="json"),
                     lambda: self.admin_b.post(f"{M}/settings/{i}/set-default/", {}, format="json"),
                     lambda: self.admin_b.post(f"{M}/settings/{i}/enable/", {}, format="json"),
                     lambda: self.admin_b.post(f"{M}/settings/{i}/disable/", {}, format="json")):
            self.assertEqual(call().status_code, 404)
        row = CompanyEmailConfig.objects.get(pk=i)
        self.assertEqual((row.name, row.enabled, row.company_id), ("Alpha HR", True, self.A.pk))
        self.assertEqual(self.srv_a.messages, [])

    def test_resolve_never_leaks_across_companies(self):
        self.add(self.admin, self.srv_a, "Alpha", audience="EMPLOYEE")
        self.add(self.admin, self.srv_a2, "Careers", audience="CANDIDATE")
        r = self.admin.get(f"{M}/settings/resolve/?email=asha@alpha.com").json()["data"]
        self.assertEqual((r["matched"], r["route"], r["config"]["name"], r["audience"]), (True, "COMPANY_SMTP", "Alpha", "EMPLOYEE"))
        r = self.admin.get(f"{M}/settings/resolve/?candidate_id={self.cand.id}").json()["data"]
        self.assertEqual((r["audience"], r["config"]["name"]), ("CANDIDATE", "Careers"))
        r = self.admin.get(f"{M}/settings/resolve/?employee_code=EMP002").json()["data"]
        self.assertEqual(r["config"]["name"], "Alpha")
        r = self.admin.get(f"{M}/settings/resolve/?audience=CANDIDATE").json()["data"]
        self.assertEqual(r["config"]["name"], "Careers")
        r = self.admin.get(f"{M}/settings/resolve/?email=bela@beta.com").json()["data"]            # other company's person
        self.assertEqual((r["matched"], r["audience"], r["route"], r["config"]["name"]), (False, "OTHER", "COMPANY_SMTP", "Alpha"))
        self.assertNotIn("Beta", json.dumps(r))                                                      # nothing about the other company
        self.admin.post(f"{M}/settings/{CompanyEmailConfig.objects.get(name='Alpha').pk}/disable/", {}, format="json")
        r = self.admin.get(f"{M}/settings/resolve/?employee_code=EMP001").json()["data"]
        self.assertEqual((r["route"], r["config"]), ("BLOCKED_NO_SMTP", None))                       # no platform mailbox for company mail
        self.assertEqual(self.admin.get(f"{M}/settings/resolve/?candidate_id={self.asha.id}").json()["data"]["matched"], False)
        self.assertEqual(self.admin.get(f"{M}/settings/resolve/").status_code, 400)

    def test_a_forced_config_is_ignored_for_recipients_of_another_company(self):
        self.routing()
        a = self.add(self.admin, self.srv_a, "Alpha")
        msg = djmail.EmailMessage("S", "b", "x@y.com", ["bela@beta.com"], headers={"X-HRN-Config": str(a["id"])})
        routes = me.route_message(msg)
        self.assertEqual([r.cfg for r in routes], [None])
        self.assertEqual(self.srv_a.messages, [])


# ================================================================ automatic credentials mail on conversion
CV = "/company/employees/convert"


class WelcomeMail(MailBase):
    def setUp(self):
        super().setUp()
        self.fb = self.routing()
        self.cfg_e = self.add(self.admin, self.srv_a, "HR Mailbox", audience="EMPLOYEE", from_name="Alpha HR")
        self.cfg_c = self.add(self.admin, self.srv_a2, "Careers", audience="CANDIDATE", from_name="Alpha Careers")
        self.cfg_b = self.add(self.admin_b, self.srv_b, "Beta HR", from_name="Beta HR")

    def convert(self, cand=None, body=None, client=None):
        cand = cand or self.cand
        body = {"password": "Welcome@123", "role_code": "employee", "date_of_joining": "2026-11-03", "basic_salary": "45000",
                "designation": "Backend Developer", "department": "Engineering", "employee_type": "Full Time", **(body or {})}
        return (client or self.admin).post(f"{CV}/{cand.id}/", body, format="json")

    def test_convert_sends_credentials_through_the_company_smtp(self):
        r = self.convert()
        self.assertEqual(r.status_code, 200, r.content)
        w = r.json()["welcome_email"]
        self.assertEqual((w["sent"], w["status"], w["to"], w["via"], w["from"]), (True, "SENT", "anita@alpha.com", "HR Mailbox", "mail@alpha.com"))
        self.assertEqual(len(self.srv_a.messages), 1)                       # EMPLOYEE mailbox: she is an employee now
        self.assertEqual((self.srv_a2.messages, self.srv_b.messages, self.fb.messages), ([], [], []))   # not the careers / platform one
        m = self.srv_a.messages[0]
        self.assertEqual((m["rcpt_to"], m["from"], m["auth_user"]), (["anita@alpha.com"], "Alpha HR <mail@alpha.com>", "mail@alpha.com"))
        self.assertEqual(m["subject"], "Welcome to Alpha Corp - your login details")
        for line in ("Dear Anita Candidate", "Login email: anita@alpha.com", "Temporary password: Welcome@123", "Role: Employee",
                     "Designation: Backend Developer", "Department: Engineering", "Employee type: Full Time",
                     "Date of joining: 03 Nov 2026", "Basic salary: 45,000.00", f"Employee ID: {self.cand.employee_code}"):
            self.assertIn(line, m["body"], line)
        self.assertTrue(m["multipart"])
        log = CompanyEmailLog.objects.get()
        self.assertEqual((log.kind, log.status, log.recipient_type, log.via, log.company_id), ("welcome_credentials", "SENT", "EMPLOYEE", "COMPANY_SMTP", self.A.pk))
        self.assertNotIn("Welcome@123", log.subject + log.error)

    def test_company_without_smtp_is_told_and_nothing_goes_through_the_platform(self):
        self.admin.post(f"{M}/settings/{self.cfg_e['id']}/disable/", {}, format="json")
        self.admin.post(f"{M}/settings/{self.cfg_c['id']}/disable/", {}, format="json")
        r = self.convert()
        self.assertEqual(r.status_code, 200)                                  # conversion itself still succeeds
        w = r.json()["welcome_email"]
        self.assertEqual((w["sent"], w["status"]), (False, "NO_SMTP_CONFIG"))
        self.assertIn("never used", w["message"])
        self.assertEqual((self.fb.messages, self.srv_a.messages), ([], []))
        self.assertTrue(EmployeeDT.objects.get(pk=self.cand.pk).is_active)
        log = CompanyEmailLog.objects.get()
        self.assertEqual((log.status, log.via, log.kind), ("FAILED", "NONE", "welcome_credentials"))
        self.admin.post(f"{M}/settings/{self.cfg_e['id']}/enable/", {}, format="json")
        res = self.admin.post(f"{M}/welcome/{self.cand.employee_code}/send/", {}, format="json")      # HR fixes SMTP, then resends
        self.assertEqual(res.status_code, 200, res.content)
        self.assertEqual(len(self.srv_a.messages), 1)

    def test_each_company_uses_its_own_mailbox(self):
        EmployeeDT.objects.filter(pk=self.cand_b.pk).update(email="chirag@beta.com")
        r = self.convert(self.cand_b, client=self.admin_b)
        self.assertEqual(r.status_code, 200, r.content)
        self.assertEqual(r.json()["welcome_email"]["via"], "Beta HR")
        self.assertEqual([m["rcpt_to"] for m in self.srv_b.messages], [["chirag@beta.com"]])
        self.assertEqual(self.srv_b.messages[0]["from"], "Beta HR <mail@beta.com>")
        self.assertEqual((self.srv_a.messages, self.srv_a2.messages, self.fb.messages), ([], [], []))
        self.assertEqual(self.convert(self.cand_b).status_code, 404)           # Alpha cannot convert Beta's candidate

    def test_contents_follow_the_company_settings(self):
        r = self.admin.post(f"{M}/welcome/settings/", {"include_password": False, "include_salary": False,
                                                       "fields": ["employee_code", "email", "role", "date_of_joining", "password", "salary", "login_url"],
                                                       "subject": "Hi {name}, welcome to {company}", "intro": "Hello {name}!",
                                                       "footer": "Bye from {company}", "login_url": "https://hr.alpha.com/login"}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        self.convert()
        m = self.srv_a.messages[0]
        self.assertEqual(m["subject"], "Hi Anita Candidate, welcome to Alpha Corp")
        self.assertNotIn("Welcome@123", m["body"])
        self.assertNotIn("45,000", m["body"])
        self.assertNotIn("Designation", m["body"])                                # not in the chosen fields
        self.assertIn("Login URL: https://hr.alpha.com/login", m["body"])
        self.assertLess(m["body"].index("Employee ID"), m["body"].index("Login email"))
        self.assertLess(m["body"].index("Role:"), m["body"].index("Date of joining"))
        self.assertTrue(m["body"].strip().startswith("Hello Anita Candidate!"))
        self.assertTrue(m["body"].strip().endswith("Bye from Alpha Corp"))

    def test_switched_off_and_duplicates(self):
        self.admin.post(f"{M}/welcome/settings/", {"enabled": False}, format="json")
        self.assertEqual(self.convert().json()["welcome_email"]["status"], "DISABLED")
        self.assertEqual(self.srv_a.messages, [])
        self.admin.post(f"{M}/welcome/settings/", {"enabled": True}, format="json")
        self.assertEqual(self.convert(body={"password": ""}).json()["welcome_email"]["status"], "SENT")      # keeps the stored password
        again = self.convert(body={"password": ""}).json()["welcome_email"]
        self.assertEqual((again["sent"], again["status"]), (False, "ALREADY_SENT"))                            # no double mail
        self.assertEqual(len(self.srv_a.messages), 1)
        changed = self.convert(body={"password": "NewPass#9"}).json()["welcome_email"]
        self.assertEqual(changed["status"], "SENT")                                                          # new password -> new mail
        self.assertIn("NewPass#9", self.srv_a.messages[1]["body"])
        manual = self.admin.post(f"{M}/welcome/{self.cand.employee_code}/send/", {}, format="json")
        self.assertEqual(manual.status_code, 200)
        self.assertEqual(len(self.srv_a.messages), 3)

    def test_recruitment_joining_convert_sends_it_too(self):
        EmployeeDT.objects.filter(pk=self.cand.pk).update(candidate_status="READY_TO_JOIN")
        r = self.admin.post(f"/api/recruitment/joining/{self.cand.id}/convert/", {"password": "Join@2026", "role_code": "employee",
                                                                                   "date_of_joining": "2026-11-10", "designation": "Tester", "basic_salary": "30000"}, format="json")
        self.assertEqual(r.status_code, 200, r.content)
        w = r.json()["data"]["welcome_email"]
        self.assertEqual((w["sent"], w["via"]), (True, "HR Mailbox"))
        body = self.srv_a.messages[0]["body"]
        for part in ("Join@2026", "10 Nov 2026", "Tester", "30,000.00", "Role: Employee"):
            self.assertIn(part, body)

    def test_preview_resend_and_settings_api(self):
        self.convert(body={"password": "Secret#1"})
        p = self.admin.get(f"{M}/welcome/{self.cand.employee_code}/preview/").json()["data"]
        self.assertNotIn("Secret#1", json.dumps(p))                             # the preview masks the password
        self.assertIn("********", p["text"])
        self.assertEqual((p["can_send"], p["will_be_sent_from"]["from_email"], p["to"]), (True, "mail@alpha.com", "anita@alpha.com"))
        self.assertEqual(self.admin.get(f"{M}/welcome/{self.bela.employee_code}/preview/").status_code, 404)      # B2B
        self.assertEqual(self.admin.post(f"{M}/welcome/{self.bela.employee_code}/send/", {}, format="json").status_code, 404)
        s = self.admin.get(f"{M}/welcome/settings/").json()["data"]
        self.assertEqual((s["enabled"], s["include_password"], s["include_salary"]), (True, True, True))
        self.assertIn("date_of_joining", [f["key"] for f in s["available_fields"]])
        for bad in ({"subject": ""}, {"subject": "a\nb"}, {"fields": []}, {"fields": ["email", "ssn"]}, {"login_url": "javascript:alert(1)"},
                    {"intro": "x" * 2001}, {"fields": "email"}):
            self.assertEqual(self.admin.post(f"{M}/welcome/settings/", bad, format="json").status_code, 400, bad)
        self.assertEqual(self.admin_b.get(f"{M}/welcome/settings/").json()["data"]["subject"], s["subject"])
        self.admin.post(f"{M}/welcome/settings/", {"subject": "Alpha only"}, format="json")
        self.assertNotEqual(self.admin_b.get(f"{M}/welcome/settings/").json()["data"]["subject"], "Alpha only")   # per company

    def test_permissions(self):
        code = self.cand.employee_code
        self.assertEqual(self.ro.get(f"{M}/welcome/settings/").status_code, 200)
        self.assertEqual(self.ro.post(f"{M}/welcome/settings/", {"enabled": False}, format="json").status_code, 403)
        self.assertEqual(self.ro.get(f"{M}/welcome/{code}/preview/").status_code, 403)
        self.assertEqual(self.ro.post(f"{M}/welcome/{code}/send/", {}, format="json").status_code, 403)
        self.assertEqual(self.emp.get(f"{M}/welcome/settings/").status_code, 403)
        self.assertEqual(self.client.get(f"{M}/welcome/settings/").status_code, 401)
        EmployeeDT.objects.filter(pk=self.cand.pk).update(Employee_Status="Activate", candidate_status="JOINED", is_active=True)
        self.assertEqual(self.hr.post(f"{M}/welcome/{code}/send/", {}, format="json").status_code, 200)     # HR (edit right)
