# ============================================================
# AdminCenter - shared helpers (reuses People.common envelope / paging / CrudBase)
# ============================================================
import base64
import hashlib
import json
from datetime import datetime, timedelta, timezone as dtz

from django.conf import settings
from django.utils import timezone
from rest_framework.permissions import BasePermission

from Company.models import AuthLog, get_client_ip
from Employee.employee_crud_permissions import (_role_is_usable, actor_label, resolve_actor_role, role_allows)  # noqa: F401
from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated  # noqa: F401
from People.common import (CrudBase, PeopleAuthMixin, emp_brief, emp_by_code, employees_qs, err, iso, ok, paginate,  # noqa: F401
                           to_bool, to_date, to_int)

from .models import AdminAuditEvent, ScheduledJob, SecurityPolicy, SessionRevocation

# ---------------------------------------------------------------
# permissions
#   Company Admin token  -> everything
#   Employee (HR) token  -> role checkboxes:  sensitive resources need can_<view|edit|manage>_company
#                           (RBAC matrix needs can_<action>_roles); plain reads (org units, master data,
#                           workflows, users list) are also open to roles that can view employees.
# ---------------------------------------------------------------
def center_allows(user, action, sensitive=True, module="company"):
    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
    a = action if module != "company" else ("view" if action == "view" else "edit")
    if role_allows(role, module, a):
        return True
    return (not sensitive) and action == "view" and (role_allows(role, "employees", "view") or role_allows(role, "company", "view"))


def ip_allowed(company, request):
    p = SecurityPolicy.objects.filter(company=company).first()
    if not p or not p.ip_allowlist_enabled or not p.ip_allowlist:
        return True
    return get_client_ip(request) in p.ip_allowlist


class IsCenterUser(BasePermission):
    message = "You do not have permission to use the Admin Control Center."
    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)
        if not act or not center_allows(request.user, act, getattr(view, "sensitive", True), getattr(view, "perm_module", "company")):
            return False
        from Employee.employee_crud_permissions import resolve_company_for_user
        co = resolve_company_for_user(request.user)
        if co is not None and not ip_allowed(co, request):
            self.message = "Your IP address is not on the company's admin allow-list."
            return False
        return True


class CenterAuthMixin(PeopleAuthMixin):
    permission_classes = [IsCenterUser]
    sensitive = True


# ---------------------------------------------------------------
# audit trail (append-only)
# ---------------------------------------------------------------
def who(user):
    from Company.models import company_details
    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 log_event(request, company, action, module, record_ref=None, old=None, new=None):
    try:
        return AdminAuditEvent.objects.create(
            company=company, actor=actor_label(request.user), actor_name=who(request.user), action=action, module=module,
            record_ref=short(record_ref, 150), old_value=short(old), new_value=short(new), ip_address=get_client_ip(request))
    except Exception:
        return None


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", "id_version")]
    return ({k: before[k] for k in keys}, {k: after[k] for k in keys})


