# ============================================================
# Meetings & Minutes / Bug Management / Change Requests / Daily Work Reports / Analytics / Menu / Meta  (Admin / HR)
# ============================================================
from datetime import timedelta

from django.db import transaction
from django.db.models import Q, Sum
from django.utils import timezone
from django.utils.dateparse import parse_datetime
from rest_framework.decorators import action
from rest_framework.views import APIView

from Employee.models import EmployeeDT

from .common import (ChangeRequest, DailyWorkReport, HubAuthMixin, HubCrud, Meeting, MeetingParticipant, ProjectBug, ProjectMeetingMinute,
                     ProjectTask, TimesheetEntry, TimesheetProject, bug_row, choice, cr_row, dwr_row, emp_by_code, employees_qs, err, find_project,
                     find_task, hub_allows, iso, meeting_row, next_seq, ok, paginate, plan_for, to_date, to_decimal, to_int, MODULE)
from .engine import analytics

MEETING_MAP = {"Kickoff": "TEAM_SYNC", "Sprint Planning": "TEAM_SYNC", "Status Review": "REVIEW", "Client Call": "OTHER",
               "RCA": "REVIEW", "Retrospective": "REVIEW", "Other": "OTHER"}


def to_dt(v, name):
    if v in (None, ""):
        return None
    dt = parse_datetime(str(v))
    if dt is None:
        d = to_date(v)
        dt = timezone.datetime(d.year, d.month, d.day, 9, 0)
    return timezone.make_aware(dt) if timezone.is_naive(dt) else dt


