# ============================================================
# 7. TRANSFERS   /api/people/transfers/
# ============================================================
from django.conf import settings
from django.core.mail import send_mail
from django.db import transaction
from django.db.models import Count, Q
from django.utils import timezone
from rest_framework.decorators import action

from Employee.models import Department

from .common import (CrudBase, dept_name, emp_brief, emp_by_code, ensure_extra, err, iso, log_history, ok, to_date)
from .models import Branch, TransferRequest


def _pick(model, company, ref, label):
    if ref in (None, ""):
        return None
    f = Q(pk=int(ref)) if str(ref).isdigit() else Q(name__iexact=str(ref).strip())
    obj = model.objects.filter(company=company).filter(f).first()
    if obj is None:
        raise ValueError(f"{label} '{ref}' not found.")
    return obj


class TransferViewSet(CrudBase):
    """
    GET  /api/people/transfers/                      ?status= ?hod_status= ?employee=<code> ?search=
    POST /api/people/transfers/                      "Initiate Transfer"
         {employee_code, to_department?, to_branch?, to_manager?, effective_date, reason?, hod_approver?}
    POST /api/people/transfers/<id>/update/          (only before execution)
    POST /api/people/transfers/<id>/approve/         HOD approval   {remarks?}
    POST /api/people/transfers/<id>/reject/          {remarks}
    POST /api/people/transfers/<id>/execute/         applies department/branch/manager to the employee
    POST /api/people/transfers/<id>/remind/          reminds the pending HOD (email, if SMTP is set up)
    POST /api/people/transfers/<id>/cancel/
    """
    model = TransferRequest
    code = "TRANSFER"
    select = ("employee", "employee__department", "to_department", "to_branch", "to_manager", "hod_approver")
    search_fields = ("employee__name", "employee__employee_code", "reason")

    def build(self, t):
        cur = " • ".join(x for x in (t.from_department_name, t.from_branch_name) if x) or None
        dest = " • ".join(x for x in (t.to_department.name if t.to_department else None,
                                      t.to_branch.name if t.to_branch else None) if x) or None
        return {"id": t.id, "employee": emp_brief(t.employee), "current": cur,
                "current_department": t.from_department_name, "current_hub": t.from_branch_name,
                "proposed_destination": dest, "to_department": ({"id": t.to_department_id, "name": t.to_department.name} if t.to_department else None),
                "to_branch": ({"id": t.to_branch_id, "name": t.to_branch.name} if t.to_branch else None),
                "to_manager": emp_brief(t.to_manager), "effective_date": iso(t.effective_date),
                "reason": t.reason, "hod_approval": "Approved" if t.hod_status == "Approved" else
                ("Rejected" if t.hod_status == "Rejected" else "Pending HOD"),
                "hod_status": t.hod_status, "hod_approver": emp_brief(t.hod_approver), "hod_remarks": t.hod_remarks,
                "status": t.status, "executed_at": iso(t.executed_at), "reminded_at": iso(t.reminded_at),
                "actions": {"can_execute": t.status == "Approved" or (t.status == "Requested" and t.hod_status == "Approved"),
                            "can_remind": t.status == "Requested" and t.hod_status == "Pending"}}

    def filter(self, qs, p):
        qs = super().filter(qs, p)
        return qs.filter(hod_status=p["hod_status"]) if p.get("hod_status") else qs

    def list(self, request):
        resp = super().list(request)
        c = {r["hod_status"]: r["n"] for r in self.scope().filter(is_active=True).values("hod_status").annotate(n=Count("id"))}
        resp.data["summary"] = {"pending_hod": c.get("Pending", 0), "approved": c.get("Approved", 0),
                                "rejected": c.get("Rejected", 0)}
        return resp

    def apply(self, t, d, creating):
        co = self.company()
        if t.status in ("Executed", "Cancelled", "Rejected"):
            raise ValueError(f"A {t.status.lower()} transfer cannot be edited.")
        if creating:
            e = emp_by_code(co, d.get("employee_code"))
            x = ensure_extra(e)
            t.employee, t.from_manager = e, x.reporting_manager
            t.from_department_name, t.from_branch_name = dept_name(e), (x.branch.name if x.branch else e.Work_Location)
            if TransferRequest.objects.filter(employee=e, is_active=True, status__in=["Requested", "Approved"]).exists():
                raise ValueError("This employee already has an open transfer request.")
        if "to_department" in d:
            t.to_department = _pick(Department, co, d["to_department"], "Department")
        if "to_branch" in d:
            t.to_branch = _pick(Branch, co, d["to_branch"], "Branch")
        if "to_manager" in d:
            t.to_manager = emp_by_code(co, d["to_manager"], required=False)
        if creating or "hod_approver" in d:
            hod = emp_by_code(co, d.get("hod_approver"), required=False) if d.get("hod_approver") else t.from_manager
            t.hod_approver = hod
        if not (t.to_department or t.to_branch or t.to_manager):
            raise ValueError("Provide at least one of to_department, to_branch or to_manager.")
        if "effective_date" in d or creating:
            t.effective_date = to_date(d.get("effective_date"))
            if not t.effective_date:
                raise ValueError("effective_date is required.")
        if "reason" in d:
            t.reason = d["reason"]

    def _t(self, pk):
        return self.scope().filter(pk=pk, is_active=True).first()

    @action(detail=True, methods=["post"])
    def approve(self, request, pk=None):
        t = self._t(pk)
        if t is None:
            return err("NOT_FOUND", "Transfer not found.", 404)
        if t.status != "Requested":
            return err("INVALID_STATE", f"Transfer is already {t.status.lower()}.", 409)
        t.hod_status, t.status, t.hod_remarks, t.updated_by = "Approved", "Approved", request.data.get("remarks"), self.actor()
        t.save()
        return ok("TRANSFER_APPROVED", "HOD approval recorded.", self.build(t))

    @action(detail=True, methods=["post"])
    def reject(self, request, pk=None):
        t = self._t(pk)
        if t is None:
            return err("NOT_FOUND", "Transfer not found.", 404)
        if t.status not in ("Requested", "Approved"):
            return err("INVALID_STATE", f"Transfer is already {t.status.lower()}.", 409)
        t.hod_status, t.status, t.hod_remarks, t.updated_by = "Rejected", "Rejected", request.data.get("remarks"), self.actor()
        t.save()
        return ok("TRANSFER_REJECTED", "Transfer rejected.", self.build(t))

    @action(detail=True, methods=["post"])
    def cancel(self, request, pk=None):
        t = self._t(pk)
        if t is None:
            return err("NOT_FOUND", "Transfer not found.", 404)
        if t.status == "Executed":
            return err("INVALID_STATE", "An executed transfer cannot be cancelled.", 409)
        t.status, t.updated_by = "Cancelled", self.actor()
        t.save()
        return ok("TRANSFER_CANCELLED", "Transfer cancelled.", self.build(t))

    @action(detail=True, methods=["post"])
    @transaction.atomic
    def execute(self, request, pk=None):
        t = self._t(pk)
        if t is None:
            return err("NOT_FOUND", "Transfer not found.", 404)
        if t.status == "Executed":
            return err("ALREADY_EXECUTED", "Transfer is already executed.", 409)
        if t.hod_status != "Approved" or t.status not in ("Approved", "Requested"):
            return err("NOT_APPROVED", "HOD approval is required before executing the transfer.")
        e, x = t.employee, ensure_extra(t.employee)
        if t.to_department:
            e.department, e.Department = t.to_department, t.to_department.name
        if t.to_branch:
            x.branch = t.to_branch
        if t.to_manager:
            x.reporting_manager = t.to_manager
        e.updated_by = x.updated_by = self.actor()
        e.save()
        x.save()
        t.status, t.executed_at, t.updated_by = "Executed", timezone.now(), self.actor()
        t.save()
        dest = " • ".join(v for v in (t.to_department.name if t.to_department else None,
                                      t.to_branch.name if t.to_branch else None) if v)
        log_history(t.company, e, "TRANSFER", f"Transferred to {dest or 'new reporting line'}",
                    f"From {t.from_department_name or '-'} • {t.from_branch_name or '-'}. {t.reason or ''}".strip(),
                    t.effective_date, {"transfer_id": t.id}, self.actor())
        return ok("TRANSFER_EXECUTED", "Transfer executed. Employee record updated.", self.build(t))

    @action(detail=True, methods=["post"])
    def remind(self, request, pk=None):
        t = self._t(pk)
        if t is None:
            return err("NOT_FOUND", "Transfer not found.", 404)
        if t.hod_status != "Pending":
            return err("INVALID_STATE", "No pending HOD approval to remind.", 409)
        sent = False
        if t.hod_approver and t.hod_approver.email:
            try:
                sent = bool(send_mail(
                    f"Reminder: transfer approval pending for {t.employee.name}",
                    f"Please approve/reject the transfer of {t.employee.name} ({t.employee.employee_code}) "
                    f"effective {t.effective_date}.", getattr(settings, "DEFAULT_FROM_EMAIL", None),
                    [t.hod_approver.email], fail_silently=True))
            except Exception:
                sent = False
        t.reminded_at, t.updated_by = timezone.now(), self.actor()
        t.save()
        return ok("TRANSFER_REMINDED", "Reminder recorded.", {**self.build(t), "email_sent": sent})
