# ============================================================
# Workplace Chat & Channels - Employee app          /employee/communication/chat/...
# Auth: Employee JWT only. 1-on-1 chats live in Employee.Message (shared with the legacy /employee/messages/ API).
# ============================================================
from django.db.models import Q
from django.http import Http404
from django.utils import timezone
from rest_framework.parsers import FormParser, JSONParser, MultiPartParser
from rest_framework.views import APIView

from Employee.models import EmployeeDT, Message
from People.views_vault import send_file

from . import chat_core as cc
from .common import (EmployeeBase, dm_key, emp_by_code, employees_qs, err, get_setting, initials, iso, ok, paginate,
                     person_row, presence_map, to_bool, to_int, touch_presence)
from .models import (ChannelMessage, ChatAttachment, ChatChannel, ChatMember, ChatPresence, DirectMessageMeta)

PARSERS = [JSONParser, MultiPartParser, FormParser]
MEDIA_EXT_NOTE = "multipart/form-data with 'attachments' (one or more files) or 'file'"


class Base(EmployeeBase, APIView):
    parser_classes = PARSERS

    def peer(self, code):
        e = employees_qs(self.company()).filter(employee_code=code, is_active=True).first()
        if e is None or e.pk == self.me.pk:
            return None
        return e

    def files(self, request):
        return request.FILES.getlist("attachments") + request.FILES.getlist("file")

    def page_params(self, request):
        try:
            limit = max(1, min(int(request.query_params.get("limit", 50)), 100))
            before = int(request.query_params["before_id"]) if request.query_params.get("before_id") else None
        except ValueError:
            limit, before = 50, None
        return limit, before


# ---------------------------------------------------------------- summary / conversations / people
def build_conversations(view, request):
    c, me = view.company(), view.me
    unread = cc.unread_direct(c, me)
    peers = list(cc.direct_peers(c, me))
    pres = presence_map(c, [p.id for p in peers])
    rows = []
    for p in peers:
        last = cc.direct_qs(c, me.employee_code, p.employee_code).order_by("-id").first()
        atts = list(last.chat_attachments.filter(is_active=True)) if last else []
        st = cc.direct_state(c, me, p)
        rows.append({"type": "direct", "key": f"direct:{p.employee_code}", "peer": person_row(p, request, pres),
                     "last_message": {"id": last.id, "preview": cc.preview(last.content, atts),
                                      "sender_code": last.sender_emp_id, "created_at": iso(last.timestamp)}
                     if last else None, "unread_count": unread.get(p.employee_code, 0), **st,
                     "sort_at": iso(last.timestamp) if last else iso(p.created_at if hasattr(p, "created_at") else None)})
    for m in ChatMember.objects.filter(employee=me, is_active=True, channel__kind="GROUP", channel__is_active=True
                                       ).select_related("channel", "channel__owner"):
        r = cc.channel_row(m.channel, request, m)
        r["sort_at"] = r["last_message"]["created_at"] if r.get("last_message") else r["created_at"]
        rows.append(r)
    rows.sort(key=lambda r: r.get("sort_at") or "", reverse=True)
    return rows


class ChatSummary(Base):
    def get(self, request):
        rows = build_conversations(self, request)
        live = [r for r in rows if not r.get("is_muted")]
        return ok("CHAT_SUMMARY", "Chat summary.", {
            "unread_total": sum(r["unread_count"] for r in live),
            "unread_conversations": sum(1 for r in live if r["unread_count"]),
            "conversations": len(rows), "direct": sum(1 for r in rows if r["type"] == "direct"),
            "channels": sum(1 for r in rows if r["type"] == "channel")})


class Conversations(Base):
    """GET ?tab=all|direct|channels|unread ?search="""

    def get(self, request):
        tab = (request.query_params.get("tab") or "all").lower()
        if tab not in ("all", "direct", "channels", "unread"):
            return err("VALIDATION", "tab must be all, direct, channels or unread.")
        rows = build_conversations(self, request)
        counts = {"all": len(rows), "direct": sum(1 for r in rows if r["type"] == "direct"),
                  "channels": sum(1 for r in rows if r["type"] == "channel"),
                  "unread": sum(1 for r in rows if r["unread_count"])}
        if tab == "direct":
            rows = [r for r in rows if r["type"] == "direct"]
        elif tab == "channels":
            rows = [r for r in rows if r["type"] == "channel"]
        elif tab == "unread":
            rows = [r for r in rows if r["unread_count"]]
        q = (request.query_params.get("search") or "").strip().lower()
        if q:
            rows = [r for r in rows if q in ((r.get("peer") or {}).get("name") or r.get("name") or "").lower()
                    or q in ((r.get("last_message") or {}).get("preview") or "").lower()]
        for r in rows:
            r.pop("sort_at", None)
        return ok("CHAT_CONVERSATIONS", f"Conversations ({counts['all']}).", rows, counts=counts)


