# ============================================================
# ADDITIVE: Exit Management - Employee self-service API
# ------------------------------------------------------------
# Mounted at /employee/exit/   (see People/exit_self_urls.py)
# Auth: Employee JWT. An employee only ever sees / changes their OWN exit.
# A department approver (item.approver_code set by HR, e.g. IT head,
# reporting manager) can approve / reject only the clearance items
# assigned to them.
#
#   GET    status/                              my exit overview (resignation, clearances, F&F, interview)
#   POST   resign/                              submit my resignation (HR must accept)
#   PATCH  resign/                              edit while still 'Submitted'
#   POST   withdraw/                            withdraw while still 'Submitted'
#   GET    clearances/                          my departmental clearances (read only)
#   GET    clearances/tasks/                    clearance items assigned to ME as approver
#   POST   clearances/<exit_id>/approve/        {department, remarks?}   (only my assigned item)
#   POST   clearances/<exit_id>/reject/         {department, remarks}
#   GET    fnf/                                 my F&F statement (amounts once HR approved it)
#   GET    interview/                           my exit interview
#   POST   interview/                           submit my exit interview form
#   GET    team/                                (managers) exits of my direct reports
# Letters (relieving / experience) are already served by  GET /employee/vault/letters/
# ============================================================

from datetime import timedelta

from django.db import transaction
from django.utils import timezone
from rest_framework.views import APIView

from Employee.leave_models import ReportingHierarchy
from Employee.models import EmployeeDT

from . import exit_engine as en
from .common import emp_brief, err, iso, ok, to_bool, to_date, to_int
from .exit_models import ExitInterview, ExitResignationDetail
from .models import EmployeeLetter, ExitClearance
from .views_employee_vault import EmployeeBase
from .views_exit import apply_interview, case_qs


class Base(EmployeeBase, APIView):

    def my_case(self, include_rejected=False):
        qs = case_qs(self.company()).filter(employee=self.me)
        if not include_rejected:
            qs = qs.exclude(status="Withdrawn")
        return qs.order_by("-id").first()

    def active_case(self):
        return case_qs(self.company()).filter(employee=self.me, status__in=en.ACTIVE).order_by("-id").first()


def slim(r):
    """Resignation row without HR-only fields."""
    return {k: v for k, v in r.items() if k not in ("hr_remarks", "actions", "employee", "created_at", "handover_notes")}


class MyExitStatusView(Base):
    def get(self, request):
        x = self.my_case(include_rejected=True)
        if x is None:
            return ok("MY_EXIT_STATUS", "No exit process.", {"has_exit": False, "can_resign": True})
        r = en.resignation_row(x, request)
        f, iv = en.fnf_of(x), en.interview_of(x)
        released = f is not None and f.status in ("Approved", "Paid")
        return ok("MY_EXIT_STATUS", "Exit status.", {
            "has_exit": True, "can_resign": x.status == "Withdrawn",
            "resignation": slim(r),
            "clearances": en.clearance_detail(x, request) if r["approval_status"] == "Accepted" else None,
            "fnf": {"status": f.status if f else None, "status_label": en.FNF_LABEL[f.status if f else None],
                    "net_payable": float(f.net_payable) if released else None},
            "exit_interview": {"status": iv.status if iv else None, "scheduled_for": iso(iv.scheduled_for) if iv else None},
            "letters_endpoint": "/employee/vault/letters/",
            "letters_issued": EmployeeLetter.objects.filter(
                company=self.company(), employee=self.me, is_active=True, status="Issued",
                letter_type__in=en.EXIT_LETTER_TYPES).count()})


