# ============================================================
# Meetings & Invitations Desk
#   Admin / HR : /api/communication/meetings/          (HR sees every company meeting)
#   Employee   : /employee/communication/meetings/     (own = organizer or invited; same actions, see views_self.py)
# The viewset logic is shared (MeetingViews); only the visibility / authorization differs.
# ============================================================
from django.db.models import Q
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.viewsets import ViewSet

from People.common import to_date

from .common import (participant_row, CommAuthMixin, EmployeeJWTAuthentication, IsEmployeeAuthenticated, actor_label, err, iso, ok,
                     paginate, to_int)
from .meetings_core import ConflictError, MeetingOps
from .models import Meeting, MeetingParticipant


class MeetingViews(MeetingOps):
    """list / retrieve / create / update / delete + cancel / restore / participants / rsvp / join / summary"""

    # ---- helpers ----
    def _nf(self):
        return err("NOT_FOUND", "Meeting not found.", 404)

    def _guard(self, m):
        if not (self.is_admin or (self.viewer and m.organizer_id == self.viewer.id)):
            return err("FORBIDDEN", "Only the organizer can change this meeting.", 403)
        return None

    def _detail(self, request, m):
        return self.rows([m], request)[0][1] | {
            "participants": [participant_row(p) for p in m.participants.filter(is_active=True)
                             .select_related("employee").order_by("role", "employee__name")],
            "external_emails": m.external_emails}

    # ---- list ----
    def list(self, request):
        p = request.query_params
        qs = self.visible()
        if p.get("department"):
            qs = qs.filter(department_id=p["department"])
        if p.get("type"):
            qs = qs.filter(meeting_type=p["type"].upper())
        if p.get("organizer"):
            qs = qs.filter(organizer__employee_code=p["organizer"])
        q = (p.get("search") or "").strip()
        if q:
            qs = qs.filter(Q(title__icontains=q) | Q(agenda__icontains=q) | Q(organizer_name__icontains=q)
                           | Q(organizer__name__icontains=q) | Q(location__icontains=q))
        meetings = list(qs)
        pairs = self.rows(meetings, request)
        summary = self.summary(self.visible(), request) if not q and not p.get("department") else None
        tab = (p.get("tab") or "all").lower()
        want = {"today": ("Today",), "upcoming": ("Upcoming",), "past": ("Completed", "Cancelled"),
                "completed": ("Completed", "Cancelled"), "all": None}.get(tab)
        if tab not in ("today", "upcoming", "past", "completed", "all"):
            return err("VALIDATION", "tab must be today, upcoming, past or all.")
        rows = [r for _, r in pairs if want is None or r["phase"] in want]
        try:
            if p.get("from"):
                rows = [r for r in rows if r["date"] >= to_date(p["from"]).isoformat()]
            if p.get("to"):
                rows = [r for r in rows if r["date"] <= to_date(p["to"]).isoformat()]
        except ValueError as e:
            return err("VALIDATION", str(e))
        if p.get("my_rsvp"):
            rows = [r for r in rows if r["my_rsvp"] == p["my_rsvp"].upper()]
        rows.sort(key=lambda r: r["start_at"], reverse=(tab in ("past", "completed")))
        page, meta = paginate(request, rows, lambda r: r)
        return ok("MEETING_LIST", "Meetings.", page, meta=meta,
                  summary=summary or self.summary(self.visible(), request))

    @action(detail=False, methods=["get"])
    def summary_stats(self, request):
        return ok("MEETING_SUMMARY", "Meeting statistics.", self.summary(self.visible(), request))

    def retrieve(self, request, pk=None):
        m = self.get_meeting(pk)
        return ok("MEETING_DETAIL", "Meeting.", self._detail(request, m)) if m else self._nf()

    # ---- create / update / delete ----
    def create(self, request):
        try:
            m, conflicts = self.save_new(request.data)
        except ConflictError as ce:
            return err("CONFLICT", "An attendee already has a meeting at this time.", 409,
                       errors={"conflicts": ce.conflicts})
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("MEETING_CREATED", "Meeting scheduled.", self._detail(request, m), 201,
                  warnings={"conflicts": conflicts})

    def partial_update(self, request, pk=None):
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        g = self._guard(m)
        if g:
            return g
        if m.status == "CANCELLED":
            return err("VALIDATION", "A cancelled meeting cannot be edited. Restore it first.")
        try:
            m, conflicts = self.save_update(m, request.data)
        except ConflictError as ce:
            return err("CONFLICT", "An attendee already has a meeting at this time.", 409,
                       errors={"conflicts": ce.conflicts})
        except ValueError as e:
            return err("VALIDATION", str(e))
        return ok("MEETING_UPDATED", "Meeting updated.", self._detail(request, m), warnings={"conflicts": conflicts})

    update = partial_update

    def destroy(self, request, pk=None):
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        g = self._guard(m)
        if g:
            return g
        m.is_active, m.updated_by = False, self.actor()
        m.save()
        return ok("MEETING_DELETED", "Meeting deleted.", {"id": m.id})

    @action(detail=True, methods=["post"])
    def cancel(self, request, pk=None):
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        g = self._guard(m)
        if g:
            return g
        if m.status == "CANCELLED":
            return err("VALIDATION", "Meeting is already cancelled.")
        m.status, m.cancel_reason, m.updated_by = "CANCELLED", request.data.get("reason") or None, self.actor()
        m.save()
        return ok("MEETING_CANCELLED", "Meeting cancelled.", self._detail(request, m))

    @action(detail=True, methods=["post"])
    def restore(self, request, pk=None):
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        g = self._guard(m)
        if g:
            return g
        m.status, m.cancel_reason, m.updated_by = "SCHEDULED", None, self.actor()
        m.save()
        return ok("MEETING_RESTORED", "Meeting restored.", self._detail(request, m))

    # ---- participants ----
    @action(detail=True, methods=["get", "post"])
    def participants(self, request, pk=None):
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        if request.method == "POST":
            g = self._guard(m)
            if g:
                return g
            try:
                people = self.resolve_participants(m, request.data)
                if not people:
                    raise ValueError("Provide participant_codes, participants or invite_department.")
                added = self.add_participants(m, people)
            except ValueError as e:
                return err("VALIDATION", str(e))
            return ok("MEETING_PARTICIPANTS_ADDED", f"{len(added)} participant(s) added.",
                      self._detail(request, m)["participants"], 201, added=added)
        return ok("MEETING_PARTICIPANTS", "Participants.", self._detail(request, m)["participants"])

    def _remove(self, request, pk, code):
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        g = self._guard(m)
        if g:
            return g
        p = m.participants.filter(is_active=True, employee__employee_code=code).first()
        if p is None:
            return err("NOT_FOUND", "Participant not found.", 404)
        if p.role == "ORGANIZER":
            return err("VALIDATION", "The organizer cannot be removed.")
        p.is_active = False
        p.save()
        return ok("MEETING_PARTICIPANT_REMOVED", "Participant removed.", {"employee_code": code})

    @action(detail=True, methods=["delete"], url_path=r"participants/(?P<code>[^/]+)", url_name="participant-remove")
    def participant_remove(self, request, pk=None, code=None):
        return self._remove(request, pk, code)

    @action(detail=True, methods=["post"], url_path=r"participants/(?P<code>[^/]+)/remove",
            url_name="participant-remove-post")
    def participant_remove_post(self, request, pk=None, code=None):
        return self._remove(request, pk, code)

    # ---- RSVP / join ----
    @action(detail=True, methods=["post"])
    def rsvp(self, request, pk=None):
        if self.viewer is None:
            return err("VALIDATION", "Only employees can RSVP.")
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        r = str(request.data.get("response") or "").upper()
        if r not in ("ACCEPTED", "DECLINED", "TENTATIVE"):
            return err("VALIDATION", "response must be ACCEPTED, DECLINED or TENTATIVE.")
        if m.status == "CANCELLED":
            return err("VALIDATION", "This meeting has been cancelled.")
        p = m.participants.filter(is_active=True, employee=self.viewer).first()
        if p is None:
            return err("FORBIDDEN", "You are not invited to this meeting.", 403)
        if m.recurrence == "NONE" and m.end_at < timezone.now():
            return err("VALIDATION", "This meeting is over; RSVP is closed.")
        p.rsvp, p.responded_at, p.updated_by = r, timezone.now(), self.actor()
        p.save()
        return ok("MEETING_RSVP", "RSVP saved.", self.rows([m], request)[0][1])

    @action(detail=True, methods=["post"])
    def join(self, request, pk=None):
        if self.viewer is None:
            return err("VALIDATION", "Only employees can join a meeting room.")
        m = self.get_meeting(pk)
        if m is None:
            return self._nf()
        p = m.participants.filter(is_active=True, employee=self.viewer).first()
        if p is None:
            return err("FORBIDDEN", "You are not invited to this meeting.", 403)
        try:
            s, e = self.join_check(m)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        p.joined_at, p.updated_by = timezone.now(), self.actor()
        if p.rsvp == "PENDING":
            p.rsvp, p.responded_at = "ACCEPTED", timezone.now()
        p.save()
        return ok("MEETING_JOINED", "Joined.", {"meeting_id": m.id, "meeting_link": m.meeting_link,
                                                 "location": m.location, "starts_at": iso(s), "ends_at": iso(e),
                                                 "is_host": m.organizer_id == self.viewer.id})


