# ============================================================
# EMPLOYEE SIDE (self-service)   /employee/project-hub/
# Auth: Employee JWT. An employee sees / changes only what is theirs:
#   * projects they are allocated to or manage   * tasks / bugs assigned to them
#   * their own change requests & daily reports  * project meetings they are invited to
# A project manager (TimesheetProject.manager) additionally reviews daily reports of his projects.
# All data comes from the same tables the Admin/HR side uses - no second copy.
# ============================================================
from django.db.models import Q
from django.utils import timezone
from rest_framework.views import APIView

from .common import (ChangeRequest, DailyWorkReport, EmployeeJWTAuthentication, IsEmployeeAuthenticated, ProjectBug, ProjectMeetingMinute,
                     ProjectTask, TimesheetProject, actor_label, actual_hours_by_task, approved_hours, bug_row, cr_row, dwr_row, err, find_project,
                     is_overdue, iso, manager_projects, meeting_row, my_project_ids, next_seq, ok, paginate, plan_for, project_hub_row, task_row,
                     task_tree, to_date, DONE)
from .engine import score_for
from .views_modules import apply_bug, apply_cr, apply_dwr, review_dwr
from .views_projects import apply_task

SELF_TASK_FIELDS = ("status", "progress", "blocked_reason", "description")
SELF_BUG_FIELDS = ("status", "resolution", "rca")


class SelfBase(APIView):
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

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

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

    def actor(self):
        return actor_label(self.me)

    def pids(self):
        return my_project_ids(self.company, self.me)

    def my_tasks(self):
        return ProjectTask.objects.filter(company=self.company, assignee=self.me, is_active=True, project__is_active=True) \
            .select_related("project", "assignee", "assignee__department").prefetch_related("predecessor_links")

    def my_bugs(self):
        return ProjectBug.objects.filter(company=self.company, is_active=True).filter(Q(assignee=self.me) | Q(reported_by_code=self.actor())) \
            .select_related("project", "assignee", "assignee__department", "task")

    def my_reports(self):
        return DailyWorkReport.objects.filter(company=self.company, employee=self.me, is_active=True).select_related("employee", "employee__department", "project", "task")

    def my_crs(self):
        return ChangeRequest.objects.filter(company=self.company, is_active=True, requested_by_code=self.actor()).select_related("project")

    def my_meetings(self):
        return ProjectMeetingMinute.objects.filter(company=self.company, is_active=True, meeting__is_active=True) \
            .filter(Q(meeting__participants__employee=self.me) | Q(meeting__organizer=self.me)).distinct() \
            .select_related("project", "meeting", "meeting__organizer").order_by("-meeting__start_at")

    def review_queue(self):
        return DailyWorkReport.objects.filter(company=self.company, is_active=True, status="Pending", project__in=manager_projects(self.company, self.me)) \
            .exclude(employee=self.me).select_related("employee", "employee__department", "project", "task")

    def pick(self, qs, pk):
        return qs.filter(pk=pk).first()


def nf():
    return err("NOT_FOUND", "Record not found.", 404)


class MyMenu(SelfBase):
    """GET /employee/project-hub/menu/   sidebar entries for the employee app"""

    def get(self, request):
        is_mgr = manager_projects(self.company, self.me).exists()
        base = "/employee/projects"
        items = [("dashboard", "Dashboard", "dashboard"), ("projects", "My Projects", "projects"), ("tasks", "My Tasks", "tasks"),
                 ("meetings", "Project Meetings", "meetings"), ("bugs", "My Bugs", "bugs"), ("change-requests", "Change Requests", "change-requests"),
                 ("reports", "Daily Work Reports", "reports"), ("analytics", "My Performance", "analytics")]
        if is_mgr:
            items.insert(7, ("review", "Report Review (Team)", "review/pending"))
        return ok("MY_HUB_MENU", "Project tracking menu.", {"sidebar": [{"key": "project_tracking", "label": "Project Tracking", "icon": "kanban", "path": f"{base}",
                  "children": [{"key": k, "label": l, "path": f"{base}?tab={k}", "api": f"/employee/project-hub/{a}/"} for k, l, a in items]}],
                  "is_project_manager": is_mgr})


