# ============================================================
# Meetings & Invitations - business logic shared by the Admin/HR API and the Employee app API
# ============================================================
from datetime import datetime, timedelta

from django.core.exceptions import ValidationError
from django.core.validators import URLValidator, validate_email
from django.db import transaction
from django.db.models import Q
from django.utils import timezone

from Employee.models import Department
from People.engagement_common import to_dt

from .common import (emp_by_code, employees_qs, get_setting, local_dt, meeting_row, occurrences, focus_occurrence,
                     find_conflicts, to_int)
from .models import Meeting, MeetingParticipant


class MeetingOps:
    """Needs: self.company(), self.actor(), self.viewer (EmployeeDT | None), self.is_admin (bool)."""

    # ---------- queries ----------
    def visible(self):
        qs = Meeting.objects.filter(company=self.company(), is_active=True).select_related("organizer", "department")
        if self.is_admin:
            return qs
        v = self.viewer
        return qs.filter(Q(organizer=v) | Q(participants__employee=v, participants__is_active=True)).distinct()

    def get_meeting(self, pk):
        return self.visible().filter(pk=pk).first() if str(pk).isdigit() else None

    def rows(self, meetings, request):
        parts = {}
        for p in MeetingParticipant.objects.filter(meeting__in=meetings, is_active=True).select_related("employee"):
            parts.setdefault(p.meeting_id, []).append(p)
        return [(m, meeting_row(m, request, self.viewer, self.is_admin, parts.get(m.id, []))) for m in meetings]

    def summary(self, meetings, request):
        rows = [r for _, r in self.rows(meetings, request)]
        pend = sum(1 for r in rows if r["my_rsvp"] == "PENDING" and r["phase"] in ("Today", "Upcoming"))
        c = {"today": 0, "upcoming": 0, "past": 0, "cancelled": 0}
        for r in rows:
            c[{"Today": "today", "Upcoming": "upcoming", "Completed": "past", "Cancelled": "cancelled"}[r["phase"]]] += 1
        return {"today": c["today"], "upcoming": c["upcoming"], "completed_past": c["past"] + c["cancelled"],
                "completed": c["past"], "cancelled": c["cancelled"], "all": len(rows),
                "pending_rsvps": pend if self.viewer else None}

    # ---------- create / update ----------
    def _validate_url(self, v):
        if v:
            try:
                URLValidator(schemes=["http", "https"])(v)
            except ValidationError:
                raise ValueError("meeting_link must be a valid http(s) URL.")

    def apply(self, m, d, creating):
        st = get_setting(m.company)
        if creating or "title" in d:
            if not str(d.get("title") or "").strip():
                raise ValueError("title is required.")
            m.title = str(d["title"]).strip()[:200]
        if "agenda" in d:
            m.agenda = d["agenda"] or None
        if "meeting_type" in d:
            t = str(d["meeting_type"]).upper()
            if t not in dict(Meeting.TYPES):
                raise ValueError("Invalid meeting_type. Allowed: " + ", ".join(dict(Meeting.TYPES)))
            m.meeting_type = t
        if "department" in d:
            if d["department"] in (None, ""):
                m.department = None
            else:
                m.department = Department.objects.filter(company=m.company, pk=to_int(d["department"])).first()
                if m.department is None:
                    raise ValueError("department is invalid.")
        self._times(m, d, creating, st)
        for f in ("location",):
            if f in d:
                setattr(m, f, d[f] or None)
        if "meeting_link" in d:
            self._validate_url(d["meeting_link"])
            m.meeting_link = d["meeting_link"] or None
        if "recurrence" in d:
            r = str(d["recurrence"] or "NONE").upper()
            if r not in dict(Meeting.RECURRENCE):
                raise ValueError("Invalid recurrence. Allowed: " + ", ".join(dict(Meeting.RECURRENCE)))
            m.recurrence = r
        if "recurrence_until" in d:
            from People.common import to_date
            m.recurrence_until = to_date(d["recurrence_until"])
        if m.recurrence == "NONE":
            m.recurrence_until = None
        elif m.recurrence_until and m.recurrence_until < local_dt(m.start_at).date():
            raise ValueError("recurrence_until cannot be before the first meeting date.")
        if "external_emails" in d:
            em = d["external_emails"] or []
            if not isinstance(em, list):
                raise ValueError("external_emails must be a list.")
            for e in em:
                try:
                    validate_email(e)
                except ValidationError:
                    raise ValueError(f"Invalid email: {e}")
            m.external_emails = sorted({e.strip().lower() for e in em})
        if creating:
            if self.viewer is not None:
                m.organizer = self.viewer
                m.organizer_name = self.viewer.name
            elif d.get("organizer_code"):
                m.organizer = emp_by_code(m.company, d["organizer_code"])
                m.organizer_name = m.organizer.name
            else:
                m.organizer_name = "Company Admin"
        elif "organizer_code" in d and self.is_admin:
            m.organizer = emp_by_code(m.company, d["organizer_code"])
            m.organizer_name = m.organizer.name
        dup = Meeting.objects.filter(company=m.company, is_active=True, status="SCHEDULED", title__iexact=m.title,
                                     start_at=m.start_at, organizer=m.organizer).exclude(pk=m.pk)
        if dup.exists():
            raise ValueError("A meeting with this title, start time and organizer already exists.")

    def _times(self, m, d, creating, st):
        if creating or "start_at" in d:
            s = to_dt(d.get("start_at"))
            if s is None:
                raise ValueError("start_at is required (ISO datetime).")
            m.start_at = s
        if "end_at" in d and d["end_at"]:
            m.end_at = to_dt(d["end_at"])
        elif "duration_minutes" in d and d["duration_minutes"]:
            dur = to_int(d["duration_minutes"])
            if not dur or dur < 5 or dur > 1440:
                raise ValueError("duration_minutes must be between 5 and 1440.")
            m.end_at = m.start_at + timedelta(minutes=dur)
        elif creating:
            m.end_at = m.start_at + timedelta(minutes=st.default_meeting_minutes)
        elif "start_at" in d and m.pk:
            pass
        if m.end_at <= m.start_at:
            raise ValueError("end_at must be after start_at.")
        if m.end_at - m.start_at > timedelta(hours=24):
            raise ValueError("A meeting cannot be longer than 24 hours.")

    def resolve_participants(self, m, d):
        """[(employee, role)] from participant_codes / participants / invite_department (organizer excluded)."""
        wanted = {}
        for item in (d.get("participants") or []):
            code = item.get("employee_code") if isinstance(item, dict) else item
            role = (item.get("role") if isinstance(item, dict) else None) or "REQUIRED"
            role = str(role).upper()
            if role not in ("REQUIRED", "OPTIONAL"):
                raise ValueError("participant role must be REQUIRED or OPTIONAL.")
            wanted[str(code).strip()] = role
        for code in (d.get("participant_codes") or []):
            wanted.setdefault(str(code).strip(), "REQUIRED")
        if d.get("invite_department"):
            dep = Department.objects.filter(company=m.company, pk=to_int(d["invite_department"])).first()
            if dep is None:
                raise ValueError("invite_department is invalid.")
            for e in employees_qs(m.company).filter(is_active=True, department=dep):
                wanted.setdefault(e.employee_code, "REQUIRED")
        out = []
        for code, role in wanted.items():
            e = emp_by_code(m.company, code)
            if m.organizer_id and e.pk == m.organizer_id:
                continue
            out.append((e, role))
        return out

    @transaction.atomic
    def save_new(self, d):
        m = Meeting(company=self.company(), created_by=self.actor(), updated_by=self.actor())
        self.apply(m, d, True)
        people = self.resolve_participants(m, d)
        conflicts = self.check_conflicts(m, [e.id for e, _ in people] + ([m.organizer_id] if m.organizer_id else []), d)
        m.save()
        if m.organizer_id:
            MeetingParticipant.objects.create(company=m.company, meeting=m, employee=m.organizer, role="ORGANIZER",
                                              rsvp="ACCEPTED", responded_at=timezone.now(),
                                              created_by=self.actor(), updated_by=self.actor())
        for e, role in people:
            MeetingParticipant.objects.create(company=m.company, meeting=m, employee=e, role=role,
                                              created_by=self.actor(), updated_by=self.actor())
        return m, conflicts

    @transaction.atomic
    def save_update(self, m, d):
        before = (m.start_at, m.end_at, m.recurrence)
        self.apply(m, d, False)
        m.updated_by = self.actor()
        ids = list(m.participants.filter(is_active=True).values_list("employee_id", flat=True))
        conflicts = []
        if (m.start_at, m.end_at) != before[:2]:
            conflicts = self.check_conflicts(m, ids, d, exclude_id=m.pk)
        m.save()
        if (m.start_at, m.end_at, m.recurrence) != before and str(d.get("reset_rsvp", "true")).lower() != "false":
            m.participants.filter(is_active=True).exclude(role="ORGANIZER").update(
                rsvp="PENDING", responded_at=None)            # rescheduled -> everyone re-confirms
        if d.get("participants") or d.get("participant_codes") or d.get("invite_department"):
            self.add_participants(m, self.resolve_participants(m, d))
        return m, conflicts

    def check_conflicts(self, m, ids, d, exclude_id=None):
        ids = [i for i in set(ids) if i]
        if not ids:
            return []
        c = find_conflicts(m.company, ids, m.start_at, m.end_at, exclude_id)
        strict = str(d.get("strict", "")).lower() in ("1", "true", "yes") or get_setting(m.company).block_on_conflict
        if c and strict:
            raise ConflictError(c)
        return c

    def add_participants(self, m, people):
        added = []
        for e, role in people:
            p, created = MeetingParticipant.objects.get_or_create(
                meeting=m, employee=e, defaults={"company": m.company, "role": role, "created_by": self.actor(),
                                                 "updated_by": self.actor()})
            if not created:
                if not p.is_active:
                    p.is_active, p.rsvp, p.responded_at = True, "PENDING", None
                if p.role != "ORGANIZER":
                    p.role = role
                p.updated_by = self.actor()
                p.save()
            elif created:
                added.append(e.employee_code)
        return added

    def join_check(self, m):
        now = timezone.now()
        if m.status == "CANCELLED":
            raise ValueError("This meeting has been cancelled.")
        s, e, phase = focus_occurrence(m, now)
        if phase == "Completed":
            raise ValueError("This meeting has ended.")
        if now < s - timedelta(minutes=15):
            raise ValueError("The room opens 15 minutes before the start time.")
        if not (m.meeting_link or m.location):
            raise ValueError("This meeting has no link or location.")
        return s, e


class ConflictError(Exception):
    def __init__(self, conflicts):
        self.conflicts = conflicts
