# Engagement, Surveys & Culture tests.   python manage.py test People.tests_engagement
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 Employee.models import Department, EmployeeDT, EmployeeRole

from .models import Branch
from .tests import MEDIA, client, mk_company

A = "/api/people/engagement"
E = "/employee/engagement"


def png():
    # 1x1 transparent PNG
    return SimpleUploadedFile("b.png", bytes.fromhex(
        "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d49444154789c6360000002000001"
        "e221bc330000000049454e44ae426082"), content_type="image/png")


@MEDIA
class EngagementTests(TestCase):
    def setUp(self):
        self.co, self.other = mk_company("e@x.com"), mk_company("f@x.com")
        self.a, self.o = client(self.co), client(self.other)
        self.tech = Department.objects.create(company=self.co, name="Technology")
        self.fin = Department.objects.create(company=self.co, name="Finance")
        self.branch = Branch.objects.create(company=self.co, name="Pune HQ")
        self.emps = {}
        for key, name, dept in (("rahul", "Rahul Sharma", self.tech), ("priya", "Priya Nair", self.fin),
                                ("hr", "Elena Rostova", self.tech)):
            r = self.a.post("/api/people/directory/", {
                "name": name, "email": f"{key}@x.com", "designation": "Head of HR" if key == "hr" else "Engineer",
                "department": dept.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[key] = EmployeeDT.objects.get(employee_code=r.json()["data"]["employee_code"])
        self.rahul, self.priya, self.hr = (client(self.emps[k]) for k in ("rahul", "priya", "hr"))
        self.role = EmployeeRole.objects.create(company=self.co, role_name="HR", role_code="hr",
                                                can_manage_employees=True)
        self.emps["hr"].role = self.role
        self.hr = client(self.emps["hr"])

    def j(self, r, code=None):
        if code:
            self.assertEqual(r.status_code, code, r.content)
        return r.json()

    # ------------------------------------------------------------------ auth
    def test_authentication_and_authorization(self):
        urls = [f"{A}/", f"{A}/meta/", f"{A}/announcements/", f"{A}/surveys/", f"{A}/feedback/",
                f"{A}/recognition/", f"{A}/events/", f"{A}/announcement-comments/", f"{A}/survey-questions/"]
        anon = APIClient()
        for u in urls:
            self.assertEqual(anon.get(u).status_code, 401, u)
            self.assertEqual(self.rahul.get(u).status_code, 403, u)       # plain employee: no HR role
            self.assertEqual(self.a.get(u).status_code, 200, u)
            self.assertEqual(self.hr.get(u).status_code, 200, u)
            self.assertEqual(self.o.get(u).status_code, 200, u)
        for u in (f"{E}/home/", f"{E}/announcements/", f"{E}/surveys/", f"{E}/feedback/", f"{E}/recognition/",
                  f"{E}/events/"):
            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)
        # view-only HR role cannot write
        ro = EmployeeRole.objects.create(company=self.co, role_name="RO", role_code="ro", can_view_employees=True)
        e = self.emps["priya"]
        e.role = ro
        c = client(e)
        self.assertEqual(c.get(f"{A}/announcements/").status_code, 200)
        self.assertEqual(c.post(f"{A}/announcements/", {"title": "x", "body": "y"}, format="json").status_code, 403)
        # company isolation
        n = self.j(self.a.post(f"{A}/announcements/", {"title": "Iso", "body": "b"}, format="json"), 201)["data"]
        self.assertEqual(self.o.get(f"{A}/announcements/{n['id']}/").status_code, 404)
        self.assertEqual(self.o.patch(f"{A}/announcements/{n['id']}/", {"title": "h"}, format="json").status_code, 404)
        self.assertEqual(self.o.delete(f"{A}/announcements/{n['id']}/").status_code, 404)

    # --------------------------------------------------------- announcements
    def test_announcements_crud_and_employee_feed(self):
        now = timezone.now()
        r = self.a.post(f"{A}/announcements/", {
            "title": "Zenith Annual Tech Hackathon 2026 Announced!", "body": "48 hours of building.",
            "category": "CULTURE_INNOVATION", "priority": "HIGH", "status": "PUBLISHED", "banner_image": png()},
            format="multipart")
        a1 = self.j(r, 201)["data"]
        self.assertEqual(a1["category_label"], "Cultural & Innovation")
        self.assertTrue(a1["banner_image"])
        self.assertEqual(a1["author"]["name"], "Company Admin")
        self.assertEqual(self.a.post(f"{A}/announcements/", {"title": "zenith annual tech hackathon 2026 announced!",
                         "body": "dup", "category": "CULTURE_INNOVATION"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/announcements/", {"title": "T", "body": "b", "category": "NOPE"},
                                     format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/announcements/", {"title": "S", "body": "b", "status": "SCHEDULED"},
                                     format="json").status_code, 400)            # needs publish_at
        a2 = self.j(self.hr.post(f"{A}/announcements/", {
            "title": "New Health Insurance Policy", "body": "Cover raised.", "category": "POLICY_BENEFITS",
            "status": "SCHEDULED", "publish_at": (now + timedelta(days=2)).isoformat()}, format="json"), 201)["data"]
        self.assertEqual(a2["author"]["name"], "Elena Rostova")
        self.assertEqual(a2["effective_status"], "SCHEDULED")
        d = self.j(self.a.post(f"{A}/announcements/", {"title": "Draft one", "body": "b"}, format="json"), 201)["data"]
        lst = self.j(self.a.get(f"{A}/announcements/?tab=all_active"), 200)
        self.assertEqual(len(lst["data"]), 1)
        self.assertEqual(lst["summary"]["all_active"], 1)
        self.assertEqual(lst["summary"]["drafts_scheduled"], 2)
        self.assertEqual(len(self.a.get(f"{A}/announcements/?tab=drafts").json()["data"]), 2)
        self.assertEqual(len(self.a.get(f"{A}/announcements/?category=POLICY_BENEFITS").json()["data"]), 1)
        # employee feed: only live + audience
        feed = self.j(self.rahul.get(f"{E}/announcements/"), 200)["data"]
        self.assertEqual([x["id"] for x in feed], [a1["id"]])
        self.assertFalse(feed[0]["is_read"])
        # audience targeting (Finance only)
        self.j(self.a.patch(f"{A}/announcements/{a1['id']}/", {"audience_type": "DEPARTMENT",
                            "audience_ids": [self.fin.id]}, format="json"), 200)
        self.assertEqual(self.rahul.get(f"{E}/announcements/").json()["data"], [])
        self.assertEqual(self.rahul.get(f"{E}/announcements/{a1['id']}/").status_code, 404)
        self.assertEqual(len(self.priya.get(f"{E}/announcements/").json()["data"]), 1)
        self.assertEqual(self.a.patch(f"{A}/announcements/{a1['id']}/", {"audience_type": "DEPARTMENT",
                         "audience_ids": [999]}, format="json").status_code, 400)
        # engage: view, react (toggle), comment
        pid = a1["id"]
        self.j(self.priya.get(f"{E}/announcements/{pid}/"), 200)
        self.priya.get(f"{E}/announcements/{pid}/")
        x = self.j(self.priya.post(f"{E}/announcements/{pid}/react/", {"reaction": "HEART"}, format="json"), 200)["data"]
        self.assertEqual((x["my_reaction"], x["reactions"]["HEART"]), ("HEART", 1))
        x = self.j(self.priya.post(f"{E}/announcements/{pid}/react/", {"reaction": "ROCKET"}, format="json"), 200)["data"]
        self.assertEqual((x["reactions"]["HEART"], x["reactions"]["ROCKET"]), (0, 1))
        x = self.j(self.priya.post(f"{E}/announcements/{pid}/react/", {"reaction": "ROCKET"}, format="json"), 200)["data"]
        self.assertIsNone(x["my_reaction"])
        self.assertEqual(self.priya.post(f"{E}/announcements/{pid}/react/", {"reaction": "BAD"}, format="json").status_code, 400)
        self.priya.post(f"{E}/announcements/{pid}/react/", {"reaction": "LIKE"}, format="json")
        cm = self.j(self.priya.post(f"{E}/announcements/{pid}/comments/", {"body": "Great!"}, format="json"), 201)["data"]
        self.assertEqual(self.priya.post(f"{E}/announcements/{pid}/comments/", {"body": " "}, format="json").status_code, 400)
        hrc = self.j(self.a.post(f"{A}/announcement-comments/", {"announcement_id": pid, "body": "Thanks!"},
                                 format="json"), 201)["data"]
        self.assertEqual(len(self.priya.get(f"{E}/announcements/{pid}/comments/").json()["data"]), 2)
        self.assertEqual(self.priya.delete(f"{E}/announcements/{pid}/comments/{hrc['id']}/").status_code, 403)
        self.assertEqual(self.priya.delete(f"{E}/announcements/{pid}/comments/{cm['id']}/").status_code, 200)
        m = self.j(self.a.get(f"{A}/announcements/{pid}/metrics/"), 200)["data"]
        self.assertEqual((m["views"], m["unique_viewers"], m["reactions"]["LIKE"], m["comments"]), (2, 1, 1, 1))
        self.assertEqual(m["audience_size"], 1)
        self.assertEqual(self.a.delete(f"{A}/announcement-comments/{hrc['id']}/").status_code, 200)
        # lifecycle actions
        self.assertEqual(self.j(self.a.post(f"{A}/announcements/{d['id']}/publish/"), 200)["data"]["effective_status"], "PUBLISHED")
        self.assertTrue(self.j(self.a.post(f"{A}/announcements/{d['id']}/pin/", {"is_pinned": True}, format="json"), 200)["data"]["is_pinned"])
        self.assertEqual(self.a.post(f"{A}/announcements/{d['id']}/unpublish/").json()["data"]["status"], "DRAFT")
        self.assertEqual(self.a.post(f"{A}/announcements/{d['id']}/archive/").json()["data"]["status"], "ARCHIVED")
        self.assertEqual(self.a.post(f"{A}/announcements/{d['id']}/publish/").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/announcements/{d['id']}/update/", {"title": "Renamed"}, format="json").status_code, 200)
        self.assertEqual(self.a.post(f"{A}/announcements/{d['id']}/delete/").status_code, 200)
        self.assertEqual(self.a.get(f"{A}/announcements/{d['id']}/").status_code, 404)
        # scheduled item goes live automatically once publish_at has passed
        from .engagement_models import Announcement
        Announcement.objects.filter(pk=a2["id"]).update(publish_at=now - timedelta(minutes=1))
        self.assertEqual(self.a.get(f"{A}/announcements/{a2['id']}/").json()["data"]["effective_status"], "PUBLISHED")
        self.assertEqual(len(self.rahul.get(f"{E}/announcements/").json()["data"]), 1)
        self.assertEqual(self.rahul.get(f"{E}/home/").json()["data"]["unread_announcements"], 1)

    # --------------------------------------------------------------- surveys
    def test_surveys(self):
        qs = [{"text": "How satisfied are you?", "qtype": "RATING"},
              {"text": "Would you recommend us?", "qtype": "NPS"},
              {"text": "Best perk?", "qtype": "SINGLE", "options": ["Food", "WFH"]},
              {"text": "Comments", "qtype": "TEXT", "is_required": False}]
        s = self.j(self.a.post(f"{A}/surveys/", {"title": "Q3 2026 Employee Satisfaction & Engagement Pulse",
                   "survey_type": "ENPS", "questions": qs}, format="json"), 201)["data"]
        sid = s["id"]
        self.assertEqual(s["question_count"], 4)
        self.assertEqual(self.a.post(f"{A}/surveys/", {"title": "q3 2026 employee satisfaction & engagement pulse"},
                                     format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/surveys/", {"title": "Bad", "questions": [{"text": "x", "qtype": "SINGLE",
                         "options": ["only"]}]}, format="json").status_code, 400)
        # draft invisible to employees; cannot respond
        self.assertEqual(self.rahul.get(f"{E}/surveys/{sid}/").status_code, 404)
        # granular question CRUD while draft
        q = self.j(self.a.post(f"{A}/survey-questions/", {"survey_id": sid, "text": "Extra", "qtype": "YES_NO"},
                               format="json"), 201)["data"]
        self.assertEqual(q["options"], ["Yes", "No"])
        self.assertEqual(self.a.patch(f"{A}/survey-questions/{q['id']}/", {"text": "Extra 2"}, format="json").status_code, 200)
        self.assertEqual(self.a.delete(f"{A}/survey-questions/{q['id']}/").status_code, 200)
        self.assertEqual(len(self.a.get(f"{A}/surveys/{sid}/questions/").json()["data"]), 4)
        # launch
        empty = self.j(self.a.post(f"{A}/surveys/", {"title": "Empty"}, format="json"), 201)["data"]
        self.assertEqual(self.a.post(f"{A}/surveys/{empty['id']}/launch/").status_code, 400)
        L = self.j(self.a.post(f"{A}/surveys/{sid}/launch/"), 200)["data"]
        self.assertEqual((L["status"], L["target_count"], L["is_open"]), ("ACTIVE", 3, True))
        self.assertEqual(self.a.post(f"{A}/surveys/{sid}/launch/").status_code, 400)
        self.assertEqual(self.a.patch(f"{A}/surveys/{sid}/", {"is_anonymous": False}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/survey-questions/", {"survey_id": sid, "text": "Late"}, format="json").status_code, 400)
        self.assertEqual(self.a.patch(f"{A}/surveys/{sid}/", {"description": "Updated"}, format="json").status_code, 200)
        # employee responds
        got = self.j(self.rahul.get(f"{E}/surveys/{sid}/"), 200)["data"]
        ids = {x["text"]: x["id"] for x in got["questions"]}
        self.assertEqual(self.j(self.rahul.get(f"{E}/surveys/"), 200)["summary"]["pending"], 1)
        bad = self.rahul.post(f"{E}/surveys/{sid}/respond/", {"answers": [
            {"question_id": ids["How satisfied are you?"], "rating": 9}]}, format="json")
        self.assertEqual(bad.status_code, 400)
        full = lambda r, n, c: {"answers": [{"question_id": ids["How satisfied are you?"], "rating": r},
                                            {"question_id": ids["Would you recommend us?"], "rating": n},
                                            {"question_id": ids["Best perk?"], "choice": c},
                                            {"question_id": ids["Comments"], "text": "Nice place"}]}
        self.j(self.rahul.post(f"{E}/surveys/{sid}/respond/", full(5, 10, "food"), format="json"), 201)
        self.assertEqual(self.rahul.post(f"{E}/surveys/{sid}/respond/", full(5, 10, "Food"), format="json").status_code, 409)
        self.j(self.priya.post(f"{E}/surveys/{sid}/respond/", full(3, 5, "WFH"), format="json"), 201)
        self.assertEqual(self.rahul.get(f"{E}/surveys/?status=pending").json()["data"], [])
        self.assertEqual(len(self.rahul.get(f"{E}/surveys/?status=completed").json()["data"]), 1)
        row = self.j(self.a.get(f"{A}/surveys/{sid}/"), 200)["data"]
        self.assertEqual((row["response_count"], row["response_rate"], row["enps"]), (2, 67, 0))
        res = self.j(self.a.get(f"{A}/surveys/{sid}/results/"), 200)["data"]
        self.assertEqual(res["enps"]["promoters"], 1)
        self.assertEqual(res["enps"]["detractors"], 1)
        self.assertEqual(res["questions"][0]["average"], 4.0)
        self.assertEqual(res["questions"][2]["counts"], {"Food": 1, "WFH": 1})
        self.assertNotIn("employee", res["questions"][3]["answers"][0])      # anonymous
        resp = self.j(self.a.get(f"{A}/surveys/{sid}/responses/"), 200)
        self.assertTrue(resp["anonymous"])
        self.assertNotIn("employee", resp["data"][0])
        # close / reopen / clone
        self.assertEqual(self.a.post(f"{A}/surveys/{sid}/close/").json()["data"]["status"], "CLOSED")
        self.assertEqual(self.priya.post(f"{E}/surveys/{sid}/respond/", full(1, 1, "Food"), format="json").status_code, 404)
        self.assertEqual(self.a.post(f"{A}/surveys/{sid}/reopen/").json()["data"]["status"], "ACTIVE")
        c = self.j(self.a.post(f"{A}/surveys/{sid}/clone/"), 201)["data"]
        self.assertEqual((c["status"], c["question_count"]), ("DRAFT", 4))
        self.assertEqual(self.a.post(f"{A}/surveys/{c['id']}/delete/").status_code, 200)
        self.assertEqual(self.o.get(f"{A}/surveys/{sid}/results/").status_code, 404)
        # named survey shows identities
        n = self.j(self.a.post(f"{A}/surveys/", {"title": "Named", "is_anonymous": False, "audience_type": "DEPARTMENT",
                   "audience_ids": [self.fin.id], "questions": [{"text": "Q", "qtype": "TEXT"}]}, format="json"), 201)["data"]
        self.a.post(f"{A}/surveys/{n['id']}/launch/")
        self.assertEqual(self.rahul.get(f"{E}/surveys/{n['id']}/").status_code, 404)    # not in audience
        qid = self.priya.get(f"{E}/surveys/{n['id']}/").json()["data"]["questions"][0]["id"]
        self.priya.post(f"{E}/surveys/{n['id']}/respond/", {"answers": [{"question_id": qid, "text": "hi"}]}, format="json")
        self.assertIn("employee", self.a.get(f"{A}/surveys/{n['id']}/responses/").json()["data"][0])

    # -------------------------------------------------------------- feedback
    def test_feedback(self):
        M = "Could we extend the cafeteria snack hours until 7:30 PM for late shifts?"
        f = self.j(self.rahul.post(f"{E}/feedback/", {"category": "WORKPLACE_FACILITIES", "message": M}, format="json"), 201)["data"]
        self.assertEqual(self.rahul.post(f"{E}/feedback/", {"category": "WORKPLACE_FACILITIES", "message": M.lower()}, format="json").status_code, 400)
        self.assertEqual(self.rahul.post(f"{E}/feedback/", {"message": "x"}, format="json").status_code, 400)
        adm = self.j(self.a.get(f"{A}/feedback/"), 200)
        self.assertIsNone(adm["data"][0]["submitted_by"])                      # anonymous
        self.assertEqual(adm["summary"]["SUBMITTED"], 1)
        self.assertEqual(self.rahul.patch(f"{E}/feedback/{f['id']}/", {"message": "Updated suggestion text"}, format="json").status_code, 200)
        self.assertEqual(self.priya.get(f"{E}/feedback/{f['id']}/").status_code, 404)
        r = self.j(self.a.post(f"{A}/feedback/{f['id']}/review/", {"status": "APPROVED", "assigned_team": "Facilities Team",
                   "response_note": "Approved from next month"}, format="json"), 200)["data"]
        self.assertEqual(r["status_line"], "Approved by Facilities Team")
        self.assertEqual(self.a.post(f"{A}/feedback/{f['id']}/review/", {}, format="json").status_code, 400)
        self.assertEqual(self.rahul.patch(f"{E}/feedback/{f['id']}/", {"message": "too late now x"}, format="json").status_code, 403)
        self.assertEqual(self.rahul.delete(f"{E}/feedback/{f['id']}/").status_code, 403)
        loop = self.j(self.priya.get(f"{E}/feedback/loop/"), 200)["data"]
        self.assertEqual(len(loop), 1)
        self.assertNotIn("submitted_by", loop[0])
        named = self.j(self.rahul.post(f"{E}/feedback/", {"category": "CULTURE", "message": "More team lunches please",
                       "is_anonymous": False}, format="json"), 201)["data"]
        self.assertEqual(self.a.get(f"{A}/feedback/{named['id']}/").json()["data"]["submitted_by"]["name"], "Rahul Sharma")
        self.assertEqual(self.rahul.post(f"{E}/feedback/{named['id']}/delete/").status_code, 200)
        hr = self.j(self.a.post(f"{A}/feedback/", {"category": "IT_TOOLS", "message": "Need faster laptops"}, format="json"), 201)["data"]
        self.assertEqual(self.a.patch(f"{A}/feedback/{hr['id']}/", {"message": "Need faster laptops for devs"}, format="json").status_code, 200)
        self.assertEqual(len(self.a.get(f"{A}/feedback/?status=APPROVED").json()["data"]), 1)
        self.assertEqual(self.a.delete(f"{A}/feedback/{hr['id']}/").status_code, 200)
        self.assertEqual(self.o.get(f"{A}/feedback/{f['id']}/").status_code, 404)

    # ----------------------------------------------------------- recognition
    def test_recognition(self):
        r = self.j(self.priya.post(f"{E}/recognition/", {"recipient_code": self.emps["rahul"].employee_code,
                   "badge": "Innovation Hero", "message": "Thanks for optimizing the portal engine!"}, format="json"), 201)["data"]
        self.assertEqual(r["recipient"]["name"], "Rahul Sharma")
        P = lambda **k: self.priya.post(f"{E}/recognition/", k, format="json")
        code = self.emps["rahul"].employee_code
        self.assertEqual(P(recipient_code=code, badge="Innovation Hero", message="again").status_code, 400)   # same-day dup
        self.assertEqual(P(recipient_code=self.emps["priya"].employee_code, badge="x", message="self").status_code, 400)
        self.assertEqual(P(recipient_code="NOPE", badge="x", message="abc").status_code, 400)
        for i in range(5):      # 1 already sent + 4 more = daily limit of 5, the 5th extra is refused
            self.assertEqual(P(recipient_code=code, badge=f"Badge {i}", message="great").status_code, 201 if i < 4 else 400)
        wall = self.j(self.rahul.get(f"{E}/recognition/"), 200)["data"]
        self.assertEqual(len(wall), 5)
        rec = self.j(self.rahul.get(f"{E}/recognition/received/"), 200)
        self.assertEqual(rec["summary"]["count"], 5)
        self.assertEqual(len(self.priya.get(f"{E}/recognition/given/").json()["data"]), 5)
        self.assertEqual(self.rahul.get(f"{E}/recognition/leaderboard/").json()["data"][0]["rank"], 1)
        self.assertEqual(len(self.rahul.get(f"{E}/recognition/recipients/?search=priya").json()["data"]), 1)
        self.assertEqual(self.rahul.delete(f"{E}/recognition/{r['id']}/").status_code, 403)
        self.assertEqual(self.priya.post(f"{E}/recognition/{r['id']}/delete/").status_code, 200)
        # admin
        k = self.j(self.a.post(f"{A}/recognition/", {"recipient_code": code, "badge": "Team Player", "message": "Awesome",
                   "points": 50}, format="json"), 201)["data"]
        self.assertEqual(k["giver"]["name"], "Company Admin")
        self.assertEqual(self.a.patch(f"{A}/recognition/{k['id']}/", {"points": 5000}, format="json").status_code, 400)
        self.assertEqual(self.a.patch(f"{A}/recognition/{k['id']}/", {"message": "Truly awesome"}, format="json").status_code, 200)
        self.assertEqual(len(self.a.get(f"{A}/recognition/?recipient={code}").json()["data"]), 5)
        self.assertEqual(self.a.get(f"{A}/recognition/leaderboard/").json()["data"][0]["employee"]["employee_code"], code)
        self.assertIn("Innovation Hero", self.a.get(f"{A}/recognition/badges/").json()["data"])
        self.assertEqual(self.a.post(f"{A}/recognition/{k['id']}/delete/").status_code, 200)
        self.assertEqual(self.o.get(f"{A}/recognition/").json()["data"], [])

    # ---------------------------------------------------------------- events
    def test_events(self):
        now = timezone.now()
        e = self.j(self.a.post(f"{A}/events/", {"title": "Zenith Q3 All-Hands Town Hall", "event_type": "TOWN_HALL",
                   "start_at": (now + timedelta(days=5)).isoformat(), "mode": "HYBRID", "capacity": 1,
                   "location": "Hybrid (Auditorium + Zoom)", "meeting_link": "https://zoom.us/j/1", "rsvp_required": True,
                   "banner_image": png()}, format="multipart"), 201)["data"]
        self.assertEqual(e["phase"], "Upcoming")
        self.assertEqual(self.a.post(f"{A}/events/", {"title": "Bad", "start_at": "nonsense"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/events/", {"title": "V", "start_at": str(now.date()), "mode": "VIRTUAL"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/events/", {"title": "Z", "start_at": (now + timedelta(days=1)).isoformat(),
                         "end_at": now.isoformat()}, format="json").status_code, 400)
        past = self.j(self.a.post(f"{A}/events/", {"title": "Old Diwali Party", "event_type": "CELEBRATION",
                      "start_at": (now - timedelta(days=30)).isoformat()}, format="json"), 201)["data"]
        self.assertEqual(past["phase"], "Completed")
        lst = self.j(self.a.get(f"{A}/events/?phase=Upcoming"), 200)
        self.assertEqual(len(lst["data"]), 1)
        self.assertEqual(lst["summary"], {"Upcoming": 1, "Completed": 1})
        # employee
        ev = self.j(self.rahul.get(f"{E}/events/"), 200)["data"]
        self.assertEqual([x["id"] for x in ev], [e["id"]])
        self.assertEqual(len(self.rahul.get(f"{E}/events/?phase=Completed").json()["data"]), 1)
        self.assertEqual(self.rahul.post(f"{E}/events/{past['id']}/rsvp/", {"response": "GOING"}, format="json").status_code, 400)
        x = self.j(self.rahul.post(f"{E}/events/{e['id']}/rsvp/", {"response": "GOING"}, format="json"), 200)["data"]
        self.assertEqual(x["rsvp"]["going"], 1)
        self.assertEqual(self.priya.post(f"{E}/events/{e['id']}/rsvp/", {"response": "GOING"}, format="json").status_code, 409)   # full
        self.assertEqual(self.priya.post(f"{E}/events/{e['id']}/rsvp/", {"response": "MAYBE"}, format="json").status_code, 200)
        self.assertEqual(self.priya.post(f"{E}/events/{e['id']}/rsvp/", {"response": "??"}, format="json").status_code, 400)
        self.assertEqual(self.a.patch(f"{A}/events/{e['id']}/", {"capacity": 0}, format="json").status_code, 400)
        att = self.j(self.a.get(f"{A}/events/{e['id']}/attendees/"), 200)
        self.assertEqual(att["summary"], {"going": 1, "maybe": 1, "declined": 0})
        self.assertEqual(len(self.a.get(f"{A}/events/{e['id']}/attendees/?response=GOING").json()["data"]), 1)
        self.assertEqual(len(self.rahul.get(f"{E}/events/mine/").json()["data"]), 1)
        self.assertEqual(self.rahul.delete(f"{E}/events/{e['id']}/rsvp/").json()["data"]["my_rsvp"], None)
        self.assertEqual(self.priya.post(f"{E}/events/{e['id']}/rsvp/", {"response": "GOING"}, format="json").status_code, 200)
        # audience + cancel + restore
        self.a.patch(f"{A}/events/{e['id']}/", {"audience_type": "BRANCH", "audience_ids": [self.branch.id]}, format="json")
        self.assertEqual(self.rahul.get(f"{E}/events/{e['id']}/").status_code, 404)
        self.a.patch(f"{A}/events/{e['id']}/", {"audience_type": "ALL"}, format="json")
        c = self.j(self.a.post(f"{A}/events/{e['id']}/cancel/", {"reason": "Venue unavailable"}, format="json"), 200)["data"]
        self.assertEqual(c["phase"], "Cancelled")
        self.assertEqual(self.rahul.get(f"{E}/events/").json()["data"], [])
        self.assertEqual(self.rahul.post(f"{E}/events/{e['id']}/rsvp/", {"response": "GOING"}, format="json").status_code, 400)
        self.assertEqual(self.a.post(f"{A}/events/{e['id']}/restore/").json()["data"]["phase"], "Upcoming")
        self.assertEqual(self.a.post(f"{A}/events/{past['id']}/delete/").status_code, 200)
        self.assertEqual(self.o.get(f"{A}/events/{e['id']}/").status_code, 404)
        ov = self.j(self.a.get(f"{A}/"), 200)["data"]
        self.assertEqual([t["key"] for t in ov["tabs"]], ["announcements", "surveys", "feedback", "recognition", "events"])
        self.assertEqual(self.a.get(f"{A}/meta/").json()["data"]["badges"][0], "Innovation Hero")
