# ============================================================
# ADDITIVE: Employee self-service API - Performance Management & OKRs
# ------------------------------------------------------------
# Mounted at  /employee/performance/   (see Employee/performance_self_urls.py)
# Auth: Employee JWT. An employee only ever sees / changes their OWN
# records. A manager (someone listed as manager_code in the Reporting
# Hierarchy of the Leave module) additionally gets the team/ endpoints
# for the people who report to them.
#
#   GET  dashboard/
#   GET/POST             goals/             own goals
#   GET/PUT/PATCH/DELETE goals/<id>/
#   POST                 goals/<id>/progress/
#   GET                  appraisals/ , appraisals/<id>/
#   GET                  review-cycles/     active cycles + my eligibility
#   GET/POST             self-reviews/
#   GET/PUT/PATCH/DELETE self-reviews/<id>/   (edit / delete: Draft only)
#   POST                 self-reviews/<id>/submit/
#   GET                  feedback/          manager feedback shared with me
#   GET                  rating-history/
#
#   -- manager / team --
#   GET                  team/              my direct reports
#   GET                  team/goals/        ?employee_code=
#   GET                  team/appraisals/   ?employee_code=&cycle_id=&status=
#   POST/PATCH           team/appraisals/<id>/manager-review/
#   GET/POST             team/feedback/     feedback I wrote
#   GET/PUT/PATCH/DELETE team/feedback/<id>/
# ============================================================

from decimal import Decimal

from django.db import IntegrityError, transaction
from django.db.models import Avg, Q
from django.http import Http404
from django.utils import timezone

from rest_framework import status as http_status
from rest_framework.exceptions import NotFound, PermissionDenied
from rest_framework.views import APIView

from Company import performance_engine as eng
from Company.performance_api_views import (
    AppraisalSerializer,
    GoalSerializer,
    ManagerFeedbackSerializer,
    RatingHistorySerializer,
    ReviewCycleSerializer,
    SelfReviewSerializer,
)
from Company.performance_engine import _err, _ok, _truthy, employee_mini

from .employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from .employee_crud_permissions import actor_label
from .models import EmployeeDT
from .performance_models import (
    PerfAppraisal,
    PerfGoal,
    PerfManagerFeedback,
    PerfRatingHistory,
    PerfReviewCycle,
    PerfSelfReview,
)


# ============================================================
# BASE
# ============================================================

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 ctx(self):
        return {"company": self.company, "request": self.request}

    def limit(self, default=200, cap=1000):
        try:
            return max(1, min(int(self.request.query_params.get("limit", default)), cap))
        except (TypeError, ValueError):
            return default

    def offset(self):
        try:
            return max(0, int(self.request.query_params.get("offset", 0)))
        except (TypeError, ValueError):
            return 0

    def data_with(self, **extra):
        """request body + forced fields (employee_code is always ME)."""
        data = self.request.data.copy() if hasattr(self.request.data, "copy") else dict(self.request.data)
        for k, v in extra.items():
            data[k] = v
        return data

    def handle_exception(self, exc):
        if isinstance(exc, PermissionDenied):
            return _err("permission_denied", str(exc.detail), http_status.HTTP_403_FORBIDDEN)
        if isinstance(exc, (Http404, NotFound)):
            return _err("not_found", "Record not found.", http_status.HTTP_404_NOT_FOUND)
        return super().handle_exception(exc)

    def paged(self, qs, serializer_class, code, message):
        total = qs.count()
        limit, offset = self.limit(), self.offset()
        rows = serializer_class(qs[offset:offset + limit], many=True, context=self.ctx()).data
        return _ok(code, message, {"count": total, "limit": limit, "offset": offset,
                                   "results": rows})

    def apply_filters(self, qs, mapping):
        for param, lookup in mapping.items():
            v = self.request.query_params.get(param)
            if v not in (None, ""):
                qs = qs.filter(**{lookup: v})
        return qs


INVALID = "Please correct the highlighted fields."


