# ============================================================
# Workplace Chat - shared logic (Employee app + Admin/HR channel management)
#   1-on-1 chats are stored in the EXISTING Employee.Message table (no copy); group channels in ChannelMessage.
# ============================================================
from datetime import timedelta

from django.db.models import Q
from django.utils import timezone

from Employee.models import EmployeeDT, Message

from .common import (check_attachment, emp_by_code, employees_qs, file_url, get_setting, initials, iso,
                     person_row, presence_map, dm_key)
from .models import (ChannelMessage, ChatAttachment, ChatChannel, ChatMember, DirectMessageMeta)


def size_label(n):
    return f"{n / 1024 / 1024:.1f} MB" if n >= 1024 * 1024 else f"{max(n // 1024, 1)} KB" if n else "0 KB"


def attachment_row(a, request, prefix):
    return {"id": a.id, "name": a.name, "size": a.size, "size_label": size_label(a.size),
            "content_type": a.content_type, "is_image": (a.content_type or "").startswith("image/"),
            "url": file_url(request, a.file), "download_url": f"{prefix}{a.id}/download/"}


def preview(body, atts):
    if body:
        return body if len(body) <= 90 else body[:87] + "..."
    return f"[Attachment] {atts[0].name}" if atts else ""


def edit_allowed(company, created_at):
    w = get_setting(company).message_edit_window_minutes
    return (not w) or timezone.now() - created_at <= timedelta(minutes=w)


def save_attachments(company, files, actor, direct=None, channel_msg=None):
    out = []
    for f in files:
        check_attachment(f, company)
        out.append(ChatAttachment.objects.create(
            company=company, direct_message=direct, channel_message=channel_msg, file=f, name=f.name[:255],
            size=f.size, content_type=getattr(f, "content_type", None), created_by=actor, updated_by=actor))
    return out


# ---------------- direct ----------------
def direct_qs(company, a_code, b_code):
    """Messages exchanged between two employees (both directions), excluding self-addressed rows."""
    return Message.objects.filter(company=company, is_active=True).filter(
        Q(sender_emp_id=a_code, reciver_emp_id=b_code) | Q(sender_emp_id=b_code, reciver_emp_id=a_code))


def direct_row(msg, me, request, names, atts=None, meta=None):
    return {"id": msg.id, "kind": "direct", "body": msg.content,
            "sender": {"employee_code": msg.sender_emp_id, "name": names.get(msg.sender_emp_id),
                       "initials": initials(names.get(msg.sender_emp_id))},
            "is_mine": msg.sender_emp_id == me.employee_code, "is_read": bool(msg.msg_status),
            "is_edited": bool(meta and meta.is_edited), "created_at": iso(msg.timestamp),
            "attachments": [attachment_row(a, request, "/employee/communication/chat/attachments/") for a in (atts or [])],
            "can_edit": msg.sender_emp_id == me.employee_code and edit_allowed(msg.company, msg.timestamp)}


def direct_peers(company, me):
    codes = set(Message.objects.filter(company=company, is_active=True, sender_emp_id=me.employee_code)
                .values_list("reciver_emp_id", flat=True))
    codes |= set(Message.objects.filter(company=company, is_active=True, reciver_emp_id=me.employee_code)
                 .values_list("sender_emp_id", flat=True))
    for ch in ChatChannel.objects.filter(company=company, kind="DIRECT", is_active=True, members__employee=me,
                                         members__is_active=True):
        for k in (ch.dm_key or "").split("|"):
            codes.add(k)
    codes.discard(me.employee_code)
    codes.discard(None)
    return employees_qs(company).filter(employee_code__in=codes, is_active=True)


def direct_channel(company, a, b, create=False, actor=None):
    key = dm_key(a.employee_code, b.employee_code)
    ch = ChatChannel.objects.filter(company=company, dm_key=key).first()
    if ch is None and create:
        ch = ChatChannel.objects.create(company=company, kind="DIRECT", dm_key=key, created_by=actor,
                                        updated_by=actor)
    if ch is not None:
        for e in (a, b):
            ChatMember.objects.get_or_create(channel=ch, employee=e, defaults={
                "company": company, "role": "MEMBER", "created_by": actor, "updated_by": actor})
        if not ch.is_active:
            ch.is_active = True
            ch.save()
    return ch


def direct_state(company, me, peer):
    ch = ChatChannel.objects.filter(company=company, kind="DIRECT", dm_key=dm_key(me.employee_code,
                                                                                    peer.employee_code)).first()
    m = ch.members.filter(employee=me).first() if ch else None
    return {"is_muted": bool(m and m.is_muted)}


