# ============================================================
# AdminCenter - services: export/backup, job runner, connector ping, health probes, security posture
# ============================================================
import hashlib
import ipaddress
import json
import os
import shutil
import socket
import time
from datetime import timedelta
from urllib.parse import urlparse

from django.conf import settings
from django.core.cache import cache
from django.db import connection
from django.utils import timezone

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

from .common import compute_next_run, employees_qs
from .models import (AdminAuditEvent, BackupPolicy, BackupSnapshot, IntegrationConnector, LegalEntity, MasterDataValue, OrgUnit, ScheduledJob,
                     SecurityPolicy, WorkflowDefinition)

STARTED = time.time()


# ---------------- export / backup (company-scoped config export: never passwords or secrets) ----------------
def build_export(company):
    users = []
    for a in EmployeeAccount.objects.filter(employee__company=company).select_related("employee", "role"):
        users.append({"employee_code": a.employee.employee_code, "name": a.employee.name, "email": a.employee.email,
                      "role": a.role.role_code if a.role else None, "login_enabled": a.is_login_enabled, "active": a.employee.is_active})
    roles = []
    for r in EmployeeRole.objects.filter(company=company):
        roles.append({"role_code": r.role_code, "role_name": r.role_name, "is_active": r.is_active,
                      "permissions": {f.name: getattr(r, f.name) for f in r._meta.fields if f.name.startswith("can_")}})
    p = SecurityPolicy.objects.filter(company=company).first()
    return {
        "exported_at": timezone.now().isoformat(), "company_id": company.company_id, "scope": "admin-center configuration (no passwords, no secrets)",
        "legal_entities": [{"name": e.name, "code": e.code, "tax_id": e.tax_id, "country": e.country, "currency": e.currency, "timezone": e.timezone,
                            "status": e.status, "is_primary": e.is_primary} for e in LegalEntity.objects.filter(company=company, is_active=True)],
        "org_units": [{"unit_type": u.unit_type, "name": u.name, "code": u.code, "parent": u.parent.name if u.parent_id else u.parent_name,
                       "head": u.head.employee_code if u.head_id else None, "status": u.status} for u in OrgUnit.objects.filter(company=company, is_active=True).select_related("parent", "head")],
        "master_data": [{"category": m.category, "value": m.value, "code": m.code, "sort_order": m.sort_order, "status": m.status}
                        for m in MasterDataValue.objects.filter(company=company, is_active=True)],
        "workflows": [{"name": w.name, "module": w.module, "trigger_event": w.trigger_event, "sla_hours": w.sla_hours, "status": w.status,
                       "steps": [{"order": s.step_order, "approver_type": s.approver_type, "sla_hours": s.sla_hours} for s in w.steps.filter(is_active=True)]}
                      for w in WorkflowDefinition.objects.filter(company=company, is_active=True)],
        "scheduled_jobs": [{"name": j.name, "job_type": j.job_type, "schedule_type": j.schedule_type, "time_of_day": str(j.time_of_day), "status": j.status}
                           for j in ScheduledJob.objects.filter(company=company, is_active=True)],
        "integrations": [{"name": i.name, "connector_type": i.connector_type, "endpoint": i.endpoint, "version": i.version, "status": i.status}
                         for i in IntegrationConnector.objects.filter(company=company, is_active=True)],
        "security_policy": {f.name: getattr(p, f.name) for f in p._meta.fields if f.name not in ("id", "company", "created_by", "updated_by", "id_version", "created_at", "updated_at")} if p else None,
        "roles": roles, "users": users,
    }


def backup_dir(company):
    d = os.path.join(settings.MEDIA_ROOT, "admin_center_backups", str(company.company_id))
    os.makedirs(d, exist_ok=True)
    return d


def create_snapshot(company, actor, policy=None):
    data = build_export(company)
    raw = json.dumps(data, indent=2, default=str, ensure_ascii=False).encode()
    path = os.path.join(backup_dir(company), f"snapshot_{timezone.now().strftime('%Y%m%d_%H%M%S_%f')}.json")
    with open(path, "wb") as f:
        f.write(raw)
    counts = {k: len(v) for k, v in data.items() if isinstance(v, list)}
    snap = BackupSnapshot.objects.create(company=company, policy=policy, file_path=path, size_bytes=len(raw), checksum=hashlib.sha256(raw).hexdigest(),
                                         record_counts=counts, status="Completed", triggered_by=actor, created_by=actor, updated_by=actor)
    if policy is not None:                                   # retention
        cutoff = timezone.now() - timedelta(days=policy.retention_days)
        for old in BackupSnapshot.objects.filter(company=company, policy=policy, is_active=True, created_at__lt=cutoff):
            drop_snapshot(old)
    return snap


