# ============================================================
# EmployeeRelations - shared helpers (reuses People.common: envelope, paging, parsing, CrudBase)
# ============================================================
import hashlib
import json
import secrets
from datetime import date

from django.db import IntegrityError, transaction
from django.db.models import Q
from django.utils import timezone
from rest_framework.permissions import BasePermission

from Company.models import company_details, get_client_ip
from Employee.employee_crud_permissions import (_role_is_usable, actor_label, resolve_actor_role, resolve_company_for_user, role_allows)  # noqa: F401
from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated  # noqa: F401
from Employee.models import EmployeeDT
from People.common import (CrudBase, PeopleAuthMixin, emp_brief, emp_by_code, employees_qs, err, iso, ok, paginate,  # noqa: F401
                           to_bool, to_date, to_decimal, to_int)

from .models import (CASE_STATUS, CATEGORIES, SEVERITIES, CaseDocument, CaseNote, DisciplinaryAction, DocumentAccessLog, ERCase, LegalCase,
                     RelationsSetting, WarningLetter)

OPEN_CASE = ("Open", "In Investigation", "Pending Review", "Escalated")
TRANSITIONS = {
    "Open": {"In Investigation", "Pending Review", "Escalated", "Resolved", "Withdrawn"},
    "In Investigation": {"Open", "Pending Review", "Escalated", "Resolved", "Withdrawn"},
    "Pending Review": {"In Investigation", "Escalated", "Resolved", "Withdrawn"},
    "Escalated": {"In Investigation", "Pending Review", "Resolved"},
    "Resolved": {"Closed", "In Investigation"},
    "Closed": {"In Investigation"},
    "Withdrawn": set(),
}
RESOLUTION_TYPES = ["Substantiated", "Partially Substantiated", "Unsubstantiated", "Settled", "No Action Required"]


# ---------------------------------------------------------------
# permissions
#   Company Admin token -> everything
#   Employee token      -> role needs can_<action>_relations (view / create / edit / delete / manage), OR the older
#                          employees rule: EDIT employees (plain employees are view-only by default and are excluded);
#                          create / delete need can_create_ / can_delete_employees; manage implies all.
#   Confidential vault  -> Company Admin, HR Head, Legal Counsel and named vault members only (RelationsSetting).
# ---------------------------------------------------------------
def relations_allows(user, action):
    actor = resolve_actor_role(user)
    if actor == "admin":
        return True
    if actor is None:
        return False
    role = _role_is_usable(user)
    if role is None:
        return False
    own = "edit" if action == "approve" else action
    if role_allows(role, "relations", own):
        return True
    a = {"view": "edit", "approve": "edit"}.get(action, action)
    return role_allows(role, "employees", a)


def vault_allows(user):
    actor = resolve_actor_role(user)
    if actor == "admin":
        return True
    if actor is None or not isinstance(user, EmployeeDT):
        return False
    s = RelationsSetting.objects.filter(company=user.company).first()
    if s is None:
        return False
    if user.pk in (s.hr_head_id, s.legal_counsel_id):
        return True
    return s.vault_members.filter(pk=user.pk).exists()


class IsRelationsUser(BasePermission):
    message = "You do not have permission to manage Employee Relations."
    METHOD_ACTION = {"GET": "view", "HEAD": "view", "OPTIONS": "view", "POST": "create", "PUT": "edit", "PATCH": "edit", "DELETE": "delete"}

    def has_permission(self, request, view):
        act = getattr(view, "permission_action", None)
        if act is None:
            va = getattr(view, "action", None)
            act = {"update_post": "edit", "delete_post": "delete"}.get(va) or (getattr(view, "permission_action_map", None) or {}).get(va)
        act = act or self.METHOD_ACTION.get(request.method)
        return bool(act) and relations_allows(request.user, act)


class IsVaultUser(BasePermission):
    message = "The case-documents vault is restricted to the HR Head, Legal Counsel and named vault members."

    def has_permission(self, request, view):
        return vault_allows(request.user)


class RelAuthMixin(PeopleAuthMixin):
    permission_classes = [IsRelationsUser]


# ---------------------------------------------------------------
# small helpers
# ---------------------------------------------------------------
def get_setting(company):
    s, _ = RelationsSetting.objects.get_or_create(company=company)
    return s


def norm(s):
    return " ".join((s or "").split()).casefold()


def who(user):
    if isinstance(user, company_details):
        return getattr(user, "Registered_Company_Name", None) or "Company Admin"
    return getattr(user, "name", None) or str(user)


def short(v, n=400):
    if v is None:
        return None
    s = v if isinstance(v, str) else json.dumps(v, default=str, ensure_ascii=False)
    return s if len(s) <= n else s[: n - 1] + "…"


def central_audit(request, company, action, module, ref=None, old=None, new=None):
    """Write to AdminCenter's audit trail when that app is installed; never fail the request."""
    try:
        from AdminCenter.models import AdminAuditEvent
        AdminAuditEvent.objects.create(company=company, actor=actor_label(request.user), actor_name=who(request.user), action=action, module=module,
                                       record_ref=short(ref, 150), old_value=short(old), new_value=short(new), ip_address=get_client_ip(request))
    except Exception:
        pass


