# ============================================================
# User Management / Roles & RBAC matrix / Login Sessions
#   /api/admin-center/users/   /rbac/   /sessions/
# Built ON the existing EmployeeDT + EmployeeAccount + EmployeeRole + AuthLog (no copies).
# ============================================================
from django.db import transaction
from django.utils import timezone
from rest_framework.decorators import action
from rest_framework.response import Response
from rest_framework.viewsets import ViewSet
from rest_framework.views import APIView

from Company.models import AuthLog, company_details
from Employee.models import EmployeeAccount, EmployeeDT, EmployeeRole

from .common import (CenterAuthMixin, actor_label, actor_name, active_sessions, diff_rows, emp_by_code, err, iso, log_event, ok, paginate, parse_ua,
                     revoke_actor, to_int)


# ---------------- users ----------------
def user_status(emp, acct):
    if not emp.is_active:
        return "Inactive"
    return "Active" if (acct is None or acct.is_login_enabled) else "Locked"


def user_row(emp):
    acct = getattr(emp, "account", None)
    try:
        hub = emp.people_profile.branch.name if emp.people_profile.branch_id else None
    except Exception:
        hub = None
    r = acct.role if acct and acct.role_id else None
    return {"id": emp.id, "full_name": emp.name, "email": emp.email, "employee_id": emp.employee_code,
            "assigned_role": {"id": r.id, "role_name": r.role_name, "role_code": r.role_code} if r else None,
            "company_hub": hub or emp.Work_Location, "designation": emp.Designation, "phone_number": emp.phone_number,
            "last_login": iso(acct.last_login) if acct else None, "failed_login_attempts": acct.failed_login_attempts if acct else 0,
            "status": user_status(emp, acct), "has_login_account": acct is not None, "created_at": iso(getattr(emp, "created_at", None))}


def find_role(company, ref):
    q = EmployeeRole.objects.filter(company=company, is_active=True)
    r = q.filter(pk=int(ref)).first() if str(ref).isdigit() else q.filter(role_code__iexact=str(ref)).first()
    if r is None:
        raise ValueError(f"Role '{ref}' not found.")
    return r