def drop_snapshot(snap):
    try:
        if snap.file_path and os.path.abspath(snap.file_path).startswith(os.path.abspath(settings.MEDIA_ROOT)) and os.path.exists(snap.file_path):
            os.remove(snap.file_path)
    except OSError:
        pass
    snap.is_active = False
    snap.save()


def human_size(n):
    for u in ("B", "KB", "MB", "GB", "TB"):
        if n < 1024 or u == "TB":
            return f"{n:.0f} {u}" if u == "B" else f"{n:.1f} {u}"
        n /= 1024


# ---------------- scheduled jobs ----------------
def _h_backup(company, job, actor):
    s = create_snapshot(company, actor)
    return "Completed", f"Snapshot #{s.id} created ({human_size(s.size_bytes)})."


def _h_lockout(company, job, actor):
    n = lockout_sweep(company, actor)
    return "Completed", f"{n} account(s) locked for repeated failed logins."


def _h_log(company, job, actor):
    return "Completed", "Executed (no external side effects configured for this job type)."


HANDLERS = {"backup": _h_backup, "lockout": _h_lockout, "log": _h_log}


def run_job(job, actor):
    fn = HANDLERS.get(job.handler, _h_log)
    try:
        status, msg = fn(job.company, job, actor)
    except Exception as e:                                   # a failing job must never crash the API
        status, msg = "Failed", str(e)[:280]
    job.last_run_at, job.last_run_status, job.last_run_message = timezone.now(), status, msg
    job.next_run_at = compute_next_run(job) if job.status == "Active" else None
    job.save()
    return status, msg


# ---------------- connector ping (SSRF-guarded TCP connect) ----------------
def _target(endpoint):
    e = (endpoint or "").strip()
    if not e:
        raise ValueError("endpoint is empty.")
    if "://" in e:
        u = urlparse(e)
        return u.hostname, u.port or {"https": 443, "http": 80, "smtp": 25}.get(u.scheme, 443)
    host, _, port = e.partition("/")[0].partition(":")
    return host, int(port) if port.isdigit() else 443


def ping_endpoint(endpoint, timeout=3):
    try:
        host, port = _target(endpoint)
        infos = socket.getaddrinfo(host, port, proto=socket.IPPROTO_TCP)
    except Exception as e:
        return False, None, f"Cannot resolve endpoint: {str(e)[:120]}"
    allow_private = getattr(settings, "ADMIN_CENTER_ALLOW_PRIVATE_PING", False)
    for i in infos:
        ip = ipaddress.ip_address(i[4][0])
        if not allow_private and (ip.is_private or ip.is_loopback or ip.is_link_local or ip.is_reserved or ip.is_multicast):
            return False, None, "Blocked: internal / private addresses are not pinged (set ADMIN_CENTER_ALLOW_PRIVATE_PING = True to allow)."
    t0 = time.time()
    try:
        with socket.create_connection((host, port), timeout=timeout):
            pass
    except Exception as e:
        return False, None, f"Connection failed: {str(e)[:120]}"
    return True, int((time.time() - t0) * 1000), "Reachable."


# ---------------- security posture ----------------
WEIGHTS = {"mfa_required_admins": 25, "lockout_enabled": 20, "password_rotation_enabled": 20, "idle_timeout_enabled": 20, "ip_allowlist_enabled": 15}


def get_policy(company):
    p, _ = SecurityPolicy.objects.get_or_create(company=company)
    return p


def posture_score(p):
    return sum(w for k, w in WEIGHTS.items() if getattr(p, k))


def failed_logins(company, hours=24):
    return AuthLog.objects.filter(company=company, action=AuthLog.ACTION_LOGIN, status=AuthLog.STATUS_FAILED, created_at__gte=timezone.now() - timedelta(hours=hours))


def locked_accounts(company):
    return EmployeeAccount.objects.filter(employee__company=company, employee__is_active=True, is_login_enabled=False)


def threats(company):
    out, rows = [], {}
    for l in failed_logins(company):
        r = rows.setdefault(l.ip_address or "unknown", {"count": 0, "last": l.created_at, "ids": set()})
        r["count"] += 1
        r["last"] = max(r["last"], l.created_at)
        r["ids"].add(l.identifier)
    for ip, r in rows.items():
        if r["count"] >= 3:
            out.append({"severity": "Warning" if r["count"] < 10 else "High", "title": f"Brute Force suspected (IP: {ip})",
                        "detail": f"{r['count']} failed login attempts in 24h across {len(r['ids'])} identifier(s).", "at": r["last"].isoformat()})
    p = get_policy(company)
    for a in EmployeeAccount.objects.filter(employee__company=company, failed_login_attempts__gte=p.lockout_attempts, is_login_enabled=True):
        out.append({"severity": "Medium", "title": f"Lockout threshold reached ({a.employee.employee_code})",
                    "detail": f"{a.failed_login_attempts} consecutive failed attempts; run the lockout sweep to lock the account.", "at": a.updated_at.isoformat()})
    return sorted(out, key=lambda x: x["at"], reverse=True)