class MyDashboard(SelfBase):
    """GET /employee/project-hub/dashboard/"""

    def get(self, request):
        today = timezone.localdate()
        ts = list(self.my_tasks().exclude(status="Cancelled"))
        reps = self.my_reports()
        return ok("MY_HUB_DASHBOARD", "My project dashboard.", {
            "my_projects": len(self.pids()), "tasks_open": sum(1 for t in ts if t.status not in DONE), "tasks_overdue": sum(1 for t in ts if is_overdue(t, today)),
            "tasks_blocked": sum(1 for t in ts if t.status == "Blocked"), "tasks_completed": sum(1 for t in ts if t.status == "Completed"),
            "bugs_open": self.my_bugs().exclude(status__in=("Closed", "Won't Fix")).count(),
            "reports_pending_review": reps.filter(status="Pending").count(), "reports_need_revision": reps.filter(status="Revision").count(),
            "reported_today": reps.filter(report_date=today).exists(), "approved_hours": float(approved_hours(self.company, employee=self.me)),
            "pending_in_my_review_queue": self.review_queue().count()})


class MyProjects(SelfBase):
    """GET /employee/project-hub/projects/    GET /employee/project-hub/projects/<id>/  (with WBS task tree and team)"""

    def get(self, request, pk=None):
        qs = TimesheetProject.objects.filter(company=self.company, is_active=True, pk__in=self.pids())
        if pk is None:
            if request.query_params.get("status"):
                qs = qs.filter(status=request.query_params["status"])
            rows, meta = paginate(request, qs, lambda p: {**project_hub_row(p, request), "my_open_tasks": self.my_tasks().filter(project=p).exclude(status__in=DONE).count(),
                                                          "i_am_manager": p.manager_id == self.me.id})
            return ok("MY_HUB_PROJECTS", "My projects.", rows, meta=meta)
        p = self.pick(qs, pk)
        if p is None:
            return nf()
        team = [{"employee_code": a.employee.employee_code, "name": a.employee.name, "role": a.role, "allocation_percent": a.allocation_percent}
                for a in p.allocations.filter(is_active=True).select_related("employee")]
        return ok("MY_HUB_PROJECT", "Project detail.", {**project_hub_row(p, request), "team": team, "tasks": task_tree(p, request)})


class MyTasks(SelfBase):
    """GET /employee/project-hub/tasks/  ?project= ?status= ?overdue=true"""

    def get(self, request):
        p, qs = request.query_params, self.my_tasks()
        if p.get("project"):
            qs = qs.filter(project_id=int(p["project"])) if str(p["project"]).isdigit() else qs.filter(project__code__iexact=p["project"])
        if p.get("status"):
            qs = qs.filter(status=p["status"])
        if p.get("overdue", "").lower() in ("1", "true", "yes"):
            qs = qs.filter(due_date__lt=timezone.localdate()).exclude(status__in=DONE)
        rows, meta = paginate(request, qs, lambda t: task_row(t, request))
        return ok("MY_HUB_TASKS", "My tasks.", rows, meta=meta)


class MyTaskDetail(SelfBase):
    """GET /employee/project-hub/tasks/<id>/     PATCH or POST /employee/project-hub/tasks/<id>/update/  {status?, progress?, blocked_reason?, description?}"""

    def get(self, request, pk):
        t = self.pick(self.my_tasks(), pk)
        return nf() if t is None else ok("MY_HUB_TASK", "Task.", task_row(t, request, actual_hours_by_task(self.company, t.project).get(t.id, 0)))

    def patch(self, request, pk):
        t = self.pick(self.my_tasks(), pk)
        if t is None:
            return nf()
        if t.status == "Cancelled":
            return err("CONFLICT", "Cancelled tasks cannot be changed.", 409)
        d = {k: v for k, v in request.data.items() if k in SELF_TASK_FIELDS}
        if d.get("status") == "Cancelled":
            return err("VALIDATION", "You cannot cancel a task. Ask your project manager.")
        if not d:
            return err("VALIDATION", f"Nothing to update. Allowed fields: {', '.join(SELF_TASK_FIELDS)}.")
        try:
            apply_task(self.company, t, d, False, actor_is_self=True)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        t.updated_by = self.actor()
        t.save()
        return ok("MY_HUB_TASK_UPDATED", "Updated.", task_row(t, request))

    post = patch