class People(Base):
    """GET ?search= - colleagues for 'New 1-on-1 Chat' / adding channel members, with presence."""

    def get(self, request):
        q = (request.query_params.get("search") or "").strip()
        qs = employees_qs(self.company()).filter(is_active=True).exclude(pk=self.me.pk)
        if q:
            qs = qs.filter(Q(name__icontains=q) | Q(employee_code__icontains=q) | Q(Designation__icontains=q))
        rows, meta = paginate(request, qs.order_by("name"), lambda e: e)
        pres = presence_map(self.company(), [e.id for e in rows])
        return ok("CHAT_PEOPLE", "Colleagues.", [person_row(e, request, pres) for e in rows], meta=meta)


class PresenceView(Base):
    """POST {status?: ONLINE|AWAY|BUSY|OFFLINE, status_text?} heartbeat  |  GET ?codes=EMP1,EMP2"""

    def post(self, request):
        st = str(request.data.get("status") or "ONLINE").upper()
        if st not in ("ONLINE", "AWAY", "BUSY", "OFFLINE"):
            return err("VALIDATION", "status must be ONLINE, AWAY, BUSY or OFFLINE.")
        touch_presence(self.me, st, request.data.get("status_text"))
        return ok("PRESENCE_UPDATED", "Presence updated.", presence_map(self.company(), [self.me.id])[self.me.id])

    def get(self, request):
        codes = [c for c in (request.query_params.get("codes") or "").split(",") if c]
        emps = employees_qs(self.company()).filter(employee_code__in=codes) if codes else []
        pres = presence_map(self.company(), [e.id for e in emps])
        return ok("PRESENCE", "Presence.", {e.employee_code: pres[e.id] for e in emps})


# ---------------------------------------------------------------- direct (1-on-1)
class DirectStart(Base):
    """POST {employee_code} -> the 1-on-1 conversation (created if new)."""

    def post(self, request):
        peer = self.peer(str(request.data.get("employee_code") or "").strip())
        if peer is None:
            return err("VALIDATION", "Colleague not found (you cannot chat with yourself).")
        cc.direct_channel(self.company(), self.me, peer, True, self.actor())
        pres = presence_map(self.company(), [peer.id])
        return ok("CHAT_DIRECT_STARTED", "Conversation ready.", {
            "type": "direct", "key": f"direct:{peer.employee_code}", "peer": person_row(peer, request, pres),
            "unread_count": cc.unread_direct(self.company(), self.me).get(peer.employee_code, 0),
            **cc.direct_state(self.company(), self.me, peer)}, 201)