class AuditedCrud(CenterAuthMixin, CrudBase):
    """CrudBase + audit trail + soft delete that releases unique keys (so a deleted code/name can be reused)."""
    module_label = "Admin Center"
    ref_field = "name"
    unique_fields = ()          # fields suffixed with ~del<id> on delete

    def _ref(self, d):
        return d.get(self.ref_field) if isinstance(d, dict) else None

    def dup(self, obj, **lookup):
        """Case-insensitive duplicate check among live rows of this company."""
        qs = self.model.objects.filter(company=self.company(), is_active=True)
        for k, v in lookup.items():
            qs = qs.filter(**{f"{k}__iexact": v}) if isinstance(v, str) else qs.filter(**{k: v})
        if obj.pk:
            qs = qs.exclude(pk=obj.pk)
        if qs.exists():
            raise ValueError("Duplicate: " + ", ".join(f"{k} '{v}'" for k, v in lookup.items()) + " already exists.")

    def create(self, request):
        r = super().create(request)
        if r.status_code == 201:
            d = r.data["data"]
            log_event(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"])
            log_event(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)
        for f in self.unique_fields:
            setattr(o, f, f"{str(getattr(o, f) or '')[:20]}~del{o.pk}")
        o.is_active, o.updated_by = False, self.actor()
        o.save()
        self.after_delete(o)
        log_event(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


# ---------------------------------------------------------------
# connector secrets: encrypted at rest, write-only (never returned by any API)
# ---------------------------------------------------------------
def _fernet():
    from cryptography.fernet import Fernet
    key = getattr(settings, "ADMIN_CENTER_FERNET_KEY", None)
    if not key:
        key = base64.urlsafe_b64encode(hashlib.sha256(("admin-center:" + settings.SECRET_KEY).encode()).digest())
    return Fernet(key)


def encrypt_secret(plain):
    return _fernet().encrypt(plain.encode()).decode()


def decrypt_secret(token):
    return _fernet().decrypt(token.encode()).decode()


def secret_hint(plain):
    return "****" + plain[-4:] if len(plain) >= 8 else "****"


# ---------------------------------------------------------------
# scheduled jobs: schedule label + next run
# ---------------------------------------------------------------
DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]


def _t(job):
    t = job.time_of_day
    return datetime.strptime(t, "%H:%M").time() if isinstance(t, str) else t


def ordinal(n):
    return f"{n}{'th' if 10 <= n % 100 <= 20 else {1: 'st', 2: 'nd', 3: 'rd'}.get(n % 10, 'th')}"


def schedule_label(job):
    at = _t(job).strftime("%I:%M %p")
    return {"Daily": f"Every day {at}", "Weekdays": f"Weekdays {at}",
            "Weekly": f"Weekly on {DAYS[job.day_of_week or 0]} {at}", "Monthly": f"{ordinal(job.day_of_month or 1)} of Month {at}"}.get(job.schedule_type, job.schedule_type)


def compute_next_run(job, now=None):
    tz = timezone.get_current_timezone()
    now = timezone.localtime(now or timezone.now(), tz)
    for i in range(0, 62):
        d = (now + timedelta(days=i)).date()
        ok_day = (job.schedule_type == "Daily" or (job.schedule_type == "Weekdays" and d.weekday() < 5)
                  or (job.schedule_type == "Weekly" and d.weekday() == (job.day_of_week or 0))
                  or (job.schedule_type == "Monthly" and d.day == (job.day_of_month or 1)))
        if not ok_day:
            continue
        cand = timezone.make_aware(datetime.combine(d, _t(job)), tz)
        if cand > now:
            return cand
    return None


# ---------------------------------------------------------------
# sessions (derived from the existing Company.AuthLog) + revocation
# ---------------------------------------------------------------
def session_window():
    return settings.SIMPLE_JWT.get("REFRESH_TOKEN_LIFETIME", timedelta(days=1))


def parse_ua(ua):
    ua = ua or ""
    os_ = ("Windows 11/10" if "Windows" in ua else "macOS" if "Mac OS" in ua and "iPhone" not in ua else "Android" if "Android" in ua
           else "iOS" if ("iPhone" in ua or "iPad" in ua) else "Linux" if "Linux" in ua else "Unknown")
    br = ("Edge" if "Edg/" in ua else "Firefox" if "Firefox/" in ua else "Chrome" if "Chrome/" in ua else "Safari" if "Safari/" in ua else "API client" if ua else "Unknown")
    return os_, br


def actor_name(company, actor_type, actor_id, identifier=None):
    if actor_type == AuthLog.ACTOR_EMPLOYEE:
        e = employees_qs(company).filter(employee_code=actor_id).first()
        return e.name if e else (identifier or actor_id)
    return getattr(company, "Registered_Company_Name", None) or identifier or "Company Admin"


def active_sessions(company):
    """Latest successful login per actor+ip+device that is newer than the actor's logout / revocation and inside the refresh lifetime."""
    since = timezone.now() - session_window()
    logs = AuthLog.objects.filter(company=company, action=AuthLog.ACTION_LOGIN, status=AuthLog.STATUS_SUCCESS, created_at__gte=since).order_by("-id")
    logouts = {}
    for l in AuthLog.objects.filter(company=company, action=AuthLog.ACTION_LOGOUT, status=AuthLog.STATUS_SUCCESS, created_at__gte=since).order_by("id"):
        logouts[(l.actor_type, l.actor_id)] = l.created_at
    revs = {(r.actor_type, r.actor_id): r.revoked_before for r in SessionRevocation.objects.filter(company=company)}
    seen, out = set(), []
    for l in logs:
        key = (l.actor_type, l.actor_id, l.ip_address, l.user_agent)
        if key in seen:
            continue
        seen.add(key)
        k2 = (l.actor_type, l.actor_id)
        if (k2 in logouts and logouts[k2] >= l.created_at) or (k2 in revs and revs[k2] > l.created_at):
            continue
        out.append(l)
    return out


def is_token_revoked(validated_token, employee):
    """Called from Employee.employee_authentication (additive hook). True -> token rejected."""
    iat = validated_token.get("iat")
    if iat is None:
        return False
    r = SessionRevocation.objects.filter(company=employee.company, actor_type=AuthLog.ACTOR_EMPLOYEE, actor_id=employee.employee_code).first()
    return bool(r and datetime.fromtimestamp(int(iat), tz=dtz.utc) < r.revoked_before)


def revoke_actor(company, actor_type, actor_id, by, reason=None, before=None):
    r, _ = SessionRevocation.objects.update_or_create(company=company, actor_type=actor_type, actor_id=str(actor_id),
                                                       defaults={"revoked_before": before or timezone.now(), "revoked_by": by, "reason": reason})
    return r