def next_no(model, company, field, prefix, width=2):
    """PREFIX-<n> per company; n continues from the highest existing number with that prefix (deleted rows included)."""
    best = 0
    for v in model.objects.filter(company=company, **{f"{field}__startswith": prefix}).values_list(field, flat=True):
        try:
            best = max(best, int(v[len(prefix):]))
        except ValueError:
            continue
    return f"{prefix}{str(best + 1).zfill(width)}"


def save_numbered(obj, field, prefix, width=2):
    """Assign the next number and save; retry if two requests collide on the unique (company, number)."""
    for _ in range(5):
        setattr(obj, field, next_no(type(obj), obj.company, field, prefix, width))
        try:
            with transaction.atomic():
                obj.save()
            return
        except IntegrityError:
            obj.pk = None
    raise ValueError("Could not allocate a unique number, please retry.")


def new_token():
    t = "ANON-" + secrets.token_urlsafe(9).upper().replace("_", "X").replace("-", "Y")
    return t, hashlib.sha256(t.encode()).hexdigest()


def add_note(case, user, text, note_type="Note", internal=True):
    return CaseNote.objects.create(company=case.company, case=case, note_type=note_type, text=text, is_internal=internal,
                                   author=actor_label(user) if user is not None else None, author_name=who(user) if user is not None else "System",
                                   created_by=actor_label(user) if user is not None else None)


def check_conflict(case, emp):
    """An investigator can be neither the subject of the case nor the person who raised it."""
    if case.employee_id and emp.pk == case.employee_id:
        raise ValueError("The investigator cannot be the employee the case is about.")
    if case.raised_by_id and emp.pk == case.raised_by_id:
        raise ValueError("The investigator cannot be the person who raised the case.")


# ---------------------------------------------------------------
# row builders
# ---------------------------------------------------------------
def case_row(c, request=None, full=True, counts=False):
    r = {"id": c.id, "case_id": c.case_no, "category": c.category, "sub_category": c.sub_category, "subject": c.subject, "severity": c.severity,
         "status": c.status, "employee": emp_brief(c.employee, request),
         "assigned_investigator": c.investigator.name if c.investigator_id else None,
         "action": "Resolve Case" if c.status in OPEN_CASE else "Closed", "opened_at": iso(c.opened_at)}
    if full:
        r.update(description=c.description, incident_date=iso(c.incident_date), target_date=iso(c.target_date), source=c.source,
                 is_confidential=c.is_confidential, is_anonymous=c.raised_by_id is None and c.source == "Anonymous",
                 raised_by=emp_brief(c.raised_by, request) if c.raised_by_id else None, investigator=emp_brief(c.investigator, request) if c.investigator_id else None,
                 resolution_type=c.resolution_type, resolution_summary=c.resolution_summary, resolved_at=iso(c.resolved_at), resolved_by=c.resolved_by,
                 closed_at=iso(c.closed_at), overdue=bool(c.target_date and c.target_date < timezone.localdate() and c.status in OPEN_CASE))
    if counts:
        r["counts"] = {"notes": c.notes.filter(is_active=True).count(), "documents": c.documents.filter(is_active=True).count(),
                       "warnings": c.warnings.filter(is_active=True).count(), "disciplinary": c.disciplinary_actions.filter(is_active=True).count(),
                       "legal": c.legal_cases.filter(is_active=True).count()}
    return r


def note_row(n):
    return {"id": n.id, "type": n.note_type, "text": n.text, "is_internal": n.is_internal, "author": n.author_name, "created_at": iso(n.created_at)}


def disc_row(d, request=None):
    return {"id": d.id, "case": {"id": d.case_id, "case_id": d.case.case_no} if d.case_id else None, "employee": emp_brief(d.employee, request),
            "action_type": d.action_type, "charge": d.charge, "status": d.status, "notice_served_on": iso(d.notice_served_on),
            "hearing_date": iso(d.hearing_date), "hearing_time": d.hearing_time.strftime("%H:%M") if d.hearing_time else None,
            "hearing_location": d.hearing_location, "committee": [emp_brief(m, request) for m in d.committee.all()],
            "employee_response": d.employee_response, "response_at": iso(d.response_at), "minutes": d.minutes, "outcome": d.outcome,
            "penalty": d.penalty, "decision_date": iso(d.decision_date), "decided_by": d.decided_by, "created_at": iso(d.created_at)}


def letter_row(l, request=None):
    if l is None:
        return None
    url = None
    try:
        url = request.build_absolute_uri(l.pdf_file.url) if request else l.pdf_file.url
    except Exception:
        pass
    return {"letter_id": l.id, "letter_no": l.letter_no, "subject": l.subject, "body": l.body, "pdf_url": url}