# ---------------------------------------------------------------
# Meetings & Minutes
# ---------------------------------------------------------------
class MeetingViewSet(HubCrud):
    """
    CRUD   /api/project-hub/meetings/    ?project= ?meeting_type= ?date=YYYY-MM-DD ?status=Scheduled|Completed|Cancelled ?search=
    POST   /api/project-hub/meetings/    {project, title, meeting_type?, start_at, end_at?, location?, meeting_link?, agenda?,
                                          attendee_employee_codes?:[..], organizer_employee_code?, minutes?, decisions?, rca?, action_items?:[..]}
    The schedule is stored once, in Communication.Meeting (so it also shows in the Communication calendar). Only the minutes live here.
    """
    model = ProjectMeetingMinute
    code = "HUB_MEETING"
    status_field = None
    select = ("project", "meeting", "meeting__organizer")
    search_fields = ("meeting__title", "minutes", "decisions", "rca", "project__title")

    def build(self, m):
        return meeting_row(m, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        qs = qs.filter(meeting__is_active=True)
        if p.get("meeting_type"):
            qs = qs.filter(project_meeting_type=p["meeting_type"])
        if p.get("date"):
            qs = qs.filter(meeting__start_at__date=to_date(p["date"]))
        now, st = timezone.now(), p.get("status")
        if st == "Cancelled":
            qs = qs.filter(meeting__status="CANCELLED")
        elif st == "Completed":
            qs = qs.exclude(meeting__status="CANCELLED").filter(meeting__end_at__lt=now)
        elif st == "Scheduled":
            qs = qs.exclude(meeting__status="CANCELLED").filter(meeting__end_at__gte=now)
        return qs.order_by("-meeting__start_at")

    def apply(self, m, d, creating):
        co = self.company()
        if creating:
            m.project = find_project(co, d.get("project"))
            mt = Meeting(company=co, created_by=self.actor(), updated_by=self.actor(), status="SCHEDULED")
        else:
            mt = m.meeting
        if creating or "title" in d:
            t = (d.get("title") or "").strip()
            if not t:
                raise ValueError("title is required.")
            mt.title = t[:200]
        if "project_meeting_type" in d or "meeting_type" in d:
            m.project_meeting_type = choice(d.get("project_meeting_type", d.get("meeting_type")), ProjectMeetingMinute.TYPES, "meeting_type")
        if creating or "start_at" in d:
            s = to_dt(d.get("start_at"), "start_at")
            if s is None:
                raise ValueError("start_at is required (e.g. 2026-10-28T10:00:00).")
            mt.start_at = s
        if "end_at" in d and d["end_at"]:
            mt.end_at = to_dt(d["end_at"], "end_at")
        elif creating or "start_at" in d:
            mt.end_at = mt.start_at + timedelta(hours=1)
        if mt.end_at <= mt.start_at:
            raise ValueError("end_at must be after start_at.")
        for k in ("agenda", "location", "meeting_link"):
            if k in d:
                setattr(mt, k, d[k])
        if "organizer_employee_code" in d:
            mt.organizer = emp_by_code(co, d["organizer_employee_code"], required=False)
            mt.organizer_name = mt.organizer.name if mt.organizer else None
        elif creating:
            u = self.request.user
            if isinstance(u, EmployeeDT):
                mt.organizer, mt.organizer_name = u, u.name
            else:
                mt.organizer_name = "Admin"
        for k in ("minutes", "decisions", "rca"):
            if k in d:
                setattr(m, k, d[k])
        if "action_items" in d:
            if not isinstance(d["action_items"], list):
                raise ValueError("action_items must be a list.")
            m.action_items = d["action_items"]
        codes = d.get("attendee_employee_codes")
        people = None
        if codes is not None:
            if not isinstance(codes, list):
                raise ValueError("attendee_employee_codes must be a list.")
            people = [emp_by_code(co, c) for c in dict.fromkeys(codes)]
        if "status" in d and d["status"] == "Cancelled":
            mt.status, mt.cancel_reason = "CANCELLED", d.get("cancel_reason")
        mt.meeting_type = MEETING_MAP.get(m.project_meeting_type, "OTHER")
        mt.save()
        m.meeting = mt
        self._people = people
        if m.pk is None:
            m.save()           # CrudBase saves again harmlessly; needed so participants can reference the meeting
            m._state.adding = False

    def after_save(self, m, creating):
        people = getattr(self, "_people", None)
        mt, co = m.meeting, self.company()
        if people is None:
            return
        keep = {e.pk for e in people}
        if mt.organizer_id:
            keep.add(mt.organizer_id)
        MeetingParticipant.objects.filter(meeting=mt).exclude(employee_id__in=keep).delete()
        have = set(MeetingParticipant.objects.filter(meeting=mt).values_list("employee_id", flat=True))
        for pk in keep - have:
            MeetingParticipant.objects.create(company=co, meeting=mt, employee_id=pk, role="ORGANIZER" if pk == mt.organizer_id else "REQUIRED",
                                              created_by=self.actor(), updated_by=self.actor())
        self._people = None

    def create(self, request):
        self._people = None
        return super().create(request)

    def destroy(self, request, pk=None):
        m = self.scope().filter(pk=pk, is_active=True).first()
        if m is None:
            return err("NOT_FOUND", "Record not found.", 404)
        m.is_active = False
        m.updated_by = self.actor()
        m.save()
        Meeting.objects.filter(pk=m.meeting_id).update(is_active=False)
        return ok("HUB_MEETING_DELETED", "Deleted.", {"id": int(pk)})


# ---------------------------------------------------------------
# Bug Management
# ---------------------------------------------------------------
def apply_bug(co, b, d, creating, self_service_user=None):
    if creating:
        b.project = find_project(co, d.get("project"))
    if creating or "title" in d:
        t = (d.get("title") or "").strip()
        if not t:
            raise ValueError("title is required.")
        b.title = t[:250]
    for k in ("description", "steps_to_reproduce", "rca", "resolution"):
        if k in d:
            setattr(b, k, d[k])
    if "task" in d or "task_id" in d:
        ref = d.get("task", d.get("task_id"))
        b.task = find_task(co, ref, b.project) if ref not in (None, "") else None
    if "severity" in d:
        b.severity = choice(d["severity"], ProjectBug.SEVERITY, "severity")
    if "assignee_employee_code" in d:
        b.assignee = emp_by_code(co, d["assignee_employee_code"], required=False)
    if "status" in d:
        b.status = choice(d["status"], ProjectBug.STATUS, "status")
        if b.status in ("Fixed", "Closed", "Retest", "Won't Fix"):
            b.resolved_at = b.resolved_at or timezone.now()
        elif b.status in ("Open", "Reopened", "In Progress"):
            b.resolved_at = None
    if "qa_result" in d and self_service_user is None:
        b.qa_result = choice(d["qa_result"], ProjectBug.QA, "qa_result")


class BugViewSet(HubCrud):
    """
    CRUD   /api/project-hub/bugs/        ?project= ?severity= ?status= ?assignee=<emp code> ?search=
    POST   /api/project-hub/bugs/        {project, title, severity?, description?, steps_to_reproduce?, task?, assignee_employee_code?, rca?}
    POST   /api/project-hub/bugs/<id>/qa-result/   {qa_result: Passed|Failed, remarks?}   Passed -> Closed, Failed -> Reopened
    """
    model = ProjectBug
    code = "HUB_BUG"
    select = ("project", "assignee", "assignee__department", "task")
    search_fields = ("bug_code", "title", "rca", "project__title")
    permission_action_map = {"qa_result": "edit"}

    def build(self, b):
        return bug_row(b, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        if p.get("severity"):
            qs = qs.filter(severity=p["severity"])
        if p.get("assignee"):
            qs = qs.filter(assignee__employee_code=p["assignee"])
        return qs

    def apply(self, b, d, creating):
        apply_bug(self.company(), b, d, creating)
        if creating:
            b.bug_code = next_seq(ProjectBug, self.company(), "bug_code", "BUG-", 4)
            b.reported_by_code = self.actor()

    @action(detail=True, methods=["post"], url_path="qa-result")
    def qa_result(self, request, pk=None):
        b = self.scope().filter(pk=pk, is_active=True).first()
        if b is None:
            return err("NOT_FOUND", "Record not found.", 404)
        r = request.data.get("qa_result")
        if r not in ("Passed", "Failed"):
            return err("VALIDATION", "qa_result must be Passed or Failed.")
        b.qa_result = r
        b.status, b.resolved_at = ("Closed", timezone.now()) if r == "Passed" else ("Reopened", None)
        if request.data.get("remarks"):
            b.resolution = ((b.resolution or "") + f"\n[QA {r}] {request.data['remarks']}").strip()
        b.updated_by = self.actor()
        b.save()
        return ok("HUB_BUG_QA", f"QA marked {r}.", bug_row(b, request))


# ---------------------------------------------------------------
# Change Requests
# ---------------------------------------------------------------
def apply_cr(co, c, d, creating):
    if creating:
        c.project = find_project(co, d.get("project"))
    elif c.status != "Pending":
        raise ValueError(f"Only Pending change requests can be edited (this one is {c.status}).")
    if creating or "reason" in d:
        r = (d.get("reason") or "").strip()
        if not r:
            raise ValueError("reason is required.")
        c.reason = r
    if "scope_impact" in d:
        c.scope_impact = d["scope_impact"]
    for k in ("budget_impact", "hours_impact"):
        if k in d:
            setattr(c, k, to_decimal(d[k], 0))
    if "revised_target_date" in d or "revised_target" in d:
        c.revised_target_date = to_date(d.get("revised_target_date", d.get("revised_target")))
    if c.revised_target_date and c.project.start_date and c.revised_target_date < c.project.start_date:
        raise ValueError("revised_target_date cannot be before the project start date.")


@transaction.atomic
def decide_cr(c, approve, actor, remarks):
    if c.status != "Pending":
        raise ValueError(f"Already {c.status.lower()}.")
    c.status, c.decided_by, c.decided_at, c.decision_remarks = ("Approved" if approve else "Rejected"), actor, timezone.now(), remarks
    c.updated_by = actor
    c.save()
    if approve:
        p, pl = c.project, plan_for(c.project)
        if c.revised_target_date:
            pl.approved_end_date = p.end_date = c.revised_target_date
        if c.budget_impact:
            pl.budget_amount = (pl.budget_amount or 0) + c.budget_impact
        if c.hours_impact:
            p.budget_hours = (p.budget_hours or 0) + c.hours_impact
        pl.save()
        p.save()


class ChangeRequestViewSet(HubCrud):
    """
    CRUD   /api/project-hub/change-requests/    ?project= ?status= ?search=      (edit/delete only while Pending)
    POST   /api/project-hub/change-requests/    {project, reason, scope_impact?, budget_impact?, hours_impact?, revised_target_date?}
    POST   /api/project-hub/change-requests/<id>/approve/   {remarks?}   -> moves approved deadline / budget of the project
    POST   /api/project-hub/change-requests/<id>/reject/    {remarks}
    """
    model = ChangeRequest
    code = "HUB_CR"
    select = ("project",)
    search_fields = ("cr_code", "reason", "scope_impact", "project__title")
    permission_action_map = {"approve": "approve", "reject": "approve"}

    def build(self, c):
        return cr_row(c)

    def apply(self, c, d, creating):
        apply_cr(self.company(), c, d, creating)
        if creating:
            c.cr_code = next_seq(ChangeRequest, self.company(), "cr_code", "CR-", 4)
            c.requested_by_code = self.actor()

    def destroy(self, request, pk=None):
        c = self.scope().filter(pk=pk, is_active=True).first()
        if c is not None and c.status != "Pending":
            return err("CONFLICT", "Decided change requests cannot be deleted.", 409)
        return super().destroy(request, pk)

    def _decide(self, request, pk, approve):
        c = self.scope().filter(pk=pk, is_active=True).first()
        if c is None:
            return err("NOT_FOUND", "Record not found.", 404)
        rem = (request.data.get("remarks") or "").strip()
        if not approve and not rem:
            return err("VALIDATION", "remarks are required to reject.")
        try:
            decide_cr(c, approve, self.actor(), rem or None)
        except ValueError as ex:
            return err("CONFLICT", str(ex), 409)
        return ok("HUB_CR_APPROVED" if approve else "HUB_CR_REJECTED", "Approved." if approve else "Rejected.", cr_row(c))

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

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


# ---------------------------------------------------------------
# Daily Work Reports
# ---------------------------------------------------------------
def apply_dwr(co, r, d, creating, allowed_projects=None):
    if creating:
        r.project = find_project(co, d.get("project"))
        if allowed_projects is not None and r.project.id not in allowed_projects:
            raise ValueError("You are not allocated to this project.")
    elif r.status == "Approved":
        raise ValueError("Approved reports are locked.")
    if "task" in d or "task_id" in d or creating:
        ref = d.get("task", d.get("task_id"))
        r.task = find_task(co, ref, r.project) if ref not in (None, "") else None
    if creating or "report_date" in d:
        rd = to_date(d.get("report_date")) or (timezone.localdate() if creating else r.report_date)
        if rd > timezone.localdate():
            raise ValueError("report_date cannot be in the future.")
        r.report_date = rd
    if creating or "summary" in d:
        s = (d.get("summary") or "").strip()
        if not s:
            raise ValueError("summary is required.")
        r.summary = s
    if "blockers" in d:
        r.blockers = d["blockers"]
    if "progress_percent" in d:
        pr = to_int(d["progress_percent"])
        if pr is not None and not 0 <= pr <= 100:
            raise ValueError("progress_percent must be between 0 and 100.")
        r.progress_percent = pr
    if creating or "hours" in d:
        h = to_decimal(d.get("hours"))
        if h is None:       # no second entry of the same effort: take what the employee already logged in Timesheet that day
            h = TimesheetEntry.objects.filter(company=co, employee=r.employee, project=r.project, work_date=r.report_date, is_active=True) \
                    .exclude(status="Rejected").aggregate(s=Sum("hours"))["s"]
            if not h:
                raise ValueError("hours is required (no timesheet hours found for this project and date).")
        if h <= 0 or h > 24:
            raise ValueError("hours must be between 0 and 24.")
        r.hours = h
    dup = DailyWorkReport.objects.filter(company=co, employee=r.employee, project=r.project, report_date=r.report_date, task=r.task,
                                         is_active=True).exclude(pk=r.pk)
    if dup.exists():
        raise ValueError("A report for this employee, project, task and date already exists - edit it instead.")
    if not creating and r.status == "Revision":
        r.status, r.review_remarks = "Pending", r.review_remarks     # resubmission goes back to the review queue


@transaction.atomic
def review_dwr(r, approve, actor, remarks):
    if r.status == "Approved" and approve:
        raise ValueError("Already approved.")
    r.status = "Approved" if approve else "Revision"
    r.reviewed_by, r.reviewed_at, r.review_remarks, r.updated_by = actor, timezone.now(), remarks, actor
    r.save()
    t = r.task
    if approve and t and r.progress_percent is not None and r.progress_percent > t.progress and t.status not in ("Completed", "Cancelled"):
        t.progress = r.progress_percent
        if t.status == "To Do":
            t.status = "In Progress"
        t.save()


def dwr_cards(qs):
    return {"total_reports": qs.count(), "pending_review": qs.filter(status="Pending").count(), "approved_reports": qs.filter(status="Approved").count(),
            "revisions_requested": qs.filter(status="Revision").count(),
            "total_hours_logged": float(qs.filter(status="Approved").aggregate(h=Sum("hours"))["h"] or 0)}


class DailyReportViewSet(HubCrud):
    """
    CRUD   /api/project-hub/daily-reports/   ?employee=<code> ?project= ?status=Pending|Approved|Revision ?date=YYYY-MM-DD ?search=
    POST   /api/project-hub/daily-reports/   {employee_code, project, report_date?, summary, hours?, task?, blockers?, progress_percent?}
    GET    /api/project-hub/daily-reports/summary/                           the 5 cards
    POST   /api/project-hub/daily-reports/<id>/approve/    {remarks?}
    POST   /api/project-hub/daily-reports/<id>/request-revision/   {remarks}
    POST   /api/project-hub/daily-reports/approve-all-pending/     {project?, employee_code?}
    """
    model = DailyWorkReport
    code = "HUB_DWR"
    employee_field = "employee__employee_code"
    select = ("employee", "employee__department", "project", "task")
    search_fields = ("summary", "employee__name", "employee__employee_code", "project__title")
    permission_action_map = {"approve": "approve", "request_revision": "approve", "approve_all_pending": "approve", "summary": "view"}

    def build(self, r):
        return dwr_row(r, self.request)

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        return qs.filter(report_date=to_date(p["date"])) if p.get("date") else qs

    def apply(self, r, d, creating):
        if creating:
            r.employee = emp_by_code(self.company(), d.get("employee_code"))
        apply_dwr(self.company(), r, d, creating)

    @action(detail=False, methods=["get"], url_path="summary")
    def summary(self, request):
        qs = self.filter(self.scope().filter(is_active=True), request.query_params)
        return ok("HUB_DWR_SUMMARY", "Daily report summary.", dwr_cards(qs))

    def _review(self, request, pk, approve):
        r = self.scope().filter(pk=pk, is_active=True).first()
        if r is None:
            return err("NOT_FOUND", "Record not found.", 404)
        rem = (request.data.get("remarks") or "").strip()
        if not approve and not rem:
            return err("VALIDATION", "remarks are required to request a revision.")
        try:
            review_dwr(r, approve, self.actor(), rem or None)
        except ValueError as ex:
            return err("CONFLICT", str(ex), 409)
        return ok("HUB_DWR_APPROVED" if approve else "HUB_DWR_REVISION", "Approved." if approve else "Revision requested.", dwr_row(r, request))

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

    @action(detail=True, methods=["post"], url_path="request-revision")
    def request_revision(self, request, pk=None):
        return self._review(request, pk, False)

    @action(detail=False, methods=["post"], url_path="approve-all-pending")
    def approve_all_pending(self, request):
        qs = self.scope().filter(is_active=True, status="Pending")
        d = request.data
        if d.get("project"):
            try:
                qs = qs.filter(project=find_project(self.company(), d["project"]))
            except ValueError as ex:
                return err("VALIDATION", str(ex))
        if d.get("employee_code"):
            qs = qs.filter(employee__employee_code=d["employee_code"])
        n = 0
        for r in qs:
            review_dwr(r, True, self.actor(), d.get("remarks"))
            n += 1
        return ok("HUB_DWR_APPROVED_ALL", f"{n} report(s) approved.", {"approved": n})


# ---------------------------------------------------------------
# Analytics / Meta / Menu
# ---------------------------------------------------------------
class AnalyticsView(HubAuthMixin, APIView):
    """GET /api/project-hub/analytics/?project=<id|code>   (omit project = all projects)"""
    permission_action = "view"

    def get(self, request):
        p = None
        if request.query_params.get("project"):
            try:
                p = find_project(self.company(), request.query_params["project"])
            except ValueError as ex:
                return err("VALIDATION", str(ex))
        return ok("HUB_ANALYTICS", "Analytics & performance.", analytics(self.company(), p, request))


class MetaView(HubAuthMixin, APIView):
    """GET /api/project-hub/meta/   dropdown data for every form on the 7 tabs"""
    permission_action = "view"

    def get(self, request):
        co = self.company()
        return ok("HUB_META", "Project hub dropdowns.", {
            "project_statuses": [k for k, _ in TimesheetProject.STATUS], "priorities": [k for k, _ in ProjectTask.PRIORITY],
            "task_statuses": [k for k, _ in ProjectTask.STATUS], "bug_severities": [k for k, _ in ProjectBug.SEVERITY],
            "bug_statuses": [k for k, _ in ProjectBug.STATUS], "qa_results": [k for k, _ in ProjectBug.QA],
            "change_request_statuses": [k for k, _ in ChangeRequest.STATUS], "meeting_types": [k for k, _ in ProjectMeetingMinute.TYPES],
            "report_statuses": [{"value": k, "label": v} for k, v in DailyWorkReport.STATUS], "timescales": ["day", "week", "month"],
            "projects": list(TimesheetProject.objects.filter(company=co, is_active=True).values("id", "code", "title", "status")),
            "employees": list(employees_qs(co).filter(is_active=True).values("employee_code", "name", "Designation")[:500])})


def tab_permissions(user):
    return {a: hub_allows(user, a) for a in ("view", "create", "edit", "delete", "approve")}


HUB_TABS = [("projects", "Projects & Tasks", "projects"), ("timeline", "Gantt & Timeline", "gantt"), ("meetings", "Meetings & Minutes", "meetings"),
            ("bugs", "Bug Management", "bugs"), ("change-requests", "Change Requests", "change-requests"),
            ("reports", "Daily Work Reports", "daily-reports"), ("analytics", "Analytics & Performance", "analytics")]


class MenuView(HubAuthMixin, APIView):
    """GET /api/project-hub/menu/  -> what the Admin / HR sidebar must render for Project Tracking + the 7 page tabs."""
    permission_action = "view"

    def get(self, request):
        perms = tab_permissions(request.user)
        base = "/hr/projects"
        tabs = [{"key": k, "label": l, "path": f"{base}?tab={k}", "api": f"/api/project-hub/{a}/"} for k, l, a in HUB_TABS]
        return ok("HUB_MENU", "Project tracking menu.", {
            "mode_badge": "HR Operations Mode", "page_title": "Project & Milestone Tracking",
            "heading": "Enterprise Project Planning & Milestone Control",
            "subheading": "Comprehensive scheduling, dependencies, budget variances, meeting minutes, bug tracking, and daily work report reviews",
            "sidebar": [{"key": "project_tracking", "label": "Project Tracking", "icon": "kanban", "path": f"{base}?tab=projects", "badge": 3, "children": [
                {"key": "projects_milestones", "label": "Projects & Milestones", "path": f"{base}?tab=projects"},
                {"key": "daily_work_reports", "label": "Daily Work Reports", "path": f"{base}?tab=reports"},
                {"key": "progress_analytics", "label": "Progress & Analytics", "path": f"{base}?tab=analytics"}]}],
            "tabs": tabs, "permissions": perms})