class MyBugs(SelfBase):
    """
    GET  /employee/project-hub/bugs/   ?status= ?severity= ?project=      bugs assigned to me or reported by me
    POST /employee/project-hub/bugs/   {project, title, severity?, description?, steps_to_reproduce?, task?}   (project must be one of mine)
    """

    def get(self, request):
        p, qs = request.query_params, self.my_bugs()
        for k in ("status", "severity"):
            if p.get(k):
                qs = qs.filter(**{k: p[k]})
        if p.get("project"):
            qs = qs.filter(project_id=int(p["project"])) if str(p["project"]).isdigit() else qs.filter(project__code__iexact=p["project"])
        rows, meta = paginate(request, qs, lambda b: bug_row(b, request))
        return ok("MY_HUB_BUGS", "My bugs.", rows, meta=meta)

    def post(self, request):
        b = ProjectBug(company=self.company, created_by=self.actor(), updated_by=self.actor(), reported_by_code=self.actor())
        d = {k: v for k, v in request.data.items() if k in ("project", "title", "severity", "description", "steps_to_reproduce", "task")}
        try:
            apply_bug(self.company, b, d, True, self_service_user=self.me)
            if b.project_id not in self.pids():
                raise ValueError("You are not allocated to this project.")
            b.bug_code = next_seq(ProjectBug, self.company, "bug_code", "BUG-", 4)
            b.save()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok("MY_HUB_BUG_CREATED", "Bug reported.", bug_row(b, request), 201)


class MyBugDetail(SelfBase):
    """GET /employee/project-hub/bugs/<id>/     PATCH or POST .../<id>/update/  {status?, resolution?, rca?}   (assignee only; QA result is set by QA/HR)"""

    def get(self, request, pk):
        b = self.pick(self.my_bugs(), pk)
        return nf() if b is None else ok("MY_HUB_BUG", "Bug.", bug_row(b, request))

    def patch(self, request, pk):
        b = self.pick(self.my_bugs(), pk)
        if b is None:
            return nf()
        if b.assignee_id != self.me.id:
            return err("FORBIDDEN", "Only the assignee can update this bug.", 403)
        if b.status == "Closed":
            return err("CONFLICT", "Closed bugs are locked.", 409)
        d = {k: v for k, v in request.data.items() if k in SELF_BUG_FIELDS}
        if d.get("status") in ("Closed", "Reopened"):
            return err("VALIDATION", "Closing / reopening is done by QA. Set status to Fixed or Retest instead.")
        try:
            apply_bug(self.company, b, d, False, self_service_user=self.me)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        b.updated_by = self.actor()
        b.save()
        return ok("MY_HUB_BUG_UPDATED", "Updated.", bug_row(b, request))

    post = patch