def warning_row(w, request=None, with_letter=False):
    r = {"id": w.id, "warning_id": w.warning_no, "employee": emp_brief(w.employee, request), "warning_level": w.level, "reason": w.reason,
         "incident_date": iso(w.incident_date), "issued_on": iso(w.issued_on), "valid_until": iso(w.valid_until), "status": w.status,
         "case": {"id": w.case_id, "case_id": w.case.case_no} if w.case_id else None, "disciplinary_id": w.disciplinary_id,
         "issued_by": w.issued_by, "acknowledged_at": iso(w.acknowledged_at), "acknowledgement_remarks": w.acknowledgement_remarks,
         "withdrawn_reason": w.withdrawn_reason, "has_letter": w.letter_id is not None, "created_at": iso(w.created_at)}
    if with_letter:
        r["letter"] = letter_row(w.letter, request)
    return r


def legal_row(l, request=None):
    return {"id": l.id, "legal_id": l.legal_no, "case_type": l.case_type, "title": l.title, "employee": emp_brief(l.employee, request) if l.employee_id else None,
            "claimant": l.claimant or (l.employee.name if l.employee_id else None), "forum": l.forum, "court_case_number": l.court_case_number,
            "case": {"id": l.case_id, "case_id": l.case.case_no} if l.case_id else None, "filed_on": iso(l.filed_on),
            "next_hearing_date": iso(l.next_hearing_date), "counsel_name": l.counsel_name, "claim_amount": float(l.claim_amount) if l.claim_amount is not None else None,
            "status": l.status, "outcome": l.outcome, "notes": l.notes, "closed_on": iso(l.closed_on), "is_active_dispute": l.status in LegalCase.ACTIVE,
            "created_at": iso(l.created_at)}


def doc_row(d, request=None):
    return {"id": d.id, "title": d.title, "doc_type": d.doc_type, "description": d.description, "confidentiality": d.confidentiality, "file_name": d.file_name,
            "file_size": d.file_size, "content_type": d.content_type, "sha256": d.sha256, "uploaded_by": d.uploaded_by,
            "case": {"id": d.case_id, "case_id": d.case.case_no} if d.case_id else None, "disciplinary_id": d.disciplinary_id,
            "legal_case": {"id": d.legal_case_id, "legal_id": d.legal_case.legal_no} if d.legal_case_id else None,
            "download_url": request.build_absolute_uri(f"/api/relations/documents/{d.id}/download/") if request else f"/api/relations/documents/{d.id}/download/",
            "created_at": iso(d.created_at)}


def setting_row(s, request=None):
    return {"hr_head": emp_brief(s.hr_head, request) if s.hr_head_id else None, "legal_counsel": emp_brief(s.legal_counsel, request) if s.legal_counsel_id else None,
            "icc_presiding_officer": emp_brief(s.icc_presiding_officer, request) if s.icc_presiding_officer_id else None,
            "icc_meeting_frequency": s.icc_meeting_frequency, "vault_members": [emp_brief(m, request) for m in s.vault_members.all()],
            "hearing_notice_days": s.hearing_notice_days, "warning_valid_months": s.warning_valid_months}


# ---------------------------------------------------------------
# generic CRUD base: company isolation + audit (central, if AdminCenter exists) + soft delete + duplicate helper
# ---------------------------------------------------------------
def diff_rows(before, after):
    keys = [k for k in after if k in before and before[k] != after[k] and k not in ("updated_at",)]
    return ({k: before[k] for k in keys}, {k: after[k] for k in keys})


class RelCrud(RelAuthMixin, CrudBase):
    module_label = "Employee Relations"
    ref_field = "id"

    def _ref(self, d):
        return d.get(self.ref_field) if isinstance(d, dict) else None

    def create(self, request):
        r = super().create(request)
        if r.status_code == 201:
            d = r.data["data"]
            central_audit(request, self.company(), "CREATED", self.module_label, self._ref(d), None, d)
        return r

    def partial_update(self, request, pk=None):
        o = self.scope().filter(pk=pk, is_active=True).first()
        before = self.build(o) if o else None
        r = super().partial_update(request, pk)
        if r.status_code == 200 and before is not None:
            old, new = diff_rows(before, r.data["data"])
            central_audit(request, self.company(), "UPDATED", self.module_label, self._ref(r.data["data"]), old, new)
        return r

    def destroy(self, request, pk=None):
        o = self.scope().filter(pk=pk, is_active=True).first()
        if o is None:
            return err("NOT_FOUND", "Record not found.", 404)
        try:
            self.before_delete(o)
        except ValueError as e:
            return err("CONFLICT", str(e), 409)
        before = self.build(o)
        o.is_active, o.updated_by = False, self.actor()
        o.save()
        self.after_delete(o)
        central_audit(request, self.company(), "DELETED", self.module_label, self._ref(before), before, None)
        return ok(f"{self.code}_DELETED", "Deleted.", {"id": int(pk)})

    def before_delete(self, obj):
        pass

    def after_delete(self, obj):
        pass

    def dup(self, qs, message):
        if qs.filter(company=self.company(), is_active=True).exists():
            raise ValueError(message)