def lockout_sweep(company, actor):
    p = get_policy(company)
    if not p.lockout_enabled:
        return 0
    n = 0
    for a in EmployeeAccount.objects.filter(employee__company=company, is_login_enabled=True, failed_login_attempts__gte=p.lockout_attempts):
        a.is_login_enabled, a.updated_by = False, actor
        a.save()
        AdminAuditEvent.objects.create(company=company, actor=actor, actor_name="Security policy", action="LOCKED", module="Security",
                                       record_ref=a.employee.employee_code, new_value=f"Locked after {a.failed_login_attempts} failed attempts")
        n += 1
    return n


def security_scan(company):
    p, f = get_policy(company), []
    labels = {"mfa_required_admins": "MFA is not enforced for admins", "lockout_enabled": "Automatic lockout is disabled",
              "password_rotation_enabled": "Password rotation is disabled", "idle_timeout_enabled": "Idle session timeout is disabled",
              "ip_allowlist_enabled": "Admin IP allow-list is not enforced"}
    for k, t in labels.items():
        if not getattr(p, k):
            f.append({"severity": "High" if k in ("mfa_required_admins", "lockout_enabled") else "Medium", "title": t, "category": "policy"})
    stale = timezone.now() - timedelta(days=90)
    for a in EmployeeAccount.objects.filter(employee__company=company, employee__is_active=True, is_login_enabled=True):
        if a.last_login is None or a.last_login < stale:
            f.append({"severity": "Low", "title": f"Dormant login account {a.employee.employee_code}", "category": "accounts",
                      "detail": "No login in the last 90 days."})
    for t in threats(company):
        f.append({"severity": t["severity"], "title": t["title"], "category": "threats", "detail": t["detail"]})
    return {"score": posture_score(p), "findings": f, "scanned_at": timezone.now().isoformat()}


# ---------------- system health ----------------
def _probe(name, fn):
    t0 = time.time()
    try:
        status, detail = fn()
    except Exception as e:
        status, detail = "Down", str(e)[:120]
    return {"name": name, "status": status, "detail": detail, "latency_ms": round((time.time() - t0) * 1000, 1)}


def health(company):
    def db():
        with connection.cursor() as c:
            c.execute("SELECT 1")
            c.fetchone()
        return "Operational", f"{connection.vendor} reachable"

    def cache_():
        cache.set("admin_center_probe", "1", 5)
        return ("Operational", "read/write ok") if cache.get("admin_center_probe") == "1" else ("Degraded", "cache did not return value")

    def storage():
        os.makedirs(settings.MEDIA_ROOT, exist_ok=True)
        p = os.path.join(settings.MEDIA_ROOT, ".probe")
        open(p, "w").close()
        os.remove(p)
        return "Operational", "media directory writable"

    def sched():
        try:
            from Company.scheduler import _scheduler
            return ("Operational", "scheduler running") if _scheduler.running else ("Degraded", "scheduler not running in this process")
        except Exception:
            return "Degraded", "scheduler module unavailable"

    def smtp():
        return ("Operational", "SMTP host configured") if getattr(settings, "EMAIL_HOST", None) else ("Not Configured", "EMAIL_HOST not set")

    probes = [_probe("Database", db), _probe("Cache", cache_), _probe("File Storage", storage), _probe("Background Scheduler", sched),
              _probe("SMTP Relay", smtp), _probe("REST API", lambda: ("Operational", "serving this request"))]
    du = shutil.disk_usage(settings.MEDIA_ROOT if os.path.exists(settings.MEDIA_ROOT) else settings.BASE_DIR)
    res = {"storage_used_percent": round(du.used * 100 / du.total, 1), "storage_free_gb": round(du.free / 1024 ** 3, 1)}
    try:
        import psutil
        res["cpu_percent"] = psutil.cpu_percent(interval=0.1)
        res["memory_percent"] = psutil.virtual_memory().percent
    except Exception:
        try:
            res["cpu_percent"] = round(min(100, os.getloadavg()[0] * 100 / (os.cpu_count() or 1)), 1)
        except Exception:
            res["cpu_percent"] = None
        res["memory_percent"] = None
    failed = ScheduledJob.objects.filter(company=company, is_active=True, last_run_status="Failed").count()
    up = int(time.time() - STARTED)
    allgood = all(p["status"] in ("Operational", "Not Configured") for p in probes)
    return {"overall": "All Operational" if allgood else "Degraded", "database_latency_ms": probes[0]["latency_ms"],
            "application_uptime_seconds": up, "application_uptime_label": f"{up // 86400}d {up % 86400 // 3600}h {up % 3600 // 60}m",
            "background_jobs_failed": failed, "resources": res, "probes": probes, "checked_at": timezone.now().isoformat()}