class MyResignView(Base):
    @transaction.atomic
    def post(self, request):
        me, d, actor = self.me, request.data, self.actor()
        if ExitClearance.objects.filter(employee=me, is_active=True, status__in=en.ACTIVE).exists():
            return err("EXISTS", "You already have a resignation in progress.", 409)
        reason = str(d.get("reason") or "").strip()
        if not reason:
            return err("VALIDATION", "reason is required.", errors={"reason": ["This field is required."]})
        try:
            res = to_date(d.get("resignation_date")) or timezone.localdate()
            notice = en.parse_notice_days(me)
            lwd = to_date(d.get("last_working_day")) or res + timedelta(days=notice)
            if lwd < res:
                raise ValueError("last_working_day cannot be before resignation_date.")
            handover = None
            if d.get("handover_to_code"):
                handover = EmployeeDT.objects.filter(company=me.company, employee_code=d["handover_to_code"]).first()
                if handover is None or handover.pk == me.pk:
                    raise ValueError("Invalid handover_to_code.")
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        x = ExitClearance.objects.create(
            company=me.company, employee=me, resignation_date=res, last_working_day=lwd, reason=reason,
            items=en.default_items(me), status="Initiated", created_by=actor, updated_by=actor)
        ExitResignationDetail.objects.create(
            company=me.company, exit=x, separation_type="Resignation", notice_period_days=notice,
            approval_status="Submitted", requested_by="Employee", handover_to=handover,
            handover_notes=d.get("handover_notes"), created_by=actor, updated_by=actor)
        return ok("MY_RESIGNATION_SUBMITTED", "Resignation submitted. HR will review it.",
                  slim(en.resignation_row(case_qs(me.company).get(pk=x.pk), request)), 201)

    @transaction.atomic
    def patch(self, request):
        x, d = self.active_case(), request.data
        if x is None:
            return err("NOT_FOUND", "No resignation in progress.", 404)
        det = en.get_detail(x)
        if det.approval_status != "Submitted":
            return err("CONFLICT", "Only a resignation that is still waiting for HR can be edited.", 409)
        try:
            if "reason" in d:
                if not str(d["reason"] or "").strip():
                    raise ValueError("reason cannot be empty.")
                x.reason = d["reason"]
            if "resignation_date" in d:
                x.resignation_date = to_date(d["resignation_date"]) or x.resignation_date
            if "last_working_day" in d:
                x.last_working_day = to_date(d["last_working_day"])
            if x.last_working_day and x.last_working_day < x.resignation_date:
                raise ValueError("last_working_day cannot be before resignation_date.")
            if "handover_to_code" in d:
                h = EmployeeDT.objects.filter(company=self.company(), employee_code=d["handover_to_code"]).first() \
                    if d["handover_to_code"] else None
                if d["handover_to_code"] and (h is None or h.pk == self.me.pk):
                    raise ValueError("Invalid handover_to_code.")
                det.handover_to = h
            if "handover_notes" in d:
                det.handover_notes = d["handover_notes"]
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        x.updated_by = det.updated_by = self.actor()
        x.save()
        det.save()
        return ok("MY_RESIGNATION_UPDATED", "Resignation updated.", slim(en.resignation_row(case_qs(self.company()).get(pk=x.pk), request)))

    def get(self, request):
        x = self.my_case(include_rejected=True)
        return ok("MY_RESIGNATION", "My resignation.", slim(en.resignation_row(x, request)) if x else None)


class MyWithdrawView(Base):
    @transaction.atomic
    def post(self, request):
        x = self.active_case()
        if x is None:
            return err("NOT_FOUND", "No resignation in progress.", 404)
        det = en.get_detail(x)
        if det.approval_status != "Submitted":
            return err("CONFLICT", "HR has already accepted your resignation. Please contact HR to withdraw it.", 409)
        x.status, x.updated_by = "Withdrawn", self.actor()
        x.save()
        if request.data.get("reason"):
            det.hr_remarks = f"Withdrawn by employee: {request.data['reason']}"
            det.save()
        return ok("MY_RESIGNATION_WITHDRAWN", "Resignation withdrawn.", slim(en.resignation_row(case_qs(self.company()).get(pk=x.pk), request)))


class MyClearancesView(Base):
    def get(self, request):
        x = self.active_case() or self.my_case()
        if x is None or en.detail_or_virtual(x).approval_status != "Accepted":
            return ok("MY_CLEARANCES", "No clearances yet.", None)
        return ok("MY_CLEARANCES", "My clearances.", en.clearance_detail(x, request))


class MyClearanceTasksView(Base):
    """Items assigned to me as approver (IT head, reporting manager, ...)."""

    def get(self, request):
        me, rows = self.me, []
        for x in case_qs(self.company()).filter(status__in=en.ACTIVE).exclude(employee=me):
            if en.detail_or_virtual(x).approval_status != "Accepted":
                continue
            for i in en.items_of(x):
                if i.get("approver_code") == me.employee_code:
                    rows.append({"exit_id": x.id, "employee": emp_brief(x.employee, request),
                                 "last_working_day": iso(x.last_working_day), "department": i["department"],
                                 "title": i["title"], "status": i["status"], "remarks": i["remarks"],
                                 "pending_assets": en.pending_assets(x.employee) if i["department"] in ("IT", "Admin") else []})
        pending = request.query_params.get("pending")
        if pending and to_bool(pending):
            rows = [r for r in rows if r["status"] == "Pending"]
        return ok("MY_CLEARANCE_TASKS", "Clearance tasks assigned to me.", rows)