class MyChangeRequests(SelfBase):
    """
    GET  /employee/project-hub/change-requests/     ?status=
    POST /employee/project-hub/change-requests/     {project, reason, scope_impact?, budget_impact?, hours_impact?, revised_target_date?}  -> always Pending
    """

    def get(self, request):
        qs = self.my_crs()
        if request.query_params.get("status"):
            qs = qs.filter(status=request.query_params["status"])
        rows, meta = paginate(request, qs, cr_row)
        return ok("MY_HUB_CRS", "My change requests.", rows, meta=meta)

    def post(self, request):
        c = ChangeRequest(company=self.company, created_by=self.actor(), updated_by=self.actor(), requested_by_code=self.actor())
        d = {k: v for k, v in request.data.items() if k in ("project", "reason", "scope_impact", "budget_impact", "hours_impact", "revised_target_date")}
        try:
            apply_cr(self.company, c, d, True)
            if c.project_id not in self.pids():
                raise ValueError("You are not allocated to this project.")
            c.cr_code = next_seq(ChangeRequest, self.company, "cr_code", "CR-", 4)
            c.save()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok("MY_HUB_CR_CREATED", "Change request raised.", cr_row(c), 201)


class MyChangeRequestDetail(SelfBase):
    """GET /employee/project-hub/change-requests/<id>/    POST .../<id>/delete/  (withdraw; Pending only)"""

    def get(self, request, pk):
        c = self.pick(self.my_crs(), pk)
        return nf() if c is None else ok("MY_HUB_CR", "Change request.", cr_row(c))

    def post(self, request, pk):
        c = self.pick(self.my_crs(), pk)
        if c is None:
            return nf()
        if c.status != "Pending":
            return err("CONFLICT", "Only Pending change requests can be withdrawn.", 409)
        c.is_active, c.updated_by = False, self.actor()
        c.save()
        return ok("MY_HUB_CR_WITHDRAWN", "Withdrawn.", {"id": c.id})


class MyMeetings(SelfBase):
    """GET /employee/project-hub/meetings/  ?project= ?status=Scheduled|Completed|Cancelled ?date=    GET .../meetings/<id>/"""

    def get(self, request, pk=None):
        qs = self.my_meetings()
        if pk:
            m = self.pick(qs, pk)
            return nf() if m is None else ok("MY_HUB_MEETING", "Meeting.", meeting_row(m, request))
        p, now = request.query_params, timezone.now()
        if p.get("project"):
            qs = qs.filter(project_id=int(p["project"])) if str(p["project"]).isdigit() else qs.filter(project__code__iexact=p["project"])
        if p.get("date"):
            qs = qs.filter(meeting__start_at__date=to_date(p["date"]))
        if p.get("status") == "Cancelled":
            qs = qs.filter(meeting__status="CANCELLED")
        elif p.get("status") == "Completed":
            qs = qs.exclude(meeting__status="CANCELLED").filter(meeting__end_at__lt=now)
        elif p.get("status") == "Scheduled":
            qs = qs.exclude(meeting__status="CANCELLED").filter(meeting__end_at__gte=now)
        rows, meta = paginate(request, qs, lambda m: meeting_row(m, request))
        return ok("MY_HUB_MEETINGS", "My project meetings.", rows, meta=meta)


class MyReports(SelfBase):
    """
    GET  /employee/project-hub/reports/    ?status= ?project= ?date_from= ?date_to=
    POST /employee/project-hub/reports/    {project, summary, report_date?, hours?, task?, blockers?, progress_percent?}   hours omitted = taken from my Timesheet
    """

    def get(self, request):
        p, qs = request.query_params, self.my_reports()
        if p.get("status"):
            qs = qs.filter(status=p["status"])
        if p.get("project"):
            qs = qs.filter(project_id=int(p["project"])) if str(p["project"]).isdigit() else qs.filter(project__code__iexact=p["project"])
        if p.get("date_from"):
            qs = qs.filter(report_date__gte=to_date(p["date_from"]))
        if p.get("date_to"):
            qs = qs.filter(report_date__lte=to_date(p["date_to"]))
        rows, meta = paginate(request, qs, lambda r: dwr_row(r, request))
        return ok("MY_HUB_REPORTS", "My daily work reports.", rows, meta=meta)

    def post(self, request):
        r = DailyWorkReport(company=self.company, employee=self.me, created_by=self.actor(), updated_by=self.actor())
        d = {k: v for k, v in request.data.items() if k in ("project", "summary", "report_date", "hours", "task", "blockers", "progress_percent")}
        try:
            apply_dwr(self.company, r, d, True, allowed_projects=self.pids())
            if r.task_id and r.task.assignee_id not in (None, self.me.id):
                raise ValueError("That task is assigned to someone else.")
            r.save()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok("MY_HUB_REPORT_SUBMITTED", "Report submitted for review.", dwr_row(r, request), 201)