# ============================================================
# GENERIC OWN-RECORD LIST / DETAIL
# ============================================================

class OwnListCreate(SelfBase):
    model = None
    serializer = None
    entity, label = "record", "Record"
    select = ()
    filters = {}
    can_create = True
    conflict_message = "A record with the same details already exists."

    def base_qs(self):
        qs = self.model.objects.filter(company=self.company, employee=self.me)
        return qs.select_related(*self.select) if self.select else qs

    def after_save(self, obj, actor, created):
        pass

    def get(self, request):
        qs = self.apply_filters(self.base_qs(), self.filters)
        if request.query_params.get("is_active") not in (None, ""):
            qs = qs.filter(is_active=_truthy(request.query_params["is_active"]))
        return self.paged(qs, self.serializer, f"my_{self.entity}_list",
                          f"{self.label} list fetched successfully.")

    def post(self, request):
        if not self.can_create:
            return _err("method_not_allowed", "Creating this record is not allowed.",
                        http_status.HTTP_405_METHOD_NOT_ALLOWED)
        ser = self.serializer(data=self.data_with(employee_code=self.me.employee_code),
                              context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        actor = actor_label(self.me)
        try:
            with transaction.atomic():
                obj = ser.save(company=self.company, created_by=actor, updated_by=actor)
                self.after_save(obj, actor, True)
        except IntegrityError:
            return _err(f"{self.entity}_exists", self.conflict_message,
                        http_status.HTTP_409_CONFLICT)
        obj = self.base_qs().get(pk=obj.pk)
        return _ok(f"my_{self.entity}_created", f"{self.label} created.",
                   self.serializer(obj, context=self.ctx()).data, http_status.HTTP_201_CREATED)


class OwnDetail(SelfBase):
    model = None
    serializer = None
    entity, label = "record", "Record"
    select = ()
    can_update = True
    can_delete = True

    def base_qs(self):
        qs = self.model.objects.filter(company=self.company, employee=self.me)
        return qs.select_related(*self.select) if self.select else qs

    def get_obj(self, pk):
        obj = self.base_qs().filter(pk=pk).first()
        if obj is None:
            raise NotFound()
        return obj

    def locked(self, obj):
        """Return an error response when the record can no longer be edited."""
        return None

    def after_save(self, obj, actor, created):
        pass

    def get(self, request, pk):
        return _ok(f"my_{self.entity}_detail", f"{self.label} fetched successfully.",
                   self.serializer(self.get_obj(pk), context=self.ctx()).data)

    def _save(self, request, pk, partial):
        if not self.can_update:
            return _err("method_not_allowed", "Updating this record is not allowed.",
                        http_status.HTTP_405_METHOD_NOT_ALLOWED)
        obj = self.get_obj(pk)
        blocked = self.locked(obj)
        if blocked is not None:
            return blocked
        ser = self.serializer(obj, data=self.data_with(employee_code=self.me.employee_code),
                              partial=partial, context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        actor = actor_label(self.me)
        try:
            with transaction.atomic():
                obj = ser.save(updated_by=actor, id_version=(obj.id_version or 1) + 1)
                self.after_save(obj, actor, False)
        except IntegrityError:
            return _err(f"{self.entity}_exists", "A record with the same details already exists.",
                        http_status.HTTP_409_CONFLICT)
        return _ok(f"my_{self.entity}_updated", f"{self.label} updated.",
                   self.serializer(self.base_qs().get(pk=obj.pk), context=self.ctx()).data)

    def put(self, request, pk):
        return self._save(request, pk, False)

    def patch(self, request, pk):
        return self._save(request, pk, True)

    def delete(self, request, pk):
        if not self.can_delete:
            return _err("method_not_allowed", "Deleting this record is not allowed.",
                        http_status.HTTP_405_METHOD_NOT_ALLOWED)
        obj = self.get_obj(pk)
        blocked = self.locked(obj)
        if blocked is not None:
            return blocked
        obj.delete()
        return _ok(f"my_{self.entity}_deleted", f"{self.label} deleted.", {"id": pk})


# ============================================================
# DASHBOARD
# ============================================================

class MyPerformanceDashboardView(SelfBase):
    """GET dashboard/ - my latest rating, goal progress, open actions, active cycles."""

    def get(self, request):
        company, me = self.company, self.me

        latest = (PerfAppraisal.objects.filter(company=company, employee=me, is_active=True,
                                               status="Completed")
                  .select_related("cycle").order_by("-completed_at", "-id").first())

        goals = PerfGoal.objects.filter(company=company, employee=me, is_active=True)
        goal_agg = goals.aggregate(avg=Avg("progress_percent"))
        open_goals = goals.exclude(status__in=("Completed", "Cancelled")).count()

        pending_self = PerfAppraisal.objects.filter(
            company=company, employee=me, is_active=True, status="Pending Self Review")

        active_cycles = PerfReviewCycle.objects.filter(
            company=company, status="Active", is_active=True)

        reports = eng.direct_report_codes(company, me.employee_code)

        return _ok("my_performance_dashboard", "Performance dashboard fetched successfully.", {
            "employee": employee_mini(me),
            "latest_rating": {
                "rating": eng.num(latest.normalized_rating) if latest else None,
                "label": eng.appraisal_label(latest) if latest else None,
                "badge": eng.rating_badge(latest) if latest else None,
                "cycle": latest.cycle.name if latest else None,
            },
            "goals": {
                "total": goals.count(),
                "open": open_goals,
                "average_progress": eng.num(goal_agg["avg"]),
            },
            "pending_self_reviews": [
                {"appraisal_id": a.pk, "cycle_id": a.cycle_id} for a in pending_self
            ],
            "active_cycles": ReviewCycleSerializer(active_cycles, many=True).data,
            "is_manager": bool(reports),
            "team_size": len(reports),
        })


# ============================================================
# GOALS
# ============================================================

class MyGoalsView(OwnListCreate):
    """GET/POST goals/   filters: cycle_id, status, goal_type, financial_year"""
    model, serializer = PerfGoal, GoalSerializer
    entity, label = "goal", "Goal"
    select = ("employee", "employee__department", "cycle")
    filters = {"cycle_id": "cycle_id", "status": "status", "goal_type": "goal_type",
               "financial_year": "financial_year"}


class MyGoalDetailView(OwnDetail):
    model, serializer = PerfGoal, GoalSerializer
    entity, label = "goal", "Goal"
    select = ("employee", "employee__department", "cycle")


class MyGoalProgressView(SelfBase):
    """POST goals/<id>/progress/  {"current_value": 85} | {"progress_percent": 85}"""

    def post(self, request, pk):
        obj = PerfGoal.objects.filter(company=self.company, employee=self.me, pk=pk).first()
        if obj is None:
            raise NotFound()
        allowed = {k: v for k, v in request.data.items()
                   if k in ("current_value", "progress_percent", "status")}
        if not allowed:
            return _err("invalid_input", "Send current_value, progress_percent or status.")
        ser = GoalSerializer(obj, data=allowed, partial=True, context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        obj = ser.save(updated_by=actor_label(self.me), id_version=(obj.id_version or 1) + 1)
        return _ok("my_goal_progress_updated", "Goal progress updated.",
                   GoalSerializer(obj, context=self.ctx()).data)


# ============================================================
# APPRAISALS / CYCLES / RATING HISTORY / FEEDBACK  (read only)
# ============================================================

class MyAppraisalsView(OwnListCreate):
    """GET appraisals/   filters: cycle_id, status, financial_year"""
    model, serializer = PerfAppraisal, AppraisalSerializer
    entity, label = "appraisal", "Appraisal"
    select = ("employee", "employee__department", "cycle")
    filters = {"cycle_id": "cycle_id", "status": "status", "financial_year": "financial_year"}
    can_create = False


class MyAppraisalDetailView(OwnDetail):
    model, serializer = PerfAppraisal, AppraisalSerializer
    entity, label = "appraisal", "Appraisal"
    select = ("employee", "employee__department", "cycle")
    can_update = False
    can_delete = False


class MyReviewCyclesView(SelfBase):
    """GET review-cycles/?status=Active   - cycles + am I eligible + my appraisal status."""

    def get(self, request):
        qs = PerfReviewCycle.objects.filter(company=self.company, is_active=True)
        status = request.query_params.get("status", "Active")
        if status:
            qs = qs.filter(status=status)

        mine = {a.cycle_id: a for a in PerfAppraisal.objects.filter(
            company=self.company, employee=self.me)}
        joined = self.me.Date_of_Joining

        rows = []
        for c in qs:
            row = ReviewCycleSerializer(c).data
            row["eligible"] = (c.eligible_joined_before is None or joined is None
                               or joined < c.eligible_joined_before)
            appraisal = mine.get(c.pk)
            row["my_appraisal_id"] = appraisal.pk if appraisal else None
            row["my_appraisal_status"] = appraisal.status if appraisal else None
            rows.append(row)
        return _ok("my_review_cycles", "Review cycles fetched successfully.",
                   {"count": len(rows), "results": rows})


class MyRatingHistoryView(OwnListCreate):
    """GET rating-history/   filters: cycle_id, financial_year"""
    model, serializer = PerfRatingHistory, RatingHistorySerializer
    entity, label = "rating_history", "Rating history"
    select = ("employee", "employee__department", "cycle")
    filters = {"cycle_id": "cycle_id", "financial_year": "financial_year"}
    can_create = False


class MyFeedbackView(SelfBase):
    """GET feedback/ - only the manager feedback HR / the manager shared with me."""

    def get(self, request):
        qs = (PerfManagerFeedback.objects
              .filter(company=self.company, employee=self.me, is_active=True,
                      visible_to_employee=True)
              .select_related("employee", "employee__department", "manager",
                              "manager__department", "cycle"))
        qs = self.apply_filters(qs, {"cycle_id": "cycle_id", "feedback_type": "feedback_type"})
        return self.paged(qs, ManagerFeedbackSerializer, "my_feedback_list",
                          "Feedback list fetched successfully.")


# ============================================================
# SELF REVIEW
# ============================================================

class _SelfReviewLock:
    def locked(self, obj):
        if obj.status == "Submitted":
            return _err("self_review_locked",
                        "A submitted self review can no longer be changed.",
                        http_status.HTTP_409_CONFLICT)
        return None

    def after_save(self, obj, actor, created):
        eng.after_self_review_save(obj, actor)


class MySelfReviewsView(_SelfReviewLock, OwnListCreate):
    """
    GET/POST self-reviews/
    {"cycle": 1, "summary": "Delivered ...", "self_score": 4.9, "status": "Draft|Submitted"}
    """
    model, serializer = PerfSelfReview, SelfReviewSerializer
    entity, label = "self_review", "Self review"
    select = ("employee", "employee__department", "cycle")
    filters = {"cycle_id": "cycle_id", "status": "status"}
    conflict_message = "You already have a self review for this review cycle."


class MySelfReviewDetailView(_SelfReviewLock, OwnDetail):
    model, serializer = PerfSelfReview, SelfReviewSerializer
    entity, label = "self_review", "Self review"
    select = ("employee", "employee__department", "cycle")


class MySelfReviewSubmitView(SelfBase):
    """POST self-reviews/<id>/submit/"""

    def post(self, request, pk):
        obj = PerfSelfReview.objects.filter(
            company=self.company, employee=self.me, pk=pk).first()
        if obj is None:
            raise NotFound()
        if obj.status == "Submitted":
            return _err("already_submitted", "This self review is already submitted.",
                        http_status.HTTP_409_CONFLICT)
        ser = SelfReviewSerializer(obj, data={"status": "Submitted"}, partial=True,
                                   context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        actor = actor_label(self.me)
        with transaction.atomic():
            obj = ser.save(updated_by=actor, id_version=(obj.id_version or 1) + 1)
            eng.after_self_review_save(obj, actor)
        return _ok("my_self_review_submitted", "Self review submitted.",
                   SelfReviewSerializer(obj, context=self.ctx()).data)


# ============================================================
# MANAGER / TEAM
# ============================================================

class TeamBase(SelfBase):
    """Managers only see people who report to them (Reporting Hierarchy)."""

    def report_codes(self):
        return eng.direct_report_codes(self.company, self.me.employee_code)


class MyTeamView(TeamBase):
    """GET team/ - my direct reports with their latest appraisal and goal progress."""

    def get(self, request):
        codes = self.report_codes()
        emps = (EmployeeDT.objects.filter(company=self.company, employee_code__in=codes)
                .select_related("department").order_by("name"))

        appraisals = {}
        for a in (PerfAppraisal.objects.filter(company=self.company, employee__in=emps,
                                               is_active=True)
                  .select_related("cycle").order_by("-id")):
            appraisals.setdefault(a.employee_id, a)

        progress = {r["employee"]: r["avg"] for r in (
            PerfGoal.objects.filter(company=self.company, employee__in=emps, is_active=True)
            .values("employee").annotate(avg=Avg("progress_percent")))}

        rows = []
        for e in emps:
            a = appraisals.get(e.pk)
            rows.append({
                "employee": employee_mini(e),
                "latest_appraisal": None if a is None else {
                    "id": a.pk, "cycle": a.cycle.name, "status": a.status,
                    "self_score": eng.num(a.self_score),
                    "manager_score": eng.num(a.manager_score),
                },
                "goal_progress_average": eng.num(progress.get(e.pk)),
            })
        return _ok("my_team", "Team fetched successfully.", {"count": len(rows), "results": rows})


class TeamGoalsView(TeamBase):
    """GET team/goals/?employee_code=&cycle_id=&status="""

    def get(self, request):
        qs = (PerfGoal.objects.filter(company=self.company, is_active=True,
                                      employee__employee_code__in=self.report_codes())
              .select_related("employee", "employee__department", "cycle"))
        qs = self.apply_filters(qs, {"employee_code": "employee__employee_code",
                                     "cycle_id": "cycle_id", "status": "status"})
        return self.paged(qs, GoalSerializer, "team_goal_list", "Team goals fetched successfully.")


class TeamAppraisalsView(TeamBase):
    """GET team/appraisals/?employee_code=&cycle_id=&status="""

    def get(self, request):
        qs = (PerfAppraisal.objects.filter(company=self.company, is_active=True,
                                           employee__employee_code__in=self.report_codes())
              .select_related("employee", "employee__department", "cycle"))
        qs = self.apply_filters(qs, {"employee_code": "employee__employee_code",
                                     "cycle_id": "cycle_id", "status": "status"})
        return self.paged(qs, AppraisalSerializer, "team_appraisal_list",
                          "Team appraisals fetched successfully.")


class TeamManagerReviewView(TeamBase):
    """
    POST|PATCH team/appraisals/<id>/manager-review/
    {"manager_score": 4.8, "manager_comments": "...", "potential": "High",
     "nine_box_position": "Star", "promotion_proposed": true, "proposed_level": "L4"}
    Moves the appraisal to 'Calibration' for HR to finalise (HR completes it).
    """

    FIELDS = ("manager_score", "manager_comments", "potential", "nine_box_position",
              "promotion_proposed", "proposed_level")

    def _run(self, request, pk):
        obj = (PerfAppraisal.objects.filter(
            company=self.company, pk=pk, employee__employee_code__in=self.report_codes())
            .select_related("employee", "employee__department", "cycle").first())
        if obj is None:
            raise NotFound()
        if obj.status == "Completed":
            return _err("appraisal_completed", "This appraisal is already completed.",
                        http_status.HTTP_409_CONFLICT)

        data = {k: v for k, v in request.data.items() if k in self.FIELDS}
        if "manager_score" not in data and obj.manager_score is None:
            return _err("invalid_input", INVALID,
                        errors={"manager_score": ["This field is required."]})
        data["reviewer_code"] = self.me.employee_code
        data["status"] = "Calibration"

        ser = AppraisalSerializer(obj, data=data, partial=True, context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        obj = ser.save(updated_by=actor_label(self.me), id_version=(obj.id_version or 1) + 1)
        return _ok("manager_review_saved", "Manager review saved.",
                   AppraisalSerializer(obj, context=self.ctx()).data)

    def post(self, request, pk):
        return self._run(request, pk)

    def patch(self, request, pk):
        return self._run(request, pk)


class TeamFeedbackListView(TeamBase):
    """
    GET  team/feedback/?employee_code=&cycle_id=&feedback_type=   feedback I wrote
    POST team/feedback/
    {"employee_code": "EMP-0248", "cycle": 1, "feedback_type": "1-on-1",
     "feedback": "...", "meeting_date": "2026-09-20", "visible_to_employee": true}
    """

    SELECT = ("employee", "employee__department", "manager", "manager__department", "cycle")

    def get(self, request):
        qs = (PerfManagerFeedback.objects
              .filter(company=self.company, manager=self.me, is_active=True)
              .select_related(*self.SELECT))
        qs = self.apply_filters(qs, {"employee_code": "employee__employee_code",
                                     "cycle_id": "cycle_id", "feedback_type": "feedback_type"})
        return self.paged(qs, ManagerFeedbackSerializer, "team_feedback_list",
                          "Feedback list fetched successfully.")

    def post(self, request):
        target = request.data.get("employee_code")
        if target not in self.report_codes():
            return _err("not_your_report", "You can only write feedback for your direct reports.",
                        http_status.HTTP_403_FORBIDDEN)
        ser = ManagerFeedbackSerializer(
            data=self.data_with(manager_code=self.me.employee_code), context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        actor = actor_label(self.me)
        obj = ser.save(company=self.company, created_by=actor, updated_by=actor)
        obj = PerfManagerFeedback.objects.select_related(*self.SELECT).get(pk=obj.pk)
        return _ok("team_feedback_created", "Feedback saved.",
                   ManagerFeedbackSerializer(obj, context=self.ctx()).data,
                   http_status.HTTP_201_CREATED)


class TeamFeedbackDetailView(TeamBase):
    SELECT = TeamFeedbackListView.SELECT

    def get_obj(self, pk):
        obj = (PerfManagerFeedback.objects
               .filter(company=self.company, manager=self.me, pk=pk)
               .select_related(*self.SELECT).first())
        if obj is None:
            raise NotFound()
        return obj

    def get(self, request, pk):
        return _ok("team_feedback_detail", "Feedback fetched successfully.",
                   ManagerFeedbackSerializer(self.get_obj(pk), context=self.ctx()).data)

    def _save(self, request, pk, partial):
        obj = self.get_obj(pk)
        data = self.data_with(manager_code=self.me.employee_code)
        if "employee_code" in data and data["employee_code"] not in self.report_codes():
            return _err("not_your_report", "You can only write feedback for your direct reports.",
                        http_status.HTTP_403_FORBIDDEN)
        ser = ManagerFeedbackSerializer(obj, data=data, partial=partial, context=self.ctx())
        if not ser.is_valid():
            return _err("invalid_input", INVALID, errors=ser.errors)
        obj = ser.save(updated_by=actor_label(self.me), id_version=(obj.id_version or 1) + 1)
        obj = PerfManagerFeedback.objects.select_related(*self.SELECT).get(pk=obj.pk)
        return _ok("team_feedback_updated", "Feedback updated.",
                   ManagerFeedbackSerializer(obj, context=self.ctx()).data)

    def put(self, request, pk):
        return self._save(request, pk, False)

    def patch(self, request, pk):
        return self._save(request, pk, True)

    def delete(self, request, pk):
        self.get_obj(pk).delete()
        return _ok("team_feedback_deleted", "Feedback deleted.", {"id": pk})