class MyClearanceActView(Base):
    status = None

    def post(self, request, exit_id):
        x = case_qs(self.company()).filter(pk=exit_id).exclude(status="Withdrawn").first()
        if x is None or x.employee_id == self.me.pk:
            return err("NOT_FOUND", "Exit case not found.", 404)
        d = request.data
        item = next((i for i in en.items_of(x) if i["department"] == d.get("department")), None)
        if item is not None and item.get("approver_code") != self.me.employee_code:
            return err("FORBIDDEN", "This clearance is not assigned to you.", 403)
        if item is None and d.get("department"):
            return err("FORBIDDEN", "This clearance is not assigned to you.", 403)
        try:
            en.set_item_status(x, d.get("department"), self.status, d.get("remarks"), self.actor(), force=False)
        except en.ExitConflict as ex:
            return err("CONFLICT", str(ex), 409)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        return ok(f"MY_CLEARANCE_{self.status.upper()}", f"{d.get('department')} clearance {self.status.lower()}.",
                  en.clearance_detail(case_qs(self.company()).get(pk=x.pk), request))


class MyClearanceApproveView(MyClearanceActView):
    status = "Approved"


class MyClearanceRejectView(MyClearanceActView):
    status = "Rejected"


class MyFnFView(Base):
    def get(self, request):
        x = self.my_case()
        f = en.fnf_of(x) if x else None
        if f is None or f.status not in ("Approved", "Paid"):
            return ok("MY_FNF", "Your F&F statement is not released yet.",
                      {"released": False, "status": f.status if f else None,
                       "status_label": en.FNF_LABEL[f.status if f else None]})
        row = en.fnf_row(f, with_components=False)
        return ok("MY_FNF", "My F&F statement.", {"released": True, **row,
                  "last_working_day": iso(x.last_working_day), "resignation_date": iso(x.resignation_date)})


class MyInterviewView(Base):
    def get(self, request):
        x = self.my_case()
        iv = en.interview_of(x) if x else None
        return ok("MY_EXIT_INTERVIEW", "My exit interview.", en.interview_row(iv, request) if iv else None)

    @transaction.atomic
    def post(self, request):
        x = self.active_case()
        if x is None or en.detail_or_virtual(x).approval_status != "Accepted":
            return err("CONFLICT", "The exit interview opens after HR accepts your resignation.", 409)
        iv = en.interview_of(x)
        if iv is not None and iv.status == "Completed":
            return err("EXISTS", "You have already submitted your exit interview.", 409)
        actor = self.actor()
        if iv is None:
            iv = ExitInterview(company=x.company, exit=x, created_by=actor)
        d = {k: v for k, v in request.data.items() if k in (
            "overall_rating", "reason_for_leaving", "feedback", "liked_most", "improvement_suggestions",
            "would_recommend", "would_rejoin")}
        d.update(status="Completed", mode="Form", conducted_by=f"{self.me.name} (self)")
        try:
            apply_interview(iv, d, actor, True)
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        iv.submitted_by, iv.updated_by = "Employee", actor
        iv.save()
        return ok("MY_EXIT_INTERVIEW_SUBMITTED", "Exit interview submitted. Thank you!",
                  en.interview_row(iv, request), 201)


class MyTeamExitsView(Base):
    """Managers: exits of the people who report to me (read only)."""

    def get(self, request):
        codes = list(ReportingHierarchy.objects.filter(
            company=self.company(), manager_code=self.me.employee_code, is_active=True
        ).values_list("Employee_ID", flat=True))
        qs = case_qs(self.company()).filter(employee__employee_code__in=codes).exclude(status="Withdrawn")
        rows = []
        for x in qs.order_by("-id"):
            r = en.resignation_row(x, request)
            rows.append({k: r[k] for k in ("id", "employee", "status", "approval_status", "resignation_date",
                                           "last_working_day", "days_left", "notice_period", "clearance_status")})
        return ok("MY_TEAM_EXITS", "Team exits.", {"count": len(rows), "results": rows})