class DirectMessages(Base):
    """GET /chat/direct/<code>/messages/ ?limit= ?before_id=   |   POST {body} or multipart attachments"""

    def get(self, request, code):
        peer = self.peer(code)
        if peer is None:
            return err("NOT_FOUND", "Colleague not found.", 404)
        limit, before = self.page_params(request)
        qs = cc.direct_qs(self.company(), self.me.employee_code, code).order_by("-id")
        if before:
            qs = qs.filter(id__lt=before)
        rows = list(qs[:limit + 1])
        more, rows = len(rows) > limit, rows[:limit][::-1]
        ids = [m.id for m in rows]
        atts, metas = {}, {x.message_id: x for x in DirectMessageMeta.objects.filter(message_id__in=ids)}
        for a in ChatAttachment.objects.filter(direct_message_id__in=ids, is_active=True):
            atts.setdefault(a.direct_message_id, []).append(a)
        names = {self.me.employee_code: self.me.name, code: peer.name}
        pres = presence_map(self.company(), [peer.id])
        return ok("CHAT_DIRECT_MESSAGES", "Messages.", [cc.direct_row(m, self.me, request, names, atts.get(m.id),
                                                                       metas.get(m.id)) for m in rows],
                  meta={"limit": limit, "has_more": more, "oldest_id": rows[0].id if rows else None},
                  peer=person_row(peer, request, pres), **cc.direct_state(self.company(), self.me, peer))

    def post(self, request, code):
        peer = self.peer(code)
        if peer is None:
            return err("NOT_FOUND", "Colleague not found.", 404)
        body, files = str(request.data.get("body") or request.data.get("message") or "").strip(), self.files(request)
        if not body and not files:
            return err("VALIDATION", "Write a message or attach a file.")
        if len(body) > 4000:
            return err("VALIDATION", "Message is too long (max 4000 characters).")
        try:
            for f in files:
                cc.check_attachment(f, self.company())
        except ValueError as e:
            return err("VALIDATION", str(e))
        msg = Message.objects.create(employee=self.me, sender_emp_id=self.me.employee_code, reciver_emp_id=code,
                                     company=self.company(), content=body, msg_status=False,
                                     created_by=self.actor(), updated_by=self.actor())
        atts = cc.save_attachments(self.company(), files, self.actor(), direct=msg)
        names = {self.me.employee_code: self.me.name, code: peer.name}
        return ok("CHAT_DIRECT_SENT", "Message sent.", cc.direct_row(msg, self.me, request, names, atts), 201)


class DirectRead(Base):
    def post(self, request, code):
        if self.peer(code) is None:
            return err("NOT_FOUND", "Colleague not found.", 404)
        n = Message.objects.filter(company=self.company(), is_active=True, sender_emp_id=code,
                                   reciver_emp_id=self.me.employee_code).exclude(msg_status=True).update(msg_status=True)
        return ok("CHAT_DIRECT_READ", "Marked as read.", {"marked": n})


class DirectMute(Base):
    """POST {muted: true|false}"""

    def post(self, request, code):
        peer = self.peer(code)
        if peer is None:
            return err("NOT_FOUND", "Colleague not found.", 404)
        ch = cc.direct_channel(self.company(), self.me, peer, True, self.actor())
        mem = ch.members.get(employee=self.me)
        mem.is_muted = to_bool(request.data.get("muted"), True)
        mem.save()
        return ok("CHAT_DIRECT_MUTED", "Muted." if mem.is_muted else "Unmuted.", {"is_muted": mem.is_muted})


class DirectMessageDetail(Base):
    """PATCH {body} (own, inside the edit window) | DELETE (own)"""

    def _get(self, pk):
        return Message.objects.filter(company=self.company(), pk=pk, is_active=True).first()

    def patch(self, request, pk):
        m = self._get(pk)
        if m is None or self.me.employee_code not in (m.sender_emp_id, m.reciver_emp_id):
            return err("NOT_FOUND", "Message not found.", 404)
        if m.sender_emp_id != self.me.employee_code:
            return err("FORBIDDEN", "You can edit only your own messages.", 403)
        if not cc.edit_allowed(m.company, m.timestamp):
            return err("LOCKED", "The edit window for this message has passed.", 403)
        body = str(request.data.get("body") or "").strip()
        if not body:
            return err("VALIDATION", "body is required.")
        m.content, m.updated_by = body, self.actor()
        m.save()
        meta, _ = DirectMessageMeta.objects.get_or_create(message=m, defaults={"company": m.company})
        meta.is_edited, meta.edited_at = True, timezone.now()
        meta.save()
        names = {m.sender_emp_id: self.me.name}
        return ok("CHAT_DIRECT_EDITED", "Message edited.", cc.direct_row(m, self.me, request, names,
                                                                         list(m.chat_attachments.filter(is_active=True)), meta))

    def delete(self, request, pk):
        m = self._get(pk)
        if m is None or self.me.employee_code not in (m.sender_emp_id, m.reciver_emp_id):
            return err("NOT_FOUND", "Message not found.", 404)
        if m.sender_emp_id != self.me.employee_code:
            return err("FORBIDDEN", "You can delete only your own messages.", 403)
        m.is_active, m.updated_by = False, self.actor()
        m.save()
        m.chat_attachments.update(is_active=False)
        return ok("CHAT_DIRECT_DELETED", "Message deleted.", {"id": m.id})

    def post(self, request, pk):          # POST-only clients: /update/ and /delete/ variants
        return err("NOT_ALLOWED", "Use PATCH, or POST to .../update/ or .../delete/.", 405)


