# ============================================================
# EMPLOYEE SIDE (self-service, read-mostly)     /employee/admin-center/
# Auth: Employee JWT. Employees see their own access / sessions / activity and read the company's
# org structure, master data, approval chains and password rules. They cannot change governance data.
# ============================================================
from datetime import datetime, timedelta, timezone as dtz

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

from Company.models import AuthLog
from Employee.employee_authentication import EmployeeJWTAuthentication, IsEmployeeAuthenticated
from Employee.employee_crud_permissions import actor_label
from People.common import err, iso, ok, paginate

from . import services
from .common import active_sessions, parse_ua, revoke_actor
from .models import AdminAuditEvent, LegalEntity, MasterDataValue, OrgUnit, WorkflowDefinition
from .views_access import role_flags
from .views_automation import workflow_row
from .views_org import org_row


class SelfBase(APIView):
    authentication_classes = [EmployeeJWTAuthentication]
    permission_classes = [IsEmployeeAuthenticated]

    @property
    def me(self):
        return self.request.user

    @property
    def company(self):
        return self.request.user.company


class MyAccess(SelfBase):
    """GET /employee/admin-center/my-access/    my role and exactly what it allows"""

    def get(self, request):
        r = getattr(self.me, "role", None)
        mods = []
        if r is not None:
            for m, acts in sorted(role_flags().items()):
                allowed = [a for a in acts if getattr(r, f"can_{a}_{m}", False)]
                if allowed:
                    mods.append({"module": m, "allowed_actions": allowed})
        return ok("MY_ACCESS", "My access.", {"employee_code": self.me.employee_code, "name": self.me.name,
                                              "role": {"id": r.id, "role_name": r.role_name, "role_code": r.role_code} if r else None, "modules": mods})


class MySessions(SelfBase):
    """
    GET  /employee/admin-center/my-sessions/             my active sessions
    POST /employee/admin-center/my-sessions/revoke-others/   sign out every other device (this session stays valid)
    """

    def get(self, request):
        rows = []
        for l in active_sessions(self.company):
            if l.actor_type == AuthLog.ACTOR_EMPLOYEE and l.actor_id == self.me.employee_code:
                os_, br = parse_ua(l.user_agent)
                rows.append({"id": l.id, "device": os_, "browser": br, "ip_address": l.ip_address, "last_activity": iso(l.created_at)})
        return ok("MY_SESSIONS", "My active sessions.", rows)


class MySessionsRevokeOthers(SelfBase):
    def post(self, request):
        iat = (request.auth or {}).get("iat") if request.auth is not None else None
        before = datetime.fromtimestamp(int(iat), tz=dtz.utc) if iat else timezone.now() - timedelta(seconds=1)
        revoke_actor(self.company, AuthLog.ACTOR_EMPLOYEE, self.me.employee_code, actor_label(self.me), "Revoked other sessions", before=before)
        AdminAuditEvent.objects.create(company=self.company, actor=actor_label(self.me), actor_name=self.me.name, action="SESSIONS_REVOKED", module="Sessions",
                                       record_ref=self.me.employee_code, new_value="own other sessions")
        return ok("MY_SESSIONS_REVOKED", "Other sessions signed out.", {"revoked_before": iso(before)})


class MyActivity(SelfBase):
    """GET /employee/admin-center/my-activity/    ?kind=login|audit (default both)  - my login history and the admin-center events that name me"""

    def get(self, request):
        kind = request.query_params.get("kind")
        code = self.me.employee_code
        out = {}
        if kind in (None, "", "login"):
            qs = AuthLog.objects.filter(company=self.company, actor_type=AuthLog.ACTOR_EMPLOYEE).filter(actor_id=code).order_by("-id")[:50]
            out["logins"] = [{"id": l.id, "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)} for l in qs]
        if kind in (None, "", "audit"):
            qs = AdminAuditEvent.objects.filter(company=self.company, actor=actor_label(self.me)).order_by("-id")[:50]
            out["actions"] = [{"id": a.id, "timestamp": iso(a.created_at), "action": a.action, "module": a.module, "record_reference": a.record_ref} for a in qs]
        return ok("MY_ACTIVITY", "My recent activity.", out)


class OrgUnitsRead(SelfBase):
    """GET /employee/admin-center/org-units/    ?unit_type= ?search="""

    def get(self, request):
        from .views_org import sync_org_units
        sync_org_units(self.company)
        qs = OrgUnit.objects.filter(company=self.company, is_active=True, status="Active").select_related("parent", "head")
        p = request.query_params
        if p.get("unit_type"):
            qs = qs.filter(unit_type=p["unit_type"])
        if p.get("search"):
            qs = qs.filter(name__icontains=p["search"])
        rows, meta = paginate(request, qs, lambda u: {k: org_row(u)[k] for k in ("id", "unit_type", "name", "code", "parent_structure", "head_manager", "status")})
        return ok("ORG_UNITS", "Organization units.", rows, meta=meta)


class MasterDataRead(SelfBase):
    """GET /employee/admin-center/master-data/?category=Leave Type      active values for dropdowns"""

    def get(self, request):
        qs = MasterDataValue.objects.filter(company=self.company, is_active=True, status="Active")
        if request.query_params.get("category"):
            qs = qs.filter(category__iexact=request.query_params["category"])
        return ok("MASTER_DATA", "Master data.", [{"category": m.category, "value": m.value, "code": m.code, "sort_order": m.sort_order} for m in qs])


class WorkflowsRead(SelfBase):
    """GET /employee/admin-center/workflows/?module=Leave     approval chains that apply to my requests"""

    def get(self, request):
        qs = WorkflowDefinition.objects.filter(company=self.company, is_active=True, status="Active")
        if request.query_params.get("module"):
            qs = qs.filter(module__iexact=request.query_params["module"])
        rows = []
        for w in qs:
            r = workflow_row(w)
            rows.append({k: r[k] for k in ("id", "name", "module", "trigger_event", "levels_label", "sla_label", "approver_chain")})
        return ok("WORKFLOWS", "Approval workflows.", rows)


class CompaniesRead(SelfBase):
    """GET /employee/admin-center/companies/     legal entities (name, code, country, currency only)"""

    def get(self, request):
        qs = LegalEntity.objects.filter(company=self.company, is_active=True, status="Active")
        return ok("COMPANIES", "Legal entities.", [{"id": e.id, "name": e.name, "code": e.code, "country": e.country, "currency": e.currency,
                                                     "timezone": e.timezone, "is_primary": e.is_primary} for e in qs])


class SecurityRules(SelfBase):
    """GET /employee/admin-center/security-policy/    password / session rules that apply to me (no admin details, no IP list)"""

    def get(self, request):
        p = services.get_policy(self.company)
        return ok("SECURITY_RULES", "Security rules.", {
            "password_rotation_days": p.password_rotation_days if p.password_rotation_enabled else None, "password_history": p.password_history,
            "idle_timeout_minutes": p.idle_timeout_minutes if p.idle_timeout_enabled else None,
            "lockout_after_failed_attempts": p.lockout_attempts if p.lockout_enabled else None,
            "lockout_minutes": p.lockout_minutes if p.lockout_enabled else None})