class MeetingAdminViewSet(MeetingViews, CommAuthMixin, ViewSet):
    """
    GET  /api/communication/meetings/        ?tab=today|upcoming|past|all ?department= ?type= ?organizer=<code> ?search=
                                             ?from= ?to= ?my_rsvp=PENDING ?page= ?page_size=
    POST /api/communication/meetings/        {title, start_at, end_at | duration_minutes, agenda?, meeting_type?, department?,
                                              location?, meeting_link?, recurrence?, recurrence_until?, external_emails?[],
                                              participant_codes?[] | participants?[{employee_code, role}] | invite_department?,
                                              organizer_code?, strict?}
    GET|PATCH|PUT|DELETE .../<id>/     POST .../<id>/update|delete/
    POST .../<id>/cancel/ {reason?}  .../<id>/restore/    GET|POST .../<id>/participants/    DELETE|POST .../<id>/participants/<code>/(remove/)
    POST .../<id>/rsvp/ {response}  .../<id>/join/        (HR users who are employees)     GET .../summary_stats/
    """
    permission_action_map = {"cancel": "edit", "restore": "edit", "participant_remove": "edit",
                             "participant_remove_post": "edit", "rsvp": "view", "join": "view",
                             "summary_stats": "view"}

    @property
    def is_admin(self):
        return True

    @property
    def viewer(self):
        from Employee.models import EmployeeDT
        u = self.request.user
        return u if isinstance(u, EmployeeDT) else None