class DirectMessageUpdatePost(DirectMessageDetail):
    def post(self, request, pk):
        return self.patch(request, pk)


class DirectMessageDeletePost(DirectMessageDetail):
    def post(self, request, pk):
        return self.delete(request, pk)


# ---------------------------------------------------------------- group channels
class ChannelBase(Base):
    def channel(self, pk, need_member=True):
        ch = ChatChannel.objects.filter(company=self.company(), pk=pk, kind="GROUP", is_active=True).select_related(
            "owner").first() if str(pk).isdigit() else None
        if ch is None:
            return None, None, err("NOT_FOUND", "Channel not found.", 404)
        mem = cc.my_membership(ch, self.me)
        if need_member and mem is None:
            return ch, None, err("FORBIDDEN", "You are not a member of this channel.", 403)
        return ch, mem, None

    @staticmethod
    def can_manage(mem):
        return bool(mem and mem.role in ("OWNER", "ADMIN"))


class Channels(ChannelBase):
    """GET my channels | POST {name, description?, is_private?, member_codes?[]}"""

    def get(self, request):
        q = (request.query_params.get("search") or "").strip().lower()
        rows = []
        for m in ChatMember.objects.filter(employee=self.me, is_active=True, channel__kind="GROUP",
                                           channel__is_active=True).select_related("channel", "channel__owner"):
            if q and q not in (m.channel.name or "").lower():
                continue
            rows.append(cc.channel_row(m.channel, request, m))
        rows.sort(key=lambda r: r["last_message_at"] or r["created_at"], reverse=True)
        return ok("CHAT_CHANNELS", "My channels.", rows)

    def post(self, request):
        if not get_setting(self.company()).allow_employee_channels:
            return err("FORBIDDEN", "Creating channels is restricted to HR in your company.", 403)
        d = request.data
        try:
            name = cc.validate_channel_name(self.company(), d.get("name"))
            people = cc.employees_from_codes(self.company(), d.get("member_codes"))
        except ValueError as e:
            return err("VALIDATION", str(e))
        ch = ChatChannel.objects.create(company=self.company(), kind="GROUP", name=name,
                                        description=(d.get("description") or None), is_private=to_bool(d.get("is_private")),
                                        owner=self.me, created_by=self.actor(), updated_by=self.actor())
        cc.add_members(ch, [self.me], "OWNER", self.actor(), announce=False)
        cc.add_members(ch, [p for p in people if p.pk != self.me.pk], "MEMBER", self.actor(), announce=False)
        cc.system_message(ch, f"{self.me.name} created the channel", self.actor())
        return ok("CHAT_CHANNEL_CREATED", "Channel created.", cc.channel_row(ch, request, cc.my_membership(ch, self.me)), 201)


class ChannelBrowse(ChannelBase):
    """GET public channels I have not joined"""

    def get(self, request):
        mine = ChatMember.objects.filter(employee=self.me, is_active=True).values_list("channel_id", flat=True)
        q = (request.query_params.get("search") or "").strip()
        qs = ChatChannel.objects.filter(company=self.company(), kind="GROUP", is_active=True, is_private=False,
                                        is_archived=False).exclude(id__in=list(mine)).select_related("owner")
        if q:
            qs = qs.filter(Q(name__icontains=q) | Q(description__icontains=q))
        return ok("CHAT_CHANNEL_BROWSE", "Public channels you can join.", [cc.channel_row(c, request) for c in qs])


