# ============================================================
# Communication & Collaboration - shared helpers (reuses People.common: envelope, paging, parsing, CrudBase)
# Everything is computed from the database - no sample / hard-coded data.
# ============================================================
import os
from datetime import date, datetime, timedelta

from django.db.models import Q
from django.utils import timezone
from rest_framework.permissions import BasePermission

from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated  # noqa: F401
from Employee.employee_crud_permissions import (_role_is_usable, actor_label, resolve_actor_role,  # noqa: F401
                                                role_allows)
from Employee.models import EmployeeDT
from People.common import (CrudBase, PeopleAuthMixin, dept_name, emp_brief, emp_by_code, employees_qs, err, iso,  # noqa: F401
                           ok, paginate, to_bool, to_date, to_int)

from .models import (ChatMember, ChatPresence, CommunicationSetting, Meeting, MeetingParticipant)

MODULE = "communication"
WEEKDAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
ALLOWED_EXT = {".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx", ".txt", ".csv", ".png", ".jpg", ".jpeg",
               ".gif", ".webp", ".zip"}


# ---------------- permissions ----------------
def comm_allows(user, act):
    """Company admin always; HR employee via can_<act>_communication if that checkbox exists, else the same
    action on the 'employees' module (existing HR roles keep working without a role migration)."""
    actor = resolve_actor_role(user)
    if actor == "admin":
        return True
    if actor is None:
        return False
    role = _role_is_usable(user)
    if role is None:
        return False
    a = "edit" if act == "approve" else act
    return bool(role_allows(role, MODULE, a) or role_allows(role, "employees", a))


class IsCommunicationUser(BasePermission):
    message = "You do not have permission to manage Communication & Collaboration (needs HR / Employees role access)."
    METHOD_ACTION = {"GET": "view", "HEAD": "view", "OPTIONS": "view", "POST": "create", "PUT": "edit",
                     "PATCH": "edit", "DELETE": "delete"}

    def has_permission(self, request, view):
        act = getattr(view, "permission_action", None)
        if act is None:
            va = getattr(view, "action", None)
            act = {"update_post": "edit", "delete_post": "delete"}.get(va) or (
                getattr(view, "permission_action_map", None) or {}).get(va)
        act = act or self.METHOD_ACTION.get(request.method)
        return bool(act) and comm_allows(request.user, act)


class CommAuthMixin(PeopleAuthMixin):
    permission_classes = [IsCommunicationUser]


class CommCrud(CommAuthMixin, CrudBase):
    pass


def person(request):
    """(EmployeeDT | None, display name) of the caller."""
    u = request.user
    if isinstance(u, EmployeeDT):
        return u, u.name
    return None, "Company Admin"


def is_company_admin(request):
    return resolve_actor_role(request.user) == "admin"


# ---------------- settings / misc ----------------
def get_setting(company):
    s, _ = CommunicationSetting.objects.get_or_create(company=company)
    return s


def initials(name):
    parts = (name or "").split()
    return "".join(p[0] for p in parts[:2]).upper() or "?"


def check_attachment(f, company):
    if os.path.splitext(f.name)[1].lower() not in ALLOWED_EXT:
        raise ValueError("Unsupported file type. Allowed: " + ", ".join(sorted(ALLOWED_EXT)))
    cap = get_setting(company).max_attachment_mb
    if f.size > cap * 1024 * 1024:
        raise ValueError(f"File too large (max {cap} MB).")


def file_url(request, f):
    if not f:
        return None
    try:
        return request.build_absolute_uri(f.url) if request else f.url
    except Exception:
        return None


def dm_key(a, b):
    return "|".join(sorted([a, b]))


# ---------------- presence ----------------
def presence_map(company, employee_ids):
    """{employee_id: {status, status_text, last_seen_at, label}} - 'OFFLINE' once the heartbeat is stale."""
    window = timedelta(minutes=get_setting(company).presence_timeout_minutes)
    now = timezone.now()
    out = {i: {"status": "OFFLINE", "status_text": None, "last_seen_at": None, "label": "Offline"}
           for i in employee_ids}
    for p in ChatPresence.objects.filter(company=company, employee_id__in=list(employee_ids)):
        live = now - p.last_seen_at <= window and p.status != "OFFLINE"
        st = p.status if live else "OFFLINE"
        out[p.employee_id] = {"status": st, "status_text": p.status_text, "last_seen_at": iso(p.last_seen_at),
                              "label": {"ONLINE": "Active now", "AWAY": "Away", "BUSY": "Busy",
                                        "OFFLINE": "Offline"}[st]}
    return out