class UserViewSet(CenterAuthMixin, ViewSet):
    """
    CRUD   /api/admin-center/users/              ?search= ?role=<code|id> ?status=Active|Locked|Inactive
    POST   {name, email, password(6-50), role?(id|code), phone_number?, designation?}      [Add User]
    PATCH  /<id>/   {name?, email?, role?, phone_number?, designation?}
    POST   /<id>/lock/  /unlock/  /reset-password/ {new_password}  /revoke-sessions/
    DELETE /<id>/  = deactivate (employee + login disabled; record kept)
    """
    sensitive = True                      # user list exposes emails / roles / login data -> needs company access, not just "view employees"
    permission_action_map = {"lock": "edit", "unlock": "edit", "reset_password": "edit", "revoke_sessions": "edit"}

    def _qs(self):
        return EmployeeDT.objects.filter(company=self.company()).select_related("account", "account__role", "company")

    def _one(self, pk):
        return self._qs().filter(pk=pk).first()

    def _me_same(self, emp):
        return isinstance(self.request.user, EmployeeDT) and self.request.user.pk == emp.pk

    def list(self, request):
        p, qs = request.query_params, self._qs()
        st = p.get("status")
        qs = qs.filter(is_active=False) if st == "Inactive" else qs.filter(is_active=True)
        if st == "Locked":
            qs = qs.filter(account__is_login_enabled=False)
        elif st == "Active":
            qs = qs.exclude(account__is_login_enabled=False)
        if p.get("role"):
            qs = qs.filter(account__role_id=int(p["role"])) if p["role"].isdigit() else qs.filter(account__role__role_code__iexact=p["role"])
        q = (p.get("search") or "").strip()
        if q:
            from django.db.models import Q
            qs = qs.filter(Q(name__icontains=q) | Q(email__icontains=q) | Q(employee_code__icontains=q))
        rows, meta = paginate(request, qs.order_by("name"), user_row)
        co = self.company()
        admin = {"full_name": getattr(co, "Registered_Company_Name", None), "email": co.email, "employee_id": "ADM-001", "assigned_role": {"role_name": "Super Admin"},
                 "status": "Active", "is_company_admin": True, "editable": False}
        return ok("USER_LIST", "List fetched.", rows, meta=meta, company_admin=admin)

    def retrieve(self, request, pk=None):
        e = self._one(pk)
        return ok("USER_DETAIL", "Detail fetched.", user_row(e)) if e else err("NOT_FOUND", "Record not found.", 404)

    def _validate_pw(self, pw):
        if not isinstance(pw, str) or not 6 <= len(pw) <= 50:
            raise ValueError("password must be 6 to 50 characters.")

    def create(self, request):
        d, co = request.data, self.company()
        try:
            name, email = (d.get("name") or "").strip(), (d.get("email") or "").strip().lower()
            if not name or not email:
                raise ValueError("name and email are required.")
            if EmployeeDT.objects.filter(email__iexact=email).exists():
                raise ValueError(f"Duplicate: a user with email '{email}' already exists.")
            self._validate_pw(d.get("password"))
            role = find_role(co, d["role"]) if d.get("role") else None
            with transaction.atomic():
                emp = EmployeeDT(company=co, name=name, email=email, password=d["password"], Employee_Status="Activate", is_active=True,
                                 phone_number=d.get("phone_number"), Designation=d.get("designation"))
                emp.save()
                EmployeeAccount.objects.create(employee=emp, role=role, is_login_enabled=True, created_by=self.actor(), updated_by=self.actor())
        except ValueError as e:
            return err("VALIDATION", str(e))
        emp = self._one(emp.pk)
        log_event(request, co, "CREATED", "Users", emp.employee_code, None, {"name": name, "email": email, "role": role.role_code if role else None})
        return ok("USER_CREATED", "User created.", user_row(emp), 201)

    def partial_update(self, request, pk=None):
        e, d, co = self._one(pk), request.data, self.company()
        if e is None or not e.is_active:
            return err("NOT_FOUND", "Record not found.", 404)
        before = user_row(e)
        try:
            if "name" in d:
                if not (d["name"] or "").strip():
                    raise ValueError("name cannot be empty.")
                e.name = d["name"].strip()
            if "email" in d:
                em = (d["email"] or "").strip().lower()
                if EmployeeDT.objects.filter(email__iexact=em).exclude(pk=e.pk).exists():
                    raise ValueError(f"Duplicate: a user with email '{em}' already exists.")
                e.email = em
            for k, f in (("phone_number", "phone_number"), ("designation", "Designation")):
                if k in d:
                    setattr(e, f, d[k])
            acct = getattr(e, "account", None)
            if "role" in d:
                if acct is None:
                    raise ValueError("This user has no login account.")
                if self._me_same(e) and (acct.role_id is not None):
                    raise ValueError("You cannot change your own role.")
                acct.role = find_role(co, d["role"]) if d["role"] else None
            with transaction.atomic():
                e.save()
                if acct is not None and "role" in d:
                    acct.updated_by = self.actor()
                    acct.save()
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        e = self._one(e.pk)
        old, new = diff_rows(before, user_row(e))
        log_event(request, co, "UPDATED", "Users", e.employee_code, old, new)
        return ok("USER_UPDATED", "Updated.", user_row(e))

    put = partial_update

    def _set_lock(self, request, pk, lock):
        e = self._one(pk)
        if e is None or not e.is_active:
            return err("NOT_FOUND", "Record not found.", 404)
        a = getattr(e, "account", None)
        if a is None:
            return err("INVALID_STATE", "This user has no login account.", 409)
        if lock and self._me_same(e):
            return err("INVALID_STATE", "You cannot lock your own account.", 409)
        if a.is_login_enabled == (not lock):
            return err("INVALID_STATE", f"User is already {'locked' if lock else 'unlocked'}.", 409)
        a.is_login_enabled, a.updated_by = (not lock), self.actor()
        if not lock:
            a.failed_login_attempts = 0
        a.save()
        if lock:
            revoke_actor(self.company(), AuthLog.ACTOR_EMPLOYEE, e.employee_code, self.actor(), "Account locked")
        log_event(request, self.company(), "LOCKED" if lock else "UNLOCKED", "Users", e.employee_code)
        return ok("USER_LOCKED" if lock else "USER_UNLOCKED", "User locked." if lock else "User unlocked.", user_row(self._one(pk)))

    @action(detail=True, methods=["post"], url_path="lock")
    def lock(self, request, pk=None):
        return self._set_lock(request, pk, True)

    @action(detail=True, methods=["post"], url_path="unlock")
    def unlock(self, request, pk=None):
        return self._set_lock(request, pk, False)

    @action(detail=True, methods=["post"], url_path="reset-password")
    def reset_password(self, request, pk=None):
        e = self._one(pk)
        if e is None or not e.is_active:
            return err("NOT_FOUND", "Record not found.", 404)
        try:
            self._validate_pw(request.data.get("new_password"))
        except ValueError as ex:
            return err("VALIDATION", str(ex))
        e.password = request.data["new_password"]
        e.save()
        revoke_actor(self.company(), AuthLog.ACTOR_EMPLOYEE, e.employee_code, self.actor(), "Password reset")
        log_event(request, self.company(), "PASSWORD_RESET", "Users", e.employee_code)
        return ok("USER_PASSWORD_RESET", "Password reset. Existing sessions were revoked.", {"id": e.id})

    @action(detail=True, methods=["post"], url_path="revoke-sessions")
    def revoke_sessions(self, request, pk=None):
        e = self._one(pk)
        if e is None:
            return err("NOT_FOUND", "Record not found.", 404)
        revoke_actor(self.company(), AuthLog.ACTOR_EMPLOYEE, e.employee_code, self.actor(), "Revoked by admin")
        log_event(request, self.company(), "SESSIONS_REVOKED", "Users", e.employee_code)
        return ok("USER_SESSIONS_REVOKED", "All sessions of this user were revoked.", {"id": e.id})

    def destroy(self, request, pk=None):
        e = self._one(pk)
        if e is None or not e.is_active:
            return err("NOT_FOUND", "Record not found.", 404)
        if self._me_same(e):
            return err("INVALID_STATE", "You cannot delete your own account.", 409)
        before = user_row(e)
        with transaction.atomic():
            e.is_active = False
            e.save()
            a = getattr(e, "account", None)
            if a is not None:
                a.is_login_enabled, a.updated_by = False, self.actor()
                a.save()
        revoke_actor(self.company(), AuthLog.ACTOR_EMPLOYEE, e.employee_code, self.actor(), "User deleted")
        log_event(request, self.company(), "DELETED", "Users", e.employee_code, before, None)
        return ok("USER_DELETED", "User deactivated.", {"id": int(pk)})