class ChannelDetail(ChannelBase):
    """GET | PATCH {name?, description?, is_private?, is_archived?} (owner/admin) | DELETE (owner)"""

    def get(self, request, pk):
        ch, mem, e = self.channel(pk, need_member=False)
        if e:
            return e
        if mem is None and ch.is_private:
            return err("FORBIDDEN", "You are not a member of this channel.", 403)
        row = cc.channel_row(ch, request, mem)
        members = ch.members.filter(is_active=True).select_related("employee").order_by("role", "employee__name")
        pres = presence_map(self.company(), [m.employee_id for m in members])
        row["members"] = [{**person_row(m.employee, request, pres), "role": m.role} for m in members]
        return ok("CHAT_CHANNEL_DETAIL", "Channel.", row)

    def patch(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        if not self.can_manage(mem):
            return err("FORBIDDEN", "Only a channel owner or admin can change it.", 403)
        d = request.data
        try:
            if "name" in d:
                ch.name = cc.validate_channel_name(self.company(), d["name"], ch.pk)
            if "description" in d:
                ch.description = d["description"] or None
            if "is_private" in d:
                ch.is_private = to_bool(d["is_private"])
            if "is_archived" in d:
                ch.is_archived = to_bool(d["is_archived"])
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        ch.updated_by = self.actor()
        ch.save()
        return ok("CHAT_CHANNEL_UPDATED", "Channel updated.", cc.channel_row(ch, request, mem))

    def delete(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        if not (mem and mem.role == "OWNER"):
            return err("FORBIDDEN", "Only the channel owner can delete it.", 403)
        ch.is_active, ch.updated_by = False, self.actor()
        ch.save()
        return ok("CHAT_CHANNEL_DELETED", "Channel deleted.", {"id": ch.id})


class ChannelUpdatePost(ChannelDetail):
    def post(self, request, pk):
        return self.patch(request, pk)


class ChannelDeletePost(ChannelDetail):
    def post(self, request, pk):
        return self.delete(request, pk)


class ChannelJoin(ChannelBase):
    def post(self, request, pk):
        ch, mem, e = self.channel(pk, need_member=False)
        if e:
            return e
        if mem:
            return err("VALIDATION", "You are already a member.")
        if ch.is_private:
            return err("FORBIDDEN", "This channel is private. Ask a member to add you.", 403)
        if ch.is_archived:
            return err("VALIDATION", "This channel is archived.")
        cc.add_members(ch, [self.me], "MEMBER", self.actor(), announce=False)
        cc.system_message(ch, f"{self.me.name} joined the channel", self.actor())
        return ok("CHAT_CHANNEL_JOINED", "Joined.", cc.channel_row(ch, request, cc.my_membership(ch, self.me)))


class ChannelLeave(ChannelBase):
    def post(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        others = ch.members.filter(is_active=True).exclude(pk=mem.pk).order_by("role", "id")
        if mem.role == "OWNER" and others.exists():
            succ = others.first()
            succ.role = "OWNER"
            succ.save()
            ch.owner = succ.employee
            ch.save()
        mem.is_active = False
        mem.save()
        if not others.exists():
            ch.is_archived = True
            ch.save()
        else:
            cc.system_message(ch, f"{self.me.name} left the channel", self.actor())
        return ok("CHAT_CHANNEL_LEFT", "You left the channel.", {"id": ch.id})


class ChannelMembers(ChannelBase):
    """GET members | POST {employee_codes:[...]} (owner/admin)"""

    def get(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        ms = ch.members.filter(is_active=True).select_related("employee").order_by("role", "employee__name")
        pres = presence_map(self.company(), [m.employee_id for m in ms])
        return ok("CHAT_CHANNEL_MEMBERS", "Members.", [{**person_row(m.employee, request, pres), "role": m.role,
                                                       "joined_at": iso(m.joined_at)} for m in ms])

    def post(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        if not self.can_manage(mem):
            return err("FORBIDDEN", "Only a channel owner or admin can add members.", 403)
        if ch.is_archived:
            return err("VALIDATION", "This channel is archived.")
        try:
            people = cc.employees_from_codes(self.company(), request.data.get("employee_codes"))
            if not people:
                raise ValueError("employee_codes is required.")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        added = cc.add_members(ch, people, "MEMBER", self.actor())
        return ok("CHAT_CHANNEL_MEMBERS_ADDED", f"{len(added)} member(s) added.", [x.employee_code for x in added], 201)


class ChannelMemberDetail(ChannelBase):
    """DELETE (remove) | PATCH {role: ADMIN|MEMBER} (owner)"""

    def _target(self, pk, code):
        ch, mem, e = self.channel(pk)
        if e:
            return None, None, None, e
        t = ch.members.filter(is_active=True, employee__employee_code=code).select_related("employee").first()
        if t is None:
            return None, None, None, err("NOT_FOUND", "Member not found.", 404)
        return ch, mem, t, None

    def delete(self, request, pk, code):
        ch, mem, t, e = self._target(pk, code)
        if e:
            return e
        if not self.can_manage(mem):
            return err("FORBIDDEN", "Only a channel owner or admin can remove members.", 403)
        if t.role == "OWNER":
            return err("VALIDATION", "The owner cannot be removed.")
        t.is_active = False
        t.save()
        cc.system_message(ch, f"{t.employee.name} was removed from the channel", self.actor())
        return ok("CHAT_CHANNEL_MEMBER_REMOVED", "Member removed.", {"employee_code": code})

    def patch(self, request, pk, code):
        ch, mem, t, e = self._target(pk, code)
        if e:
            return e
        if not (mem and mem.role == "OWNER"):
            return err("FORBIDDEN", "Only the channel owner can change roles.", 403)
        role = str(request.data.get("role") or "").upper()
        if role not in ("ADMIN", "MEMBER") or t.role == "OWNER":
            return err("VALIDATION", "role must be ADMIN or MEMBER (the owner role cannot be changed).")
        t.role = role
        t.save()
        return ok("CHAT_CHANNEL_MEMBER_UPDATED", "Role updated.", {"employee_code": code, "role": role})


class ChannelMemberRemovePost(ChannelMemberDetail):
    def post(self, request, pk, code):
        return self.delete(request, pk, code)


class ChannelMessages(ChannelBase):
    """GET ?limit= ?before_id=  |  POST {body, reply_to?} or multipart attachments"""

    def get(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        limit, before = self.page_params(request)
        qs = ChannelMessage.objects.filter(channel=ch, is_active=True).select_related("sender", "reply_to", "reply_to__sender").order_by("-id")
        if before:
            qs = qs.filter(id__lt=before)
        rows = list(qs[:limit + 1])
        more, rows = len(rows) > limit, rows[:limit][::-1]
        return ok("CHAT_CHANNEL_MESSAGES", "Messages.", [cc.channel_message_row(m, self.me, request) for m in rows],
                  meta={"limit": limit, "has_more": more, "oldest_id": rows[0].id if rows else None},
                  channel=cc.channel_row(ch, request, mem, with_last=False))

    def post(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        if ch.is_archived:
            return err("VALIDATION", "This channel is archived (read-only).")
        body, files = str(request.data.get("body") or "").strip(), self.files(request)
        if not body and not files:
            return err("VALIDATION", "Write a message or attach a file.")
        if len(body) > 4000:
            return err("VALIDATION", "Message is too long (max 4000 characters).")
        reply = None
        if request.data.get("reply_to"):
            reply = ChannelMessage.objects.filter(channel=ch, is_active=True, pk=to_int(request.data["reply_to"])).first()
            if reply is None:
                return err("VALIDATION", "reply_to is invalid.")
        try:
            for f in files:
                cc.check_attachment(f, self.company())
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        m = ChannelMessage.objects.create(company=self.company(), channel=ch, sender=self.me, body=body, reply_to=reply,
                                          created_by=self.actor(), updated_by=self.actor())
        cc.save_attachments(self.company(), files, self.actor(), channel_msg=m)
        ch.last_message_at = m.created_at
        ch.save(update_fields=["last_message_at"])
        mem.last_read_at = m.created_at
        mem.save(update_fields=["last_read_at"])
        return ok("CHAT_CHANNEL_SENT", "Message sent.", cc.channel_message_row(m, self.me, request), 201)


class ChannelRead(ChannelBase):
    def post(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        mem.last_read_at = timezone.now()
        mem.save(update_fields=["last_read_at"])
        return ok("CHAT_CHANNEL_READ", "Marked as read.", {"unread_count": 0})


class ChannelMute(ChannelBase):
    def post(self, request, pk):
        ch, mem, e = self.channel(pk)
        if e:
            return e
        mem.is_muted = to_bool(request.data.get("muted"), True)
        mem.save()
        return ok("CHAT_CHANNEL_MUTED", "Muted." if mem.is_muted else "Unmuted.", {"is_muted": mem.is_muted})


class ChannelMessageDetail(ChannelBase):
    """PATCH {body} (own, edit window) | DELETE (own, or channel owner/admin)"""

    def _get(self, pk):
        m = ChannelMessage.objects.filter(company=self.company(), pk=pk, is_active=True, is_system=False
                                          ).select_related("channel", "sender").first() if str(pk).isdigit() else None
        if m is None:
            return None, None
        return m, cc.my_membership(m.channel, self.me)

    def patch(self, request, pk):
        m, mem = self._get(pk)
        if m is None or mem is None:
            return err("NOT_FOUND", "Message not found.", 404)
        if m.sender_id != self.me.id:
            return err("FORBIDDEN", "You can edit only your own messages.", 403)
        if not cc.edit_allowed(m.company, m.created_at):
            return err("LOCKED", "The edit window for this message has passed.", 403)
        body = str(request.data.get("body") or "").strip()
        if not body:
            return err("VALIDATION", "body is required.")
        m.body, m.is_edited, m.edited_at, m.updated_by = body, True, timezone.now(), self.actor()
        m.save()
        return ok("CHAT_CHANNEL_EDITED", "Message edited.", cc.channel_message_row(m, self.me, request))

    def delete(self, request, pk):
        m, mem = self._get(pk)
        if m is None or mem is None:
            return err("NOT_FOUND", "Message not found.", 404)
        if m.sender_id != self.me.id and not self.can_manage(mem):
            return err("FORBIDDEN", "You can delete only your own messages.", 403)
        m.is_active, m.updated_by = False, self.actor()
        m.save()
        m.attachments.update(is_active=False)
        return ok("CHAT_CHANNEL_DELETED_MSG", "Message deleted.", {"id": m.id})


class ChannelMessageUpdatePost(ChannelMessageDetail):
    def post(self, request, pk):
        return self.patch(request, pk)


class ChannelMessageDeletePost(ChannelMessageDetail):
    def post(self, request, pk):
        return self.delete(request, pk)


class AttachmentDownload(Base):
    def get(self, request, pk):
        a = ChatAttachment.objects.filter(company=self.company(), pk=pk, is_active=True).first()
        if a is None:
            raise Http404("File not found.")
        ok_ = False
        if a.direct_message_id:
            m = a.direct_message
            ok_ = self.me.employee_code in (m.sender_emp_id, m.reciver_emp_id) and m.is_active
        elif a.channel_message_id:
            m = a.channel_message
            ok_ = m.is_active and (cc.my_membership(m.channel, self.me) is not None or not m.channel.is_private)
        if not ok_:
            raise Http404("File not found.")
        return send_file(a.file, a.name)


class ChatSearch(Base):
    """GET ?q= - messages in my conversations (direct + channels I belong to)"""

    def get(self, request):
        q = (request.query_params.get("q") or "").strip()
        if len(q) < 2:
            return err("VALIDATION", "q must be at least 2 characters.")
        me, c = self.me, self.company()
        out = []
        dms = Message.objects.filter(company=c, is_active=True, content__icontains=q).filter(
            Q(sender_emp_id=me.employee_code) | Q(reciver_emp_id=me.employee_code)).order_by("-id")[:30]
        codes = {x.sender_emp_id for x in dms} | {x.reciver_emp_id for x in dms}
        names = dict(employees_qs(c).filter(employee_code__in=codes).values_list("employee_code", "name"))
        for m in dms:
            other = m.reciver_emp_id if m.sender_emp_id == me.employee_code else m.sender_emp_id
            out.append({"kind": "direct", "conversation_key": f"direct:{other}", "conversation_name": names.get(other),
                        "message_id": m.id, "snippet": cc.preview(m.content, []), "sender_code": m.sender_emp_id,
                        "created_at": iso(m.timestamp)})
        mine = ChatMember.objects.filter(employee=me, is_active=True).values_list("channel_id", flat=True)
        for m in ChannelMessage.objects.filter(company=c, is_active=True, is_system=False, body__icontains=q,
                                               channel_id__in=list(mine), channel__kind="GROUP"
                                               ).select_related("channel", "sender").order_by("-id")[:30]:
            out.append({"kind": "channel", "conversation_key": f"channel:{m.channel_id}",
                        "conversation_name": m.channel.name, "message_id": m.id, "snippet": cc.preview(m.body, []),
                        "sender_name": m.sender.name if m.sender_id else m.sender_name, "created_at": iso(m.created_at)})
        out.sort(key=lambda r: r["created_at"], reverse=True)
        return ok("CHAT_SEARCH", f"{len(out)} result(s).", out[:50])