def person_row(e, request=None, pres=None):
    d = emp_brief(e, request)
    d["initials"] = initials(e.name)
    if pres is not None:
        d["presence"] = pres.get(e.id)
    return d


def touch_presence(emp, status="ONLINE", text=None):
    now = timezone.now()
    p, _ = ChatPresence.objects.get_or_create(employee=emp, defaults={
        "company": emp.company, "status": status, "last_seen_at": now})
    p.status, p.last_seen_at = status, now
    if text is not None:
        p.status_text = text or None
    p.save()
    return p


# ---------------- meetings ----------------
def local_dt(dt):
    return timezone.localtime(dt)


def recurrence_label(m):
    s = local_dt(m.start_at)
    base = {"NONE": "Does not repeat", "DAILY": "Daily", "WEEKLY": f"Weekly on {WEEKDAYS[s.weekday()]}",
            "BIWEEKLY": f"Every 2 weeks on {WEEKDAYS[s.weekday()]}", "MONTHLY": f"Monthly on day {s.day}"}[m.recurrence]
    return base + (f" until {m.recurrence_until:%d %b %Y}" if m.recurrence != "NONE" and m.recurrence_until else "")


def _add_month(d, n=1):
    import calendar
    y, mo = d.year + (d.month - 1 + n) // 12, (d.month - 1 + n) % 12 + 1
    return date(y, mo, min(d.day, calendar.monthrange(y, mo)[1]))


def occurrences(m, from_date, to_date, cap=400):
    """[(start_dt, end_dt)] of the meeting inside [from_date, to_date] (local dates, inclusive)."""
    s0, dur = local_dt(m.start_at), m.end_at - m.start_at
    out, n = [], 0
    until = m.recurrence_until
    cur_date = s0.date()
    while n < cap:
        if until and cur_date > until:
            break
        if cur_date > to_date:
            break
        if cur_date >= from_date or m.recurrence == "NONE":
            if from_date <= cur_date <= to_date:
                st = timezone.make_aware(datetime.combine(cur_date, s0.time()))
                out.append((st, st + dur))
        if m.recurrence == "NONE":
            break
        if m.recurrence == "DAILY":
            cur_date += timedelta(days=1)
        elif m.recurrence == "WEEKLY":
            cur_date += timedelta(days=7)
        elif m.recurrence == "BIWEEKLY":
            cur_date += timedelta(days=14)
        else:
            k = 1
            nxt = _add_month(s0.date(), k)
            while nxt <= cur_date:
                k += 1
                nxt = _add_month(s0.date(), k)
            cur_date = nxt
        n += 1
    return out


def focus_occurrence(m, now=None):
    """(start, end, phase) - the occurrence the list should show: today's, else the next one, else the last one."""
    now = now or timezone.now()
    today = timezone.localdate()
    if m.status == "CANCELLED":
        return m.start_at, m.end_at, "Cancelled"
    horizon = today + timedelta(days=370)
    occ = occurrences(m, local_dt(m.start_at).date(), min(horizon, m.recurrence_until or horizon))
    if not occ:
        return m.start_at, m.end_at, "Completed"
    for s, e in occ:
        if local_dt(s).date() == today and e >= now:
            return s, e, "Today"
    for s, e in occ:
        if s > now:
            return s, e, ("Today" if local_dt(s).date() == today else "Upcoming")
    return occ[-1][0], occ[-1][1], "Completed"


def rsvp_counts(meeting):
    c = {"ACCEPTED": 0, "DECLINED": 0, "TENTATIVE": 0, "PENDING": 0}
    for p in meeting.participants.filter(is_active=True):
        c[p.rsvp] += 1
    return c