# ---------------- RBAC matrix (reads / writes the existing EmployeeRole checkboxes) ----------------
def role_flags():
    mods = {}
    for f in EmployeeRole._meta.fields:
        if f.name.startswith("can_"):
            act, _, mod = f.name[4:].partition("_")
            if mod:
                mods.setdefault(mod, []).append(act)
    return mods


class RbacMatrixView(CenterAuthMixin, APIView):
    """
    GET /api/admin-center/rbac/matrix/                  ?modules=employees,payroll
    PUT /api/admin-center/rbac/matrix/   {"changes":[{"role_id"|"role_code", "module", "action"?:"view|create|edit|delete|manage|access", "allowed": true}]}   [Save Permissions]
        action "access" (default) = the single checkbox of the matrix: true -> view on, false -> every action of that module off.
    """
    perm_module = "roles"
    sensitive = True

    def get(self, request):
        co = self.company()
        roles = list(EmployeeRole.objects.filter(company=co, is_active=True).order_by("role_name"))
        mods = role_flags()
        want = [m for m in (request.query_params.get("modules") or "").split(",") if m]
        out = []
        for m, acts in sorted(mods.items()):
            if want and m not in want:
                continue
            per = {}
            for r in roles:
                flags = {a: bool(getattr(r, f"can_{a}_{m}")) for a in acts}
                flags["access"] = flags.get("view", False) or flags.get("manage", False)
                per[str(r.id)] = flags
            out.append({"module": m, "label": m.replace("_", " ").title(), "actions": acts, "roles": per})
        return ok("RBAC_MATRIX", "Permission matrix.", {"roles": [{"id": r.id, "role_name": r.role_name, "role_code": r.role_code} for r in roles], "modules": out})

    def put(self, request):
        co, ch = self.company(), request.data.get("changes")
        if not isinstance(ch, list) or not ch:
            return err("VALIDATION", "changes (non-empty list) is required.")
        mods, plan = role_flags(), []
        mine = getattr(getattr(request.user, "account", None), "role_id", None)
        for i, c in enumerate(ch, 1):
            q = EmployeeRole.objects.filter(company=co, is_active=True)
            r = q.filter(pk=to_int(c.get("role_id"))).first() if c.get("role_id") else q.filter(role_code__iexact=c.get("role_code") or "").first()
            m, a, allowed = c.get("module"), c.get("action") or "access", c.get("allowed")
            if r is None:
                return err("VALIDATION", f"Change {i}: role not found.")
            if m not in mods or (a != "access" and a not in mods[m]):
                return err("VALIDATION", f"Change {i}: unknown module/action '{m}.{a}'.")
            if not isinstance(allowed, bool):
                return err("VALIDATION", f"Change {i}: allowed must be true or false.")
            if r.id == mine and m in ("roles", "company") and not allowed:
                return err("CONFLICT", f"Change {i}: you cannot remove your own {m} access.", 409)
            plan.append((r, m, a, allowed))
        with transaction.atomic():
            for r, m, a, allowed in plan:
                names = ([f"can_view_{m}"] if allowed else [f"can_{x}_{m}" for x in mods[m]]) if a == "access" else [f"can_{a}_{m}"]
                old = {n: getattr(r, n) for n in names if hasattr(r, n)}
                for n in names:
                    if hasattr(r, n):
                        setattr(r, n, allowed)
                r.save()
                log_event(request, co, "PERMISSION_CHANGED", "RBAC", f"{r.role_code}.{m}.{a}", old, {n: getattr(r, n) for n in old})
        return ok("RBAC_SAVED", f"{len(plan)} permission change(s) saved.", {"changed": len(plan)})