class MyReportDetail(SelfBase):
    """GET /employee/project-hub/reports/<id>/   PATCH or POST .../<id>/update/   (Pending / Revision only)"""

    def get(self, request, pk):
        r = self.pick(self.my_reports(), pk)
        return nf() if r is None else ok("MY_HUB_REPORT", "Report.", dwr_row(r, request))

    def patch(self, request, pk):
        r = self.pick(self.my_reports(), pk)
        if r is None:
            return nf()
        d = {k: v for k, v in request.data.items() if k in ("summary", "report_date", "hours", "task", "blockers", "progress_percent")}
        try:
            apply_dwr(self.company, r, d, False)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        r.updated_by = self.actor()
        r.save()
        return ok("MY_HUB_REPORT_UPDATED", "Updated.", dwr_row(r, request))

    post = patch


class MyReportDelete(SelfBase):
    """POST /employee/project-hub/reports/<id>/delete/   (Pending / Revision only)"""

    def post(self, request, pk):
        r = self.pick(self.my_reports(), pk)
        if r is None:
            return nf()
        if r.status == "Approved":
            return err("CONFLICT", "Approved reports cannot be deleted.", 409)
        r.is_active, r.updated_by = False, self.actor()
        r.save()
        return ok("MY_HUB_REPORT_DELETED", "Deleted.", {"id": r.id})


# ---------------------- project manager review queue ----------------------
class ReviewPending(SelfBase):
    """GET /employee/project-hub/review/pending/   daily reports waiting on projects I manage"""

    def get(self, request):
        rows, meta = paginate(request, self.review_queue(), lambda r: dwr_row(r, request))
        return ok("MY_HUB_REVIEW_QUEUE", "Reports waiting for my review.", rows, meta=meta)


class ReviewAct(SelfBase):
    approve = True

    def post(self, request, pk):
        r = self.pick(self.review_queue().model.objects.filter(company=self.company, is_active=True, project__in=manager_projects(self.company, self.me))
                      .exclude(employee=self.me).select_related("employee", "employee__department", "project", "task"), pk)
        if r is None:
            return nf()
        rem = (request.data.get("remarks") or "").strip()
        if not self.approve and not rem:
            return err("VALIDATION", "remarks are required to request a revision.")
        try:
            review_dwr(r, self.approve, self.actor(), rem or None)
        except ValueError as ex:
            return err("CONFLICT", str(ex), 409)
        return ok("MY_HUB_REVIEWED", "Approved." if self.approve else "Revision requested.", dwr_row(r, request))


class ReviewApprove(ReviewAct):
    """POST /employee/project-hub/review/<id>/approve/   {remarks?}"""
    approve = True


class ReviewRevision(ReviewAct):
    """POST /employee/project-hub/review/<id>/request-revision/   {remarks}"""
    approve = False


class MyAnalytics(SelfBase):
    """GET /employee/project-hub/analytics/   my score (same formula the HR sees)"""

    def get(self, request):
        ts = list(self.my_tasks().filter(is_milestone=False).exclude(status="Cancelled"))
        s = score_for(self.company, ts, self.me)
        return ok("MY_HUB_ANALYTICS", "My performance.", {**s, "approved_hours": float(approved_hours(self.company, employee=self.me)),
                  "tasks_overdue": sum(1 for t in ts if is_overdue(t)), "tasks_blocked": sum(1 for t in ts if t.status == "Blocked"),
                  "formula": "Composite Score = (50% x Task On-Time Completion Rate) + (30% x Approved Daily Report Consistency) + (20% x Verified Deliverables Rate)"})