def unread_direct(company, me):
    rows = (Message.objects.filter(company=company, is_active=True, reciver_emp_id=me.employee_code)
            .exclude(msg_status=True).values_list("sender_emp_id"))
    out = {}
    for (code,) in rows:
        out[code] = out.get(code, 0) + 1
    return out


# ---------------- channels ----------------
def my_membership(channel, me):
    return channel.members.filter(employee=me, is_active=True).first()


def channel_unread(channel, member):
    qs = ChannelMessage.objects.filter(channel=channel, is_active=True, is_system=False).exclude(
        sender_id=member.employee_id)
    if member.last_read_at:
        qs = qs.filter(created_at__gt=member.last_read_at)
    return qs.count()


def channel_row(ch, request=None, member=None, with_last=True):
    cnt = ch.members.filter(is_active=True).count()
    last = ch.messages.filter(is_active=True).order_by("-id").first() if with_last else None
    row = {"id": ch.id, "type": "channel", "key": f"channel:{ch.id}", "name": ch.name, "description": ch.description,
           "is_private": ch.is_private, "is_archived": ch.is_archived, "members_count": cnt,
           "owner": {"employee_code": ch.owner.employee_code, "name": ch.owner.name} if ch.owner_id else None,
           "last_message_at": iso(ch.last_message_at), "created_at": iso(ch.created_at)}
    if last is not None:
        atts = list(last.attachments.filter(is_active=True))
        row["last_message"] = {"id": last.id, "preview": preview(last.body, atts),
                               "sender_name": last.sender.name if last.sender_id else last.sender_name,
                               "created_at": iso(last.created_at)}
    if member is not None:
        row.update(my_role=member.role, is_muted=member.is_muted, unread_count=channel_unread(ch, member))
    return row


def channel_message_row(msg, me, request, prefix="/employee/communication/chat/attachments/"):
    rep = msg.reply_to
    return {"id": msg.id, "kind": "channel", "channel_id": msg.channel_id, "body": msg.body,
            "is_system": msg.is_system,
            "sender": {"employee_code": msg.sender.employee_code if msg.sender_id else None,
                       "name": msg.sender.name if msg.sender_id else msg.sender_name,
                       "initials": initials(msg.sender.name if msg.sender_id else msg.sender_name)},
            "is_mine": bool(me and msg.sender_id == me.id), "is_edited": msg.is_edited, "edited_at": iso(msg.edited_at),
            "reply_to": {"id": rep.id, "preview": preview(rep.body, []),
                         "sender_name": rep.sender.name if rep.sender_id else rep.sender_name} if rep and rep.is_active
            else None, "created_at": iso(msg.created_at),
            "attachments": [attachment_row(a, request, prefix) for a in msg.attachments.filter(is_active=True)],
            "can_edit": bool(me and msg.sender_id == me.id and not msg.is_system
                             and edit_allowed(msg.company, msg.created_at))}


def system_message(channel, text, actor):
    m = ChannelMessage.objects.create(company=channel.company, channel=channel, body=text, is_system=True,
                                      sender_name="System", created_by=actor, updated_by=actor)
    channel.last_message_at = m.created_at
    channel.save(update_fields=["last_message_at"])
    return m


def add_members(channel, employees, role="MEMBER", actor=None, announce=True):
    added = []
    for e in employees:
        m, created = ChatMember.objects.get_or_create(channel=channel, employee=e, defaults={
            "company": channel.company, "role": role, "created_by": actor, "updated_by": actor})
        if created or not m.is_active:
            if not created:
                m.is_active, m.role = True, role
                m.save()
            added.append(e)
    if announce and added and channel.kind == "GROUP":
        system_message(channel, ", ".join(e.name for e in added) + (" was" if len(added) == 1 else " were")
                       + " added to the channel", actor)
    return added


def validate_channel_name(company, name, exclude_id=None):
    name = (name or "").strip()
    if len(name) < 2:
        raise ValueError("Channel name is required (min 2 characters).")
    if ChatChannel.objects.filter(company=company, kind="GROUP", is_active=True, name__iexact=name).exclude(
            pk=exclude_id).exists():
        raise ValueError("A channel with this name already exists.")
    return name[:100]


def employees_from_codes(company, codes):
    out, seen = [], set()
    for c in (codes or []):
        if c in seen:
            continue
        seen.add(c)
        out.append(emp_by_code(company, c))
    return out