# ---------------- sessions ----------------
class SessionViewSet(CenterAuthMixin, ViewSet):
    """
    GET    /api/admin-center/sessions/               active login sessions (derived from the existing login log)
    GET    /api/admin-center/sessions/<id>/          DELETE or POST /<id>/revoke/  -> revoke (forces that employee to log in again)
    POST   /api/admin-center/sessions/revoke-others/ [Revoke All Other Sessions]
    GET    /api/admin-center/sessions/history/       ?status=SUCCESS|FAILED ?identifier= ?date_from= ?date_to=   full login history
    """
    permission_action_map = {"revoke": "edit", "revoke_others": "edit", "history": "view"}

    def _me(self, request):
        u = request.user
        if isinstance(u, EmployeeDT):
            return AuthLog.ACTOR_EMPLOYEE, u.employee_code
        if isinstance(u, company_details):
            return AuthLog.ACTOR_COMPANY_ADMIN, str(u.company_id)
        return None, None

    def _row(self, l, request):
        os_, br = parse_ua(l.user_agent)
        me = self._me(request)
        cur = (l.actor_type, l.actor_id) == me
        return {"id": l.id, "user": actor_name(self.company(), l.actor_type, l.actor_id, l.identifier), "identifier": l.identifier,
                "actor_type": l.actor_type, "actor_id": l.actor_id, "device": os_, "browser": br, "ip_address": l.ip_address,
                "last_activity": iso(l.created_at), "status": "Current" if cur else "Active", "revocable": (not cur) and l.actor_type == AuthLog.ACTOR_EMPLOYEE}

    def list(self, request):
        rows = [self._row(l, request) for l in active_sessions(self.company())]
        return ok("SESSION_LIST", "Active login sessions.", rows, total=len(rows))

    def retrieve(self, request, pk=None):
        l = next((x for x in active_sessions(self.company()) if str(x.id) == str(pk)), None)
        return ok("SESSION_DETAIL", "Session.", self._row(l, request)) if l else err("NOT_FOUND", "Session not found or no longer active.", 404)

    def _revoke(self, request, pk):
        l = next((x for x in active_sessions(self.company()) if str(x.id) == str(pk)), None)
        if l is None:
            return err("NOT_FOUND", "Session not found or no longer active.", 404)
        if (l.actor_type, l.actor_id) == self._me(request):
            return err("INVALID_STATE", "You cannot revoke your own current session. Use logout.", 409)
        if l.actor_type != AuthLog.ACTOR_EMPLOYEE:
            return err("INVALID_STATE", "Company-admin sessions cannot be revoked from here.", 409)
        revoke_actor(self.company(), l.actor_type, l.actor_id, actor_label(request.user), "Revoked from Admin Control Center")
        log_event(request, self.company(), "SESSION_REVOKED", "Sessions", l.actor_id, None, f"{l.ip_address} {parse_ua(l.user_agent)[1]}")
        return ok("SESSION_REVOKED", "Session revoked. The user must log in again.", {"id": l.id, "actor_id": l.actor_id})

    def destroy(self, request, pk=None):
        return self._revoke(request, pk)

    @action(detail=True, methods=["post"], url_path="revoke")
    def revoke(self, request, pk=None):
        return self._revoke(request, pk)

    @action(detail=False, methods=["post"], url_path="revoke-others")
    def revoke_others(self, request):
        me, done, skipped = self._me(request), [], 0
        for l in active_sessions(self.company()):
            if (l.actor_type, l.actor_id) == me or l.actor_type != AuthLog.ACTOR_EMPLOYEE:
                skipped += 1
                continue
            if l.actor_id not in done:
                revoke_actor(self.company(), l.actor_type, l.actor_id, actor_label(request.user), "Revoke all other sessions")
                done.append(l.actor_id)
        log_event(request, self.company(), "SESSIONS_REVOKED", "Sessions", "all-others", None, f"{len(done)} user(s)")
        return ok("SESSIONS_REVOKED", f"{len(done)} user(s) signed out.", {"revoked_users": done, "skipped": skipped})

    @action(detail=False, methods=["get"], url_path="history")
    def history(self, request):
        p = request.query_params
        qs = AuthLog.objects.filter(company=self.company()).order_by("-id")
        if p.get("status"):
            qs = qs.filter(status=p["status"].upper())
        if p.get("identifier"):
            qs = qs.filter(identifier__icontains=p["identifier"])
        from People.common import to_date
        try:
            if p.get("date_from"):
                qs = qs.filter(created_at__date__gte=to_date(p["date_from"]))
            if p.get("date_to"):
                qs = qs.filter(created_at__date__lte=to_date(p["date_to"]))
        except ValueError as e:
            return err("VALIDATION", str(e))
        rows, meta = paginate(request, qs, lambda l: {"id": l.id, "identifier": l.identifier, "actor_type": l.actor_type, "action": l.action, "status": l.status,
                                                    "reason": l.reason, "ip_address": l.ip_address, "browser": parse_ua(l.user_agent)[1], "device": parse_ua(l.user_agent)[0],
                                                    "at": iso(l.created_at)})
        return ok("LOGIN_HISTORY", "Login history.", rows, meta=meta)
