# Communication & Collaboration tests.   python manage.py test Communication
from datetime import timedelta

from django.core.files.uploadedfile import SimpleUploadedFile
from django.test import TestCase
from django.utils import timezone
from rest_framework.test import APIClient

from Company.models import Holiday
from Employee.models import Department, EmployeeDT, EmployeeRole, Message
from People.engagement_models import Announcement, AnnouncementView, CompanyEvent
from People.tests import MEDIA, client, mk_company

from .models import ChatChannel, Meeting

A = "/api/communication"
E = "/employee/communication"
NOW = timezone.now()


def pdf(name="Cloud_v2_Architecture_RFC.pdf"):
    return SimpleUploadedFile(name, b"%PDF-1.4 rfc", content_type="application/pdf")


def iso(dt):
    return dt.isoformat()


@MEDIA
class CommTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("cm@x.com"), mk_company("cn@x.com")
        self.a, self.o = client(self.co), client(self.other)
        self.tech = Department.objects.create(company=self.co, name="Technology & Engineering")
        self.hrd = Department.objects.create(company=self.co, name="Human Resources")
        self.emps = {}
        for k, n, d in (("elena", "Elena Rostova", self.hrd), ("amit", "Amit Joshi", self.tech),
                        ("rahul", "Rahul Sharma", self.tech), ("priya", "Priya Patil", self.hrd),
                        ("viewer", "Vik Viewer", self.hrd)):
            r = self.a.post("/api/people/directory/", {
                "name": n, "email": f"{k}@x.com", "designation": "Head" if k == "elena" else "Engineer",
                "department": d.id, "date_of_joining": str(timezone.localdate() - timedelta(days=400)),
                "create_login": True, "password": "pw123456"}, format="json")
            self.assertEqual(r.status_code, 201, r.content)
            self.emps[k] = EmployeeDT.objects.get(employee_code=r.json()["data"]["employee_code"])
        self.code = {k: v.employee_code for k, v in self.emps.items()}
        hr = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr", can_manage_employees=True)
        ro = EmployeeRole.objects.create(company=self.co, role_name="RO", role_code="ro", can_view_employees=True)
        self.emps["elena"].role = hr
        self.emps["viewer"].role = ro
        self.hr, self.amit, self.rahul = (client(self.emps[k]) for k in ("elena", "amit", "rahul"))
        self.priya, self.viewer = client(self.emps["priya"]), client(self.emps["viewer"])

    def j(self, r, code):
        self.assertEqual(r.status_code, code, r.content)
        return r.json()

    # ------------------------------------------------------------------ auth
    def test_authentication_and_authorization(self):
        anon = APIClient()
        urls = [f"{A}/overview/", f"{A}/meta/", f"{A}/announcements/summary/", f"{A}/channels/", f"{A}/meetings/",
                f"{A}/settings/", f"{A}/calendar/"]
        for u in urls:
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.rahul.get(u).status_code, 403, u)
            self.assertEqual(self.a.get(u).status_code, 200, u)
            self.assertEqual(self.hr.get(u).status_code, 200, u)
            self.assertEqual(self.viewer.get(u).status_code, 200, u)
        self.assertEqual(self.viewer.post(f"{A}/channels/", {"name": "x1"}, format="json").status_code, 403)
        self.assertEqual(self.viewer.put(f"{A}/settings/", {"max_attachment_mb": 5}, format="json").status_code, 403)
        self.assertEqual(self.hr.put(f"{A}/settings/", {"max_attachment_mb": 5}, format="json").status_code, 200)
        for u in (f"{E}/chat/summary/", f"{E}/chat/conversations/", f"{E}/chat/people/", f"{E}/chat/channels/",
                  f"{E}/meetings/", f"{E}/home/", f"{E}/calendar/"):
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.a.get(u).status_code, 403, u)           # company-admin token is not an employee
            self.assertEqual(self.rahul.get(u).status_code, 200, u)
        ch = self.j(self.a.post(f"{A}/channels/", {"name": "Isolation"}, format="json"), 201)["data"]
        self.assertEqual(self.o.get(f"{A}/channels/{ch['id']}/").status_code, 404)
        self.assertEqual(self.o.get(f"{A}/channels/").json()["data"], [])

    # ----------------------------------------------------------------- direct
    def test_direct_chat(self):
        amit, rahul = self.code["amit"], self.code["rahul"]
        self.assertEqual(self.hr.post(f"{E}/chat/direct/start/", {"employee_code": self.code["elena"]}, format="json").status_code, 400)  # self
        self.assertEqual(self.hr.post(f"{E}/chat/direct/start/", {"employee_code": "NOPE"}, format="json").status_code, 400)
        st = self.j(self.hr.post(f"{E}/chat/direct/start/", {"employee_code": amit}, format="json"), 201)["data"]
        self.assertEqual(st["peer"]["name"], "Amit Joshi")
        m = self.j(self.hr.post(f"{E}/chat/direct/{amit}/messages/", {"body": "Hi Amit, are we on track?"}, format="json"), 201)["data"]
        self.assertTrue(m["is_mine"])
        self.assertEqual(Message.objects.filter(sender_emp_id=self.code["elena"], reciver_emp_id=amit).count(), 1)  # stored in the legacy table
        self.assertEqual(self.hr.post(f"{E}/chat/direct/{amit}/messages/", {"body": " "}, format="json").status_code, 400)
        self.assertEqual(self.hr.post(f"{E}/chat/direct/{amit}/messages/", {"body": "x" * 4001}, format="json").status_code, 400)
        r = self.j(self.amit.post(f"{E}/chat/direct/{self.code['elena']}/messages/", {"body": "Reviewed the scorecard.", "attachments": pdf()}, format="multipart"), 201)["data"]
        self.assertEqual(r["attachments"][0]["name"], "Cloud_v2_Architecture_RFC.pdf")
        self.assertEqual(self.amit.post(f"{E}/chat/direct/{self.code['elena']}/messages/", {"file": SimpleUploadedFile("a.exe", b"x")}, format="multipart").status_code, 400)
        # unread / conversations / tabs
        conv = self.j(self.hr.get(f"{E}/chat/conversations/"), 200)
        self.assertEqual((len(conv["data"]), conv["data"][0]["unread_count"], conv["counts"]["unread"]), (1, 1, 1))
        self.assertEqual(self.j(self.hr.get(f"{E}/chat/summary/"), 200)["data"]["unread_total"], 1)
        self.assertEqual(len(self.hr.get(f"{E}/chat/conversations/?tab=channels").json()["data"]), 0)
        self.assertEqual(len(self.hr.get(f"{E}/chat/conversations/?search=amit").json()["data"]), 1)
        self.assertEqual(self.hr.get(f"{E}/chat/conversations/?tab=zz").status_code, 400)
        # read receipts
        msgs = self.j(self.hr.get(f"{E}/chat/direct/{amit}/messages/"), 200)
        self.assertEqual([x["is_mine"] for x in msgs["data"]], [True, False])
        self.assertFalse(msgs["data"][0]["is_read"])
        self.assertEqual(self.j(self.hr.post(f"{E}/chat/direct/{amit}/read/"), 200)["data"]["marked"], 1)
        self.assertEqual(self.hr.get(f"{E}/chat/summary/").json()["data"]["unread_total"], 0)
        self.amit.post(f"{E}/chat/direct/{self.code['elena']}/read/")
        self.assertTrue(self.hr.get(f"{E}/chat/direct/{amit}/messages/").json()["data"][0]["is_read"])
        # legacy endpoint sees the same rows (no duplication)
        legacy = self.j(self.hr.get(f"/employee/messages/?receiver_id={amit}"), 200)["data"]
        self.assertEqual(len(legacy), 2)
        # mute excludes from badge
        self.amit.post(f"{E}/chat/direct/{self.code['elena']}/messages/", {"body": "ping"}, format="json")
        self.assertEqual(self.hr.get(f"{E}/chat/summary/").json()["data"]["unread_total"], 1)
        self.assertTrue(self.hr.post(f"{E}/chat/direct/{amit}/mute/", {"muted": True}, format="json").json()["data"]["is_muted"])
        self.assertEqual(self.hr.get(f"{E}/chat/summary/").json()["data"]["unread_total"], 0)
        self.assertTrue(self.hr.get(f"{E}/chat/conversations/").json()["data"][0]["is_muted"])
        # edit / delete rules
        self.assertEqual(self.amit.patch(f"{E}/chat/messages/direct/{m['id']}/", {"body": "hack"}, format="json").status_code, 403)
        e = self.j(self.hr.patch(f"{E}/chat/messages/direct/{m['id']}/", {"body": "Hi Amit, are we on track for 3 PM?"}, format="json"), 200)["data"]
        self.assertTrue(e["is_edited"])
        self.assertEqual(self.rahul.patch(f"{E}/chat/messages/direct/{m['id']}/", {"body": "x"}, format="json").status_code, 404)
        Message.objects.filter(pk=m["id"]).update(timestamp=NOW - timedelta(hours=2))
        self.assertEqual(self.hr.post(f"{E}/chat/messages/direct/{m['id']}/update/", {"body": "late edit"}, format="json").status_code, 403)  # window
        # attachment download: only the two people
        aid = r["attachments"][0]["id"]
        self.assertEqual(self.hr.get(f"{E}/chat/attachments/{aid}/download/").status_code, 200)
        self.assertEqual(self.rahul.get(f"{E}/chat/attachments/{aid}/download/").status_code, 404)
        # search + delete
        self.assertEqual(len(self.j(self.hr.get(f"{E}/chat/search/?q=scorecard"), 200)["data"]), 1)
        self.assertEqual(self.hr.get(f"{E}/chat/search/?q=a").status_code, 400)
        self.assertEqual(self.amit.post(f"{E}/chat/messages/direct/{r['id']}/delete/").status_code, 200)
        self.assertEqual(self.hr.post(f"{E}/chat/messages/direct/{m['id']}/delete/").status_code, 200)
        self.assertEqual(len(self.hr.get(f"{E}/chat/direct/{amit}/messages/").json()["data"]), 1)
        # people + presence
        self.j(self.amit.post(f"{E}/chat/presence/", {"status": "ONLINE"}, format="json"), 200)
        ppl = self.j(self.hr.get(f"{E}/chat/people/?search=amit"), 200)["data"]
        self.assertEqual((ppl[0]["presence"]["status"], ppl[0]["presence"]["label"]), ("ONLINE", "Active now"))
        self.assertEqual(self.hr.get(f"{E}/chat/people/?search=rahul").json()["data"][0]["presence"]["status"], "OFFLINE")
        self.assertEqual(self.amit.post(f"{E}/chat/presence/", {"status": "XX"}, format="json").status_code, 400)

    # --------------------------------------------------------------- channels
    def test_channels_employee_and_admin(self):
        cr = self.j(self.hr.post(f"{E}/chat/channels/", {"name": "HR Operations & People Connect", "description": "HR",
                    "member_codes": [self.code["priya"], self.code["amit"]]}, format="json"), 201)["data"]
        cid = cr["id"]
        self.assertEqual((cr["my_role"], cr["members_count"]), ("OWNER", 3))
        self.assertEqual(self.hr.post(f"{E}/chat/channels/", {"name": "hr operations & people connect"}, format="json").status_code, 400)
        self.assertEqual(self.hr.post(f"{E}/chat/channels/", {"name": "A"}, format="json").status_code, 400)
        self.assertEqual(self.hr.post(f"{E}/chat/channels/", {"name": "Bad", "member_codes": ["NOPE"]}, format="json").status_code, 400)
        # messages, reply, unread
        m1 = self.j(self.priya.post(f"{E}/chat/channels/{cid}/messages/", {"body": "Medical insurance cards arrived"}, format="json"), 201)["data"]
        self.j(self.priya.post(f"{E}/chat/channels/{cid}/messages/", {"body": "Reply", "reply_to": m1["id"], "attachments": pdf("a.pdf")}, format="multipart"), 201)
        self.assertEqual(self.rahul.post(f"{E}/chat/channels/{cid}/messages/", {"body": "outsider"}, format="json").status_code, 403)
        self.assertEqual(self.rahul.get(f"{E}/chat/channels/{cid}/messages/").status_code, 403)
        conv = self.hr.get(f"{E}/chat/conversations/?tab=channels").json()["data"]
        self.assertEqual((conv[0]["name"], conv[0]["unread_count"]), ("HR Operations & People Connect", 2))
        msgs = self.j(self.hr.get(f"{E}/chat/channels/{cid}/messages/"), 200)
        self.assertEqual(msgs["data"][-1]["reply_to"]["id"], m1["id"])
        self.hr.post(f"{E}/chat/channels/{cid}/read/")
        self.assertEqual(self.hr.get(f"{E}/chat/summary/").json()["data"]["unread_total"], 0)
        self.assertEqual(self.priya.patch(f"{E}/chat/messages/channel/{m1['id']}/", {"body": "Medical insurance cards arrived today"}, format="json").status_code, 200)
        self.assertEqual(self.amit.patch(f"{E}/chat/messages/channel/{m1['id']}/", {"body": "x"}, format="json").status_code, 403)
        # permissions: members / roles
        self.assertEqual(self.priya.post(f"{E}/chat/channels/{cid}/members/", {"employee_codes": [self.code["rahul"]]}, format="json").status_code, 403)
        self.assertEqual(self.hr.post(f"{E}/chat/channels/{cid}/members/", {"employee_codes": [self.code["rahul"]]}, format="json").status_code, 201)
        self.assertEqual(self.priya.get(f"{E}/chat/channels/{cid}/messages/").status_code, 200)
        self.assertEqual(self.hr.patch(f"{E}/chat/channels/{cid}/members/{self.code['priya']}/", {"role": "ADMIN"}, format="json").status_code, 200)
        self.assertEqual(self.priya.patch(f"{E}/chat/channels/{cid}/", {"description": "People ops"}, format="json").status_code, 200)
        self.assertEqual(self.priya.delete(f"{E}/chat/channels/{cid}/").status_code, 403)                      # owner only
        self.assertEqual(self.amit.patch(f"{E}/chat/channels/{cid}/", {"description": "x"}, format="json").status_code, 403)
        self.assertEqual(self.priya.post(f"{E}/chat/channels/{cid}/members/{self.code['rahul']}/remove/").status_code, 200)
        self.assertEqual(self.priya.delete(f"{E}/chat/channels/{cid}/members/{self.code['elena']}/").status_code, 400)   # owner
        self.assertEqual(self.priya.delete(f"{E}/chat/messages/channel/{m1['id']}/").status_code, 200)         # own message
        # public join / private block / browse / leave + owner transfer
        pub = self.j(self.amit.post(f"{E}/chat/channels/", {"name": "Tech & Architecture Guild"}, format="json"), 201)["data"]
        prv = self.j(self.amit.post(f"{E}/chat/channels/", {"name": "Leads Only", "is_private": True}, format="json"), 201)["data"]
        names = [c["name"] for c in self.rahul.get(f"{E}/chat/channels/browse/").json()["data"]]
        self.assertIn("Tech & Architecture Guild", names)
        self.assertNotIn("Leads Only", names)
        self.assertEqual(self.rahul.post(f"{E}/chat/channels/{prv['id']}/join/").status_code, 403)
        self.assertEqual(self.rahul.get(f"{E}/chat/channels/{prv['id']}/").status_code, 403)
        self.assertEqual(self.rahul.post(f"{E}/chat/channels/{pub['id']}/join/").status_code, 200)
        self.assertEqual(self.rahul.post(f"{E}/chat/channels/{pub['id']}/join/").status_code, 400)
        self.assertEqual(self.amit.post(f"{E}/chat/channels/{pub['id']}/leave/").status_code, 200)
        det = self.rahul.get(f"{E}/chat/channels/{pub['id']}/").json()["data"]
        self.assertEqual(det["owner"]["employee_code"], self.code["rahul"])
        self.assertTrue(self.rahul.post(f"{E}/chat/channels/{pub['id']}/mute/", {"muted": True}, format="json").json()["data"]["is_muted"])
        self.assertEqual(self.rahul.patch(f"{E}/chat/channels/{pub['id']}/", {"is_archived": True}, format="json").status_code, 200)
        self.assertEqual(self.rahul.post(f"{E}/chat/channels/{pub['id']}/messages/", {"body": "no"}, format="json").status_code, 400)
        self.assertEqual(self.hr.post(f"{E}/chat/channels/{cid}/delete/").status_code, 200)
        # ---- admin / HR moderation
        a = self.j(self.a.post(f"{A}/channels/", {"name": "Announcements Team", "owner_code": self.code["priya"],
                   "member_codes": [self.code["amit"]], "is_private": True}, format="json"), 201)["data"]
        self.assertEqual((a["members_count"], a["owner"]["employee_code"]), (2, self.code["priya"]))
        self.assertEqual(self.a.post(f"{A}/channels/", {"name": "announcements team"}, format="json").status_code, 400)
        self.priya.post(f"{E}/chat/channels/{a['id']}/messages/", {"body": "secret plan"}, format="json")
        self.assertEqual(self.hr.get(f"{A}/channel-messages/?channel={a['id']}").status_code, 403)             # HR: private blocked
        pm = self.j(self.a.get(f"{A}/channel-messages/?channel={a['id']}"), 200)["data"]
        self.assertEqual(len(pm), 2)                                                                            # system + message
        self.assertEqual(self.a.get(f"{A}/channel-messages/?channel=99999").status_code, 400)
        mid = next(x["id"] for x in pm if not x["is_system"])
        self.assertEqual(self.a.post(f"{A}/channel-messages/{mid}/delete/").status_code, 200)
        self.assertEqual(len(self.a.get(f"{A}/channel-messages/?channel={a['id']}").json()["data"]), 1)
        self.assertEqual(self.a.post(f"{A}/channels/{a['id']}/members/", {"employee_codes": [self.code["rahul"]]}, format="json").status_code, 201)
        self.assertEqual(len(self.a.get(f"{A}/channels/{a['id']}/members/").json()["data"]), 3)
        self.assertEqual(self.a.patch(f"{A}/channels/{a['id']}/members/{self.code['amit']}/", {"role": "OWNER"}, format="json").status_code, 200)
        self.assertEqual(self.a.get(f"{A}/channels/{a['id']}/").json()["data"]["owner"]["employee_code"], self.code["amit"])
        self.assertEqual(self.a.post(f"{A}/channels/{a['id']}/members/{self.code['rahul']}/remove/").status_code, 200)
        self.assertEqual(self.a.post(f"{A}/channels/{a['id']}/archive/").json()["data"]["is_archived"], True)
        self.assertEqual(len(self.a.get(f"{A}/channels/?archived=true").json()["data"]), 2)
        self.assertEqual(self.a.post(f"{A}/channels/{a['id']}/unarchive/").json()["data"]["is_archived"], False)
        self.assertEqual(len(self.a.get(f"{A}/channels/?member={self.code['amit']}").json()["data"]), 2)
        self.assertEqual(self.a.post(f"{A}/channels/{a['id']}/update/", {"description": "Comms"}, format="json").status_code, 200)
        self.assertEqual(self.a.delete(f"{A}/channels/{a['id']}/").status_code, 200)
        # 1-on-1 chats are not visible through HR channel APIs
        self.assertEqual(ChatChannel.objects.filter(kind="DIRECT").count(), 0)

    # --------------------------------------------------------------- meetings
    def test_meetings(self):
        today_start = NOW + timedelta(minutes=5)
        M = lambda c, **d: c.post(f"{E if c is not self.a else A}/meetings/", d, format="json")
        t = self.j(self.amit.post(f"{E}/meetings/", {
            "title": "Q3 Engineering Roadmap & Cloud Migration Sync", "agenda": "Review partitioning", "meeting_type": "TEAM_SYNC",
            "department": self.tech.id, "start_at": iso(today_start), "duration_minutes": 45, "location": "Zenith Virtual Alpha Room",
            "meeting_link": "https://meet.zenithcorp.com/room/alpha", "recurrence": "WEEKLY",
            "participant_codes": [self.code["elena"], self.code["rahul"]]}, format="json"), 201)
        mt = t["data"]
        self.assertEqual((mt["phase"], mt["organizer"]["name"], mt["duration_label"], mt["participants_count"]), ("Today", "Amit Joshi", "45 mins", 3))
        self.assertTrue(mt["recurrence_label"].startswith("Weekly on "))
        self.assertEqual(t["warnings"]["conflicts"], [])
        mid = mt["id"]
        # validation / duplicates
        bad = lambda **d: self.amit.post(f"{E}/meetings/", {"title": "T", "start_at": iso(NOW + timedelta(days=9)), **d}, format="json").status_code
        self.assertEqual(bad(end_at=iso(NOW)), 400)
        self.assertEqual(bad(duration_minutes=3), 400)
        self.assertEqual(bad(meeting_link="not a url"), 400)
        self.assertEqual(bad(recurrence="YEARLY"), 400)
        self.assertEqual(bad(participant_codes=["NOPE"]), 400)
        self.assertEqual(bad(external_emails=["bad"]), 400)
        self.assertEqual(bad(meeting_type="ZZ"), 400)
        self.assertEqual(self.amit.post(f"{E}/meetings/", {"title": "Q3 engineering roadmap & cloud migration sync", "start_at": iso(today_start)}, format="json").status_code, 400)
        self.assertEqual(self.amit.post(f"{E}/meetings/", {"title": "No start"}, format="json").status_code, 400)
        # visibility
        self.assertEqual(len(self.rahul.get(f"{E}/meetings/").json()["data"]), 1)
        self.assertEqual(self.priya.get(f"{E}/meetings/").json()["data"], [])
        self.assertEqual(self.priya.get(f"{E}/meetings/{mid}/").status_code, 404)
        self.assertEqual(len(self.a.get(f"{A}/meetings/").json()["data"]), 1)
        # conflict warning (rahul is busy) and strict 409
        c = self.j(self.hr.post(f"{A}/meetings/", {"title": "HR Operations & Headcount Planning Committee", "meeting_type": "HR_COMMITTEE",
                   "start_at": iso(today_start + timedelta(minutes=10)), "duration_minutes": 60, "location": "Executive Boardroom 1 (Pune HQ)",
                   "meeting_link": "https://meet.zenithcorp.com/room/exec", "participant_codes": [self.code["rahul"], self.code["priya"]]}, format="json"), 201)
        self.assertEqual(c["warnings"]["conflicts"][0]["title"], "Q3 Engineering Roadmap & Cloud Migration Sync")
        hid = c["data"]["id"]
        self.assertEqual(c["data"]["organizer"]["name"], "Elena Rostova")
        self.assertEqual(self.hr.post(f"{A}/meetings/", {"title": "Strict", "start_at": iso(today_start), "duration_minutes": 30,
                         "participant_codes": [self.code["rahul"]], "strict": True}, format="json").status_code, 409)
        # tabs + summary
        upc = self.j(self.rahul.post(f"{E}/meetings/", {"title": "Sprint Retrospective", "start_at": iso(NOW + timedelta(days=3)), "participant_codes": [self.code["amit"]]}, format="json"), 201)["data"]
        past = self.j(self.amit.post(f"{E}/meetings/", {"title": "Old Review", "start_at": iso(NOW - timedelta(days=3)), "participant_codes": [self.code["rahul"]]}, format="json"), 201)["data"]
        self.assertEqual((upc["phase"], past["phase"]), ("Upcoming", "Completed"))
        lst = self.j(self.rahul.get(f"{E}/meetings/?tab=today"), 200)
        self.assertEqual([m["title"] for m in lst["data"]][:2], ["Q3 Engineering Roadmap & Cloud Migration Sync", "HR Operations & Headcount Planning Committee"])
        self.assertEqual((lst["summary"]["today"], lst["summary"]["upcoming"], lst["summary"]["completed_past"], lst["summary"]["all"]), (2, 1, 1, 4))
        self.assertEqual(lst["summary"]["pending_rsvps"], 2)                       # rahul: roadmap + hr committee (organizer of sprint, accepted)
        self.assertEqual(len(self.rahul.get(f"{E}/meetings/?tab=past").json()["data"]), 1)
        self.assertEqual(len(self.rahul.get(f"{E}/meetings/?search=sprint").json()["data"]), 1)
        self.assertEqual(len(self.a.get(f"{A}/meetings/?department={self.tech.id}").json()["data"]), 1)
        self.assertEqual(self.rahul.get(f"{E}/meetings/?tab=zz").status_code, 400)
        self.assertEqual(self.rahul.get(f"{E}/meetings/summary_stats/").json()["data"]["all"], 4)
        # RSVP
        r = self.j(self.rahul.post(f"{E}/meetings/{mid}/rsvp/", {"response": "ACCEPTED"}, format="json"), 200)["data"]
        self.assertEqual((r["my_rsvp"], r["rsvp"]["accepted"]), ("ACCEPTED", 2))
        self.assertEqual(self.rahul.post(f"{E}/meetings/{mid}/rsvp/", {"response": "MAYBE"}, format="json").status_code, 400)
        self.assertEqual(self.priya.post(f"{E}/meetings/{mid}/rsvp/", {"response": "ACCEPTED"}, format="json").status_code, 404)
        self.assertEqual(self.rahul.post(f"{E}/meetings/{past['id']}/rsvp/", {"response": "ACCEPTED"}, format="json").status_code, 400)  # over
        self.assertEqual(self.rahul.post(f"{E}/meetings/{mid}/rsvp/", {"response": "TENTATIVE"}, format="json").json()["data"]["my_rsvp"], "TENTATIVE")
        # join
        j = self.j(self.hr.post(f"{E}/meetings/{mid}/join/"), 200) if False else None
        self.assertEqual(self.rahul.post(f"{E}/meetings/{mid}/join/").json()["data"]["meeting_link"], "https://meet.zenithcorp.com/room/alpha")
        self.assertEqual(self.rahul.post(f"{E}/meetings/{past['id']}/join/").status_code, 400)
        self.assertEqual(self.rahul.post(f"{E}/meetings/{upc['id']}/join/").status_code, 400)                     # not open yet (no link anyway)
        self.assertEqual(self.a.post(f"{A}/meetings/{mid}/rsvp/", {"response": "ACCEPTED"}, format="json").status_code, 400)  # admin has no employee
        # edit permissions + reschedule resets RSVP
        self.assertEqual(self.rahul.patch(f"{E}/meetings/{mid}/", {"title": "hack"}, format="json").status_code, 403)
        u = self.j(self.amit.patch(f"{E}/meetings/{mid}/", {"start_at": iso(today_start + timedelta(hours=1)), "duration_minutes": 30}, format="json"), 200)["data"]
        self.assertEqual(self.rahul.get(f"{E}/meetings/{mid}/").json()["data"]["my_rsvp"], "PENDING")
        self.assertEqual(u["duration_minutes"], 30)
        self.assertEqual(self.hr.patch(f"{A}/meetings/{mid}/", {"agenda": "Updated agenda"}, format="json").status_code, 200)   # HR can edit any
        # participants
        self.assertEqual(self.rahul.post(f"{E}/meetings/{mid}/participants/", {"participant_codes": [self.code["priya"]]}, format="json").status_code, 403)
        pr = self.j(self.amit.post(f"{E}/meetings/{mid}/participants/", {"participants": [{"employee_code": self.code["priya"], "role": "OPTIONAL"}]}, format="json"), 201)
        self.assertEqual(pr["added"], [self.code["priya"]])
        self.assertEqual(self.priya.get(f"{E}/meetings/{mid}/").status_code, 200)
        self.assertEqual(self.amit.post(f"{E}/meetings/{mid}/participants/", {"invite_department": self.hrd.id}, format="json").status_code, 201)
        self.assertEqual(self.amit.delete(f"{E}/meetings/{mid}/participants/{self.code['amit']}/").status_code, 400)       # organizer
        self.assertEqual(self.amit.post(f"{E}/meetings/{mid}/participants/{self.code['priya']}/remove/").status_code, 200)
        self.assertEqual(self.priya.get(f"{E}/meetings/{mid}/").status_code, 404)
        # cancel / restore / delete
        cx = self.j(self.amit.post(f"{E}/meetings/{upc['id']}/cancel/", {"reason": "Moved"}, format="json"), 403) if False else None
        self.assertEqual(self.rahul.post(f"{E}/meetings/{upc['id']}/cancel/", {"reason": "Conflict"}, format="json").json()["data"]["phase"], "Cancelled")
        self.assertEqual(self.rahul.patch(f"{E}/meetings/{upc['id']}/", {"title": "x"}, format="json").status_code, 400)
        self.assertEqual(self.rahul.post(f"{E}/meetings/{upc['id']}/restore/").json()["data"]["phase"], "Upcoming")
        self.assertEqual(self.rahul.post(f"{E}/meetings/{upc['id']}/delete/").status_code, 200)
        self.assertEqual(self.a.delete(f"{A}/meetings/{hid}/").status_code, 200)
        self.assertEqual(self.o.get(f"{A}/meetings/{mid}/").status_code, 404)
        # overview + home
        ov = self.j(self.a.get(f"{A}/overview/"), 200)["data"]
        self.assertEqual([t["key"] for t in ov["tabs"]], ["chat", "announcements", "meetings", "calendar"])
        self.assertEqual(self.rahul.get(f"{E}/home/").json()["data"]["meetings_today"], 1)

    # --------------------------------------------------------------- calendar
    def test_calendar_and_settings_and_announcements(self):
        t0 = timezone.localtime(NOW).replace(hour=10, minute=0, second=0, microsecond=0)
        first = t0.replace(day=1)
        w = self.j(self.amit.post(f"{E}/meetings/", {"title": "Weekly Sync", "start_at": iso(first), "duration_minutes": 30,
                   "recurrence": "WEEKLY", "participant_codes": [self.code["rahul"]]}, format="json"), 201)["data"]
        Holiday.objects.create(company=self.co, name="Diwali", date=first + timedelta(days=4), holiday_type="National")
        CompanyEvent.objects.create(company=self.co, title="Town Hall", event_type="TOWN_HALL", start_at=first + timedelta(days=6))
        cal = self.j(self.rahul.get(f"{E}/calendar/?view=month&date={first.date()}"), 200)["data"]
        by = {}
        for it in cal["items"]:
            by.setdefault(it["source"], []).append(it)
        self.assertGreaterEqual(len(by["meeting"]), 4)                          # weekly occurrences expanded
        self.assertEqual((len(by["holiday"]), len(by["event"])), (1, 1))
        self.assertEqual(cal["range"]["from"], str(first.date()))
        self.assertTrue(cal["days"][str(first.date())][0]["title"] == "Weekly Sync")
        self.assertEqual(len(self.priya.get(f"{E}/calendar/?view=month&date={first.date()}&sources=meetings").json()["data"]["items"]), 0)
        self.assertEqual(len(self.a.get(f"{A}/calendar/?view=month&date={first.date()}&sources=meetings").json()["data"]["items"]), len(by["meeting"]))
        wk = self.j(self.rahul.get(f"{E}/calendar/?view=week&date={first.date()}"), 200)["data"]
        self.assertEqual((wk["range"]["to"] > wk["range"]["from"]), True)
        self.assertEqual(self.rahul.get(f"{E}/calendar/?view=day&date={first.date()}").json()["data"]["range"]["from"], str(first.date()))
        self.assertEqual(self.rahul.get(f"{E}/calendar/?view=year").status_code, 400)
        self.assertEqual(self.rahul.get(f"{E}/calendar/?sources=zzz").status_code, 400)
        self.assertEqual(self.rahul.get(f"{E}/calendar/?from=2026-01-05&to=2026-01-01").status_code, 400)
        # recurrence ends
        self.amit.patch(f"{E}/meetings/{w['id']}/", {"recurrence_until": str((first + timedelta(days=8)).date())}, format="json")
        self.assertEqual(len(self.rahul.get(f"{E}/calendar/?view=month&date={first.date()}&sources=meetings").json()["data"]["items"]), 2)
        # announcements summary reuses the engagement tables
        Announcement.objects.create(company=self.co, title="Hackathon", body="b", status="PUBLISHED", published_at=NOW)
        Announcement.objects.create(company=self.co, title="Later", body="b", status="SCHEDULED", publish_at=NOW + timedelta(days=2))
        Announcement.objects.create(company=self.co, title="Draft", body="b")
        a = Announcement.objects.get(title="Hackathon")
        AnnouncementView.objects.create(company=self.co, announcement=a, employee=self.emps["rahul"], view_count=7)
        s = self.j(self.a.get(f"{A}/announcements/summary/"), 200)["data"]
        self.assertEqual((s["total_active_announcements"], s["scheduled_for_future"], s["draft_announcements"], s["total_employee_reads"]), (1, 1, 1, 7))
        self.assertEqual(s["target_groups"][0]["employees"], 5)
        self.assertEqual({g["label"] for g in s["target_groups"]} >= {"Technology & Engineering", "Human Resources"}, True)
        # settings drive behaviour
        self.assertTrue(self.j(self.a.get(f"{A}/settings/"), 200)["data"]["allow_employee_channels"])
        self.assertEqual(self.a.put(f"{A}/settings/", {"max_attachment_mb": 99}, format="json").status_code, 400)
        self.a.put(f"{A}/settings/", {"allow_employee_channels": False, "max_attachment_mb": 1}, format="json")
        self.assertEqual(self.rahul.post(f"{E}/chat/channels/", {"name": "Not Allowed"}, format="json").status_code, 403)
        big = SimpleUploadedFile("big.pdf", b"0" * (1024 * 1024 + 5), content_type="application/pdf")
        self.assertEqual(self.rahul.post(f"{E}/chat/direct/{self.code['amit']}/messages/", {"file": big}, format="multipart").status_code, 400)
        self.a.put(f"{A}/settings/", {"block_on_conflict": True}, format="json")
        self.assertEqual(self.amit.post(f"{E}/meetings/", {"title": "Clash", "start_at": iso(first), "duration_minutes": 30,
                         "participant_codes": [self.code["rahul"]]}, format="json").status_code, 409)
        self.assertEqual(len(self.a.get(f"{A}/meta/").json()["data"]["meeting_types"]), 7)