def meeting_row(m, request=None, viewer=None, admin=False, parts=None, detail=False):
    s, e, phase = focus_occurrence(m)
    ls, le = local_dt(s), local_dt(e)
    parts = parts if parts is not None else list(m.participants.filter(is_active=True).select_related("employee"))
    mine = next((p for p in parts if viewer and p.employee_id == viewer.id), None)
    org_name = m.organizer.name if m.organizer_id else (m.organizer_name or "Company Admin")
    row = {"id": m.id, "title": m.title, "agenda": m.agenda, "meeting_type": m.meeting_type,
           "meeting_type_label": dict(Meeting.TYPES).get(m.meeting_type),
           "department": {"id": m.department_id, "name": m.department.name} if m.department_id else None,
           "status": m.status, "phase": phase, "start_at": iso(s), "end_at": iso(e),
           "series_start_at": iso(m.start_at), "date": ls.date().isoformat(), "date_label": ls.strftime("%Y-%m-%d"),
           "time_label": f"{ls.strftime('%I:%M %p')} - {le.strftime('%I:%M %p')}",
           "duration_minutes": int((m.end_at - m.start_at).total_seconds() // 60),
           "duration_label": f"{int((m.end_at - m.start_at).total_seconds() // 60)} mins",
           "location": m.location, "meeting_link": m.meeting_link,
           "organizer": {"name": org_name, "employee_code": m.organizer.employee_code if m.organizer_id else None,
                         "initials": initials(org_name)},
           "recurrence": m.recurrence, "recurrence_label": recurrence_label(m) if m.recurrence != "NONE" else None,
           "recurrence_until": iso(m.recurrence_until), "cancel_reason": m.cancel_reason,
           "participants_count": len(parts), "rsvp": {k.lower(): v for k, v in _count(parts).items()},
           "participants_preview": [{"name": p.employee.name, "initials": initials(p.employee.name),
                                     "employee_code": p.employee.employee_code, "rsvp": p.rsvp}
                                    for p in parts[:4]],
           "my_rsvp": mine.rsvp if mine else None, "is_invited": bool(mine),
           "can_edit": bool(admin or (viewer and m.organizer_id == viewer.id)),
           "can_join": m.status != "CANCELLED" and phase in ("Today", "Upcoming") and bool(m.meeting_link),
           "created_at": iso(m.created_at), "updated_at": iso(m.updated_at)}
    if detail:
        row["external_emails"] = m.external_emails
        row["participants"] = [participant_row(p) for p in parts]
    return row


def _count(parts):
    c = {"ACCEPTED": 0, "DECLINED": 0, "TENTATIVE": 0, "PENDING": 0}
    for p in parts:
        c[p.rsvp] += 1
    return c


def participant_row(p):
    return {"employee_code": p.employee.employee_code, "name": p.employee.name,
            "initials": initials(p.employee.name), "designation": p.employee.Designation, "role": p.role,
            "rsvp": p.rsvp, "responded_at": iso(p.responded_at), "joined_at": iso(p.joined_at)}


def find_conflicts(company, employee_ids, start, end, exclude_id=None):
    """Existing meetings that overlap [start, end] for any of the employees (series expanded for that day)."""
    day = local_dt(start).date()
    qs = (Meeting.objects.filter(company=company, is_active=True, status="SCHEDULED")
          .filter(Q(participants__employee_id__in=employee_ids, participants__is_active=True)
                  & ~Q(participants__rsvp="DECLINED")).distinct())
    if exclude_id:
        qs = qs.exclude(pk=exclude_id)
    out = []
    for m in qs.select_related("organizer"):
        for s, e in occurrences(m, day, day):
            if s < end and e > start:
                hit = [p.employee.name for p in m.participants.filter(
                    is_active=True, employee_id__in=employee_ids).exclude(rsvp="DECLINED").select_related("employee")]
                out.append({"meeting_id": m.id, "title": m.title, "start_at": iso(s), "end_at": iso(e),
                            "attendees": hit})
    return out


class EmployeeBase:
    """Employee-app views: employee JWT only; an employee only ever acts on their own data."""
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    def company(self):
        return self.request.user.company

    def actor(self):
        return actor_label(self.request.user)
