# ============================================================
# Workplace Chat & Channels - Admin / HR     /api/communication/...
#   channels/           company group channels (CRUD + members + archive)
#   channel-messages/   moderation of channel messages (private channels: Company Admin only)
# 1-on-1 chats are private between the two employees and are NOT exposed to HR.
# ============================================================
from django.db.models import Count, Q
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.viewsets import ViewSet

from . import chat_core as cc
from .common import (CommAuthMixin, CommCrud, emp_brief, emp_by_code, err, is_company_admin, iso, ok, paginate,
                     person, person_row, presence_map, to_bool, to_int)
from .models import ChannelMessage, ChatChannel, ChatMember


class ChannelAdminViewSet(CommCrud):
    """
    GET  /api/communication/channels/        ?search= ?is_private= ?archived=true|false ?member=<employee_code>
    POST /api/communication/channels/        {name, description?, is_private?, owner_code?, member_codes?[]}
    GET|PATCH|PUT|DELETE .../<id>/           PATCH {name?, description?, is_private?, is_archived?, owner_code?}
    POST .../<id>/update|delete/ ; POST .../<id>/archive/ ../unarchive/
    GET|POST .../<id>/members/               POST {employee_codes:[...]}
    DELETE|POST .../<id>/members/<code>/(remove/)     PATCH .../<id>/members/<code>/ {role: OWNER|ADMIN|MEMBER}
    """
    model, code, select, status_field = ChatChannel, "CHANNEL", ("owner",), None
    permission_action_map = {"archive": "edit", "unarchive": "edit", "member_remove_post": "delete"}

    def scope(self):
        return super().scope().filter(kind="GROUP")

    def filter(self, qs, p):
        q = (p.get("search") or "").strip()
        if q:
            qs = qs.filter(Q(name__icontains=q) | Q(description__icontains=q))
        if p.get("is_private"):
            qs = qs.filter(is_private=to_bool(p["is_private"]))
        if p.get("archived"):
            qs = qs.filter(is_archived=to_bool(p["archived"]))
        if p.get("member"):
            qs = qs.filter(members__employee__employee_code=p["member"], members__is_active=True)
        return qs.distinct()

    def build(self, ch):
        r = cc.channel_row(ch, self.request)
        r["messages_count"] = ch.messages.filter(is_active=True, is_system=False).count()
        return r

    def apply(self, o, d, creating):
        if creating or "name" in d:
            o.name = cc.validate_channel_name(o.company, d.get("name"), o.pk)
        if "description" in d:
            o.description = d["description"] or None
        if "is_private" in d:
            o.is_private = to_bool(d["is_private"])
        if "is_archived" in d:
            o.is_archived = to_bool(d["is_archived"])
        o.kind = "GROUP"
        self._owner = None
        if d.get("owner_code"):
            self._owner = emp_by_code(o.company, d["owner_code"])
        elif creating:
            self._owner = person(self.request)[0]
        self._members = cc.employees_from_codes(o.company, d.get("member_codes")) if creating else []
        if self._owner:
            o.owner = self._owner

    def after_save(self, o, creating):
        if self._owner:
            m, _ = ChatMember.objects.get_or_create(channel=o, employee=self._owner, defaults={
                "company": o.company, "role": "OWNER", "created_by": self.actor(), "updated_by": self.actor()})
            if m.role != "OWNER" or not m.is_active:
                m.role, m.is_active = "OWNER", True
                m.save()
            ChatMember.objects.filter(channel=o, role="OWNER").exclude(pk=m.pk).update(role="ADMIN")
        if creating:
            cc.add_members(o, [e for e in self._members if not self._owner or e.pk != self._owner.pk], "MEMBER",
                           self.actor(), announce=False)
            cc.system_message(o, f"{person(self.request)[1]} created the channel", self.actor())

    def _ch(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    def _set_archived(self, pk, val):
        ch = self._ch(pk)
        if ch is None:
            return err("NOT_FOUND", "Channel not found.", 404)
        ch.is_archived, ch.updated_by = val, self.actor()
        ch.save()
        return ok("CHANNEL_UPDATED", "Channel archived." if val else "Channel restored.", self.build(ch))

    @action(detail=True, methods=["post"])
    def archive(self, request, pk=None):
        return self._set_archived(pk, True)

    @action(detail=True, methods=["post"])
    def unarchive(self, request, pk=None):
        return self._set_archived(pk, False)

    @action(detail=True, methods=["get", "post"])
    def members(self, request, pk=None):
        ch = self._ch(pk)
        if ch is None:
            return err("NOT_FOUND", "Channel not found.", 404)
        if request.method == "POST":
            try:
                people = cc.employees_from_codes(ch.company, request.data.get("employee_codes"))
                if not people:
                    raise ValueError("employee_codes is required.")
            except ValueError as e:
                return err("VALIDATION", str(e))
            added = cc.add_members(ch, people, "MEMBER", self.actor())
            return ok("CHANNEL_MEMBERS_ADDED", f"{len(added)} member(s) added.", [e.employee_code for e in added], 201)
        ms = ch.members.filter(is_active=True).select_related("employee").order_by("role", "employee__name")
        pres = presence_map(ch.company, [m.employee_id for m in ms])
        return ok("CHANNEL_MEMBERS", "Members.", [{**person_row(m.employee, request, pres), "role": m.role,
                                                  "joined_at": iso(m.joined_at)} for m in ms])

    def _rm(self, pk, code):
        ch = self._ch(pk)
        if ch is None:
            return err("NOT_FOUND", "Channel not found.", 404)
        m = ch.members.filter(is_active=True, employee__employee_code=code).select_related("employee").first()
        if m is None:
            return err("NOT_FOUND", "Member not found.", 404)
        if m.role == "OWNER":
            return err("VALIDATION", "Transfer ownership first (PATCH the member with role OWNER).")
        m.is_active = False
        m.save()
        cc.system_message(ch, f"{m.employee.name} was removed from the channel", self.actor())
        return ok("CHANNEL_MEMBER_REMOVED", "Member removed.", {"employee_code": code})

    @action(detail=True, methods=["delete", "patch"], url_path=r"members/(?P<code>[^/]+)", url_name="member-item")
    def member_item(self, request, pk=None, code=None):
        if request.method == "DELETE":
            return self._rm(pk, code)
        return self._role(request, pk, code)

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

    def _role(self, request, pk, code):
        ch = self._ch(pk)
        if ch is None:
            return err("NOT_FOUND", "Channel not found.", 404)
        role = str(request.data.get("role") or "").upper()
        if role not in ("OWNER", "ADMIN", "MEMBER"):
            return err("VALIDATION", "role must be OWNER, ADMIN or MEMBER.")
        m = ch.members.filter(is_active=True, employee__employee_code=code).select_related("employee").first()
        if m is None:
            return err("NOT_FOUND", "Member not found.", 404)
        if role == "OWNER":
            ch.members.filter(role="OWNER").exclude(pk=m.pk).update(role="ADMIN")
            ch.owner = m.employee
            ch.save()
        elif m.role == "OWNER":
            return err("VALIDATION", "Make another member the OWNER first.")
        m.role = role
        m.save()
        return ok("CHANNEL_MEMBER_UPDATED", "Role updated.", {"employee_code": code, "role": role})


class ChannelMessageAdminViewSet(CommAuthMixin, ViewSet):
    """
    GET    /api/communication/channel-messages/?channel=<id> ?search= ?page=   (moderation view)
    GET    /api/communication/channel-messages/<id>/
    DELETE|POST /api/communication/channel-messages/<id>/(delete/)             remove a message
    Private channels: only the Company Admin can read / moderate their messages.
    """

    def _can_see(self, ch):
        return (not ch.is_private) or is_company_admin(self.request)

    def _row(self, m):
        return cc.channel_message_row(m, None, self.request, "/api/communication/chat-attachments/")

    def list(self, request):
        ch = ChatChannel.objects.filter(company=self.company(), kind="GROUP", is_active=True,
                                        pk=to_int(request.query_params.get("channel"))).first()
        if ch is None:
            return err("VALIDATION", "channel (id) is required.")
        if not self._can_see(ch):
            return err("FORBIDDEN", "Messages of private channels are visible to the Company Admin only.", 403)
        qs = ChannelMessage.objects.filter(channel=ch, is_active=True).select_related("sender", "reply_to").order_by("-id")
        q = (request.query_params.get("search") or "").strip()
        if q:
            qs = qs.filter(body__icontains=q)
        rows, meta = paginate(request, qs, self._row)
        return ok("CHANNEL_MESSAGE_LIST", "Messages.", rows, meta=meta)

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

    def retrieve(self, request, pk=None):
        m = self._get(pk)
        if m is None:
            return err("NOT_FOUND", "Message not found.", 404)
        if not self._can_see(m.channel):
            return err("FORBIDDEN", "Messages of private channels are visible to the Company Admin only.", 403)
        return ok("CHANNEL_MESSAGE_DETAIL", "Message.", self._row(m))

    def destroy(self, request, pk=None):
        m = self._get(pk)
        if m is None:
            return err("NOT_FOUND", "Message not found.", 404)
        if not self._can_see(m.channel):
            return err("FORBIDDEN", "Messages of private channels are visible to the Company Admin only.", 403)
        m.is_active, m.updated_by = False, self.actor()
        m.save()
        m.attachments.update(is_active=False)
        return ok("CHANNEL_MESSAGE_DELETED", "Message removed.", {"id": m.id})

    @action(detail=True, methods=["post"], url_path="delete")
    def delete_post(self, request, pk=None):
        return self.destroy(request, pk)


class ChatAttachmentAdminViewSet(CommAuthMixin, ViewSet):
    """GET /api/communication/chat-attachments/<id>/download/  (public channels; private: Company Admin)"""

    @action(detail=True, methods=["get"])
    def download(self, request, pk=None):
        from django.http import Http404
        from People.views_vault import send_file
        from .models import ChatAttachment
        a = ChatAttachment.objects.filter(company=self.company(), pk=pk, is_active=True,
                                          channel_message__isnull=False).select_related("channel_message__channel").first() \
            if str(pk).isdigit() else None
        if a is None or (a.channel_message.channel.is_private and not is_company_admin(request)):
            raise Http404("File not found.")
        return send_file(a.file, a.name)
