# ============================================================
# ADDITIVE: SuperAdmin staff accounts, roles, system status,
# database backups.
# ============================================================

import os
import re
import shutil
import sqlite3
import sys
from datetime import timedelta

import django
from django.conf import settings
from django.contrib import messages
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.core.mail import send_mail
from django.core.validators import validate_email
from django.db import connection, transaction
from django.db.migrations.executor import MigrationExecutor
from django.http import FileResponse, Http404
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone
from django.views.decorators.http import require_POST

from Company.models import AuthLog

from .company_mail import generate_temp_password
from .models import (
    StaffRole,
    StaffRoleAssignment,
    SuperAdminProfile,
)
from .platform_helpers import (
    actor_label,
    platform_permission_required,
    write_audit,
)
from .platform_permissions import (
    ALL_PERMISSION_CODES,
    PERMISSION_CHOICES,
    user_permissions,
)

BACKUP_DIR = os.path.join(settings.BASE_DIR, "private_media", "backups")
BACKUP_NAME_RE = re.compile(r"^db-\d{8}-\d{6}\.sqlite3$")


# ------------------------------------------------------------
# helpers
# ------------------------------------------------------------

def _grantable(request):
    """Permission codes the acting user may hand out (None = all)."""
    return user_permissions(request.user)


def _full_admins_excluding(profile):
    """Active unrestricted SuperAdmins other than `profile`."""
    return (
        SuperAdminProfile.objects.filter(is_active=True, staff_role__isnull=True)
        .exclude(pk=profile.pk)
        .count()
    )


def _email_credentials(profile, password, reset=False):
    try:
        send_mail(
            subject="Your SuperAdmin portal account" if not reset else "Your SuperAdmin password was reset",
            message=(
                f"Hello {profile.full_name},\n\n"
                f"Login email: {profile.email}\nTemporary password: {password}\n\n"
                "Please sign in and change your password immediately."
            ),
            from_email=getattr(settings, "DEFAULT_FROM_EMAIL", None),
            recipient_list=[profile.email],
            fail_silently=False,
        )
        return True
    except Exception:
        return False


# ------------------------------------------------------------
# STAFF
# ------------------------------------------------------------

@platform_permission_required("staff.manage")
def superadmin_staff(request):
    profiles = SuperAdminProfile.objects.select_related(
        "user", "staff_role", "staff_role__role"
    ).order_by("full_name")
    return render(request, "superadmin/staff.html", {
        "profiles": profiles,
        "me": request.superadmin_profile,
        "roles": StaffRole.objects.filter(is_active=True),
    })


@platform_permission_required("staff.manage")
def superadmin_staff_add(request):
    grantable = _grantable(request)
    roles = StaffRole.objects.filter(is_active=True)
    if grantable is not None:
        roles = [r for r in roles if set(r.permissions or []) <= grantable]
    ctx = {"roles": roles, "errors": [], "form": request.POST,
           "can_create_full": grantable is None}
    if request.method != "POST":
        return render(request, "superadmin/staff_form.html", ctx)

    f = request.POST
    errors = ctx["errors"]
    full_name = f.get("full_name", "").strip()
    email = f.get("email", "").strip().lower()
    phone = f.get("phone_number", "").strip()[:15]
    role_id = f.get("role", "")

    if not full_name:
        errors.append("Full name is required.")
    try:
        validate_email(email)
    except ValidationError:
        errors.append("Enter a valid email address.")
    role = None
    if role_id:
        role = next((r for r in roles if str(r.pk) == role_id), None)
        if role is None:
            errors.append("Select a valid role.")
    elif grantable is not None:
        errors.append("Select a role.")
    if not errors and (
        User.objects.filter(username__iexact=email).exists()
        or User.objects.filter(email__iexact=email).exists()
        or SuperAdminProfile.objects.filter(email__iexact=email).exists()
    ):
        errors.append("An account with this email already exists.")
    if errors:
        return render(request, "superadmin/staff_form.html", ctx, status=400)

    password = generate_temp_password(12)
    with transaction.atomic():
        user = User.objects.create_user(
            username=email, email=email, password=password,
            first_name=full_name[:150],
        )
        profile = SuperAdminProfile.objects.create(
            user=user, full_name=full_name, email=email,
            phone_number=phone or None, created_by=actor_label(request),
        )
        if role:
            StaffRoleAssignment.objects.create(
                profile=profile, role=role, created_by=actor_label(request)
            )
        write_audit(request, "CREATE_ADMIN", None,
                    f"Created staff account {email} ({role.name if role else 'Full SuperAdmin'})")
    if _email_credentials(profile, password):
        messages.success(request, f"Account created. Credentials emailed to {email}.")
    else:
        messages.warning(
            request,
            f"Account created but the email failed. Temporary password (shown once): {password}",
        )
    return redirect("superadmin_staff")


@require_POST
@platform_permission_required("staff.manage")
def superadmin_staff_action(request, pk):
    profile = get_object_or_404(SuperAdminProfile.objects.select_related("user"), pk=pk)
    me = request.superadmin_profile
    action = request.POST.get("action")
    grantable = _grantable(request)

    if profile.pk == me.pk and action in ("deactivate", "set_role"):
        messages.error(request, "You cannot change your own access.")
        return redirect("superadmin_staff")
    # restricted staff managers must not touch accounts stronger than themselves
    if grantable is not None:
        target_perms = user_permissions(profile.user)
        if target_perms is None or not target_perms <= grantable:
            messages.error(request, "You cannot manage an account with higher access than yours.")
            return redirect("superadmin_staff")

    if action == "deactivate":
        if (
            not hasattr(profile, "staff_role")
            and profile.is_active
            and _full_admins_excluding(profile) == 0
        ):
            messages.error(request, "At least one active full SuperAdmin must remain.")
        else:
            profile.is_active = False
            profile.updated_by = actor_label(request)
            profile.save(update_fields=["is_active", "updated_by"])
            profile.user.is_active = False
            profile.user.save(update_fields=["is_active"])
            write_audit(request, "UPDATE_ADMIN", None, f"Deactivated staff {profile.email}")
            messages.success(request, "Account deactivated.")
    elif action == "activate":
        profile.is_active = True
        profile.updated_by = actor_label(request)
        profile.save(update_fields=["is_active", "updated_by"])
        profile.user.is_active = True
        profile.user.save(update_fields=["is_active"])
        write_audit(request, "UPDATE_ADMIN", None, f"Activated staff {profile.email}")
        messages.success(request, "Account activated.")
    elif action == "reset_password":
        pw = generate_temp_password(12)
        profile.user.set_password(pw)
        profile.user.save(update_fields=["password"])
        write_audit(request, "UPDATE_ADMIN", None, f"Reset password of {profile.email}")
        if _email_credentials(profile, pw, reset=True):
            messages.success(request, "Password reset and emailed.")
        else:
            messages.warning(request, f"Password reset but email failed. Temporary password (shown once): {pw}")
    elif action == "set_role":
        role_id = request.POST.get("role", "")
        if role_id == "":
            if grantable is not None:
                messages.error(request, "Only a full SuperAdmin can grant full access.")
            else:
                StaffRoleAssignment.objects.filter(profile=profile).delete()
                write_audit(request, "UPDATE_ADMIN", None, f"{profile.email} -> Full SuperAdmin")
                messages.success(request, "Role cleared (full SuperAdmin).")
        else:
            role = StaffRole.objects.filter(pk=role_id, is_active=True).first()
            if not role:
                messages.error(request, "Invalid role.")
            elif grantable is not None and not set(role.permissions or []) <= grantable:
                messages.error(request, "You cannot grant permissions you do not have.")
            elif (
                not hasattr(profile, "staff_role") and _full_admins_excluding(profile) == 0
            ):
                messages.error(request, "At least one active full SuperAdmin must remain.")
            else:
                StaffRoleAssignment.objects.update_or_create(
                    profile=profile,
                    defaults={"role": role, "updated_by": actor_label(request)},
                )
                write_audit(request, "UPDATE_ADMIN", None, f"{profile.email} role -> {role.name}")
                messages.success(request, "Role updated.")
    else:
        messages.error(request, "Invalid action.")
    return redirect("superadmin_staff")


# ------------------------------------------------------------
# ROLES
# ------------------------------------------------------------

@platform_permission_required("staff.manage")
def superadmin_roles(request):
    roles = StaffRole.objects.prefetch_related("assignments").order_by("name")
    return render(request, "superadmin/roles.html", {"roles": roles})


@platform_permission_required("staff.manage")
def superadmin_role_form(request, pk=None):
    role = get_object_or_404(StaffRole, pk=pk) if pk else None
    grantable = _grantable(request)
    choices = [c for c in PERMISSION_CHOICES if grantable is None or c[0] in grantable]
    ctx = {"role": role, "choices": choices, "errors": [],
           "selected": set(role.permissions or []) if role else set()}
    if request.method != "POST":
        return render(request, "superadmin/role_form.html", ctx)

    name = request.POST.get("name", "").strip()
    desc = request.POST.get("description", "").strip()[:255]
    perms = [p for p in request.POST.getlist("permissions") if p in ALL_PERMISSION_CODES]
    ctx["selected"] = set(perms)
    errors = ctx["errors"]
    if not name or len(name) > 100:
        errors.append("Role name is required.")
    if grantable is not None:
        if not set(perms) <= grantable:
            errors.append("You cannot grant permissions you do not have.")
        if role and not set(role.permissions or []) <= grantable:
            errors.append("You cannot edit a role with more access than yours.")
        if role and role.assignments.filter(profile=request.superadmin_profile).exists():
            errors.append("You cannot edit your own role.")
    clash = StaffRole.objects.filter(name__iexact=name)
    if role:
        clash = clash.exclude(pk=role.pk)
    if clash.exists():
        errors.append("A role with this name already exists.")
    if errors:
        return render(request, "superadmin/role_form.html", ctx, status=400)

    if role is None:
        base = re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")[:30] or "role"
        code, n = base, 2
        while StaffRole.objects.filter(code=code).exists():
            code, n = f"{base}-{n}", n + 1
        role = StaffRole(code=code, created_by=actor_label(request))
        verb = "Created"
    else:
        verb = "Updated"
        role.updated_by = actor_label(request)
    role.name, role.description, role.permissions = name, desc, perms
    if role.pk:
        role.is_active = request.POST.get("is_active") == "on"
    role.save()
    write_audit(request, "CREATE_ROLE" if verb == "Created" else "UPDATE_ROLE", None,
                f"{verb} role {role.name}: {', '.join(perms)}")
    messages.success(request, f"Role {verb.lower()}.")
    return redirect("superadmin_roles")


# ------------------------------------------------------------
# SYSTEM STATUS + BACKUPS
# ------------------------------------------------------------

def _list_backups():
    if not os.path.isdir(BACKUP_DIR):
        return []
    out = []
    for name in sorted(os.listdir(BACKUP_DIR), reverse=True):
        if BACKUP_NAME_RE.match(name):
            p = os.path.join(BACKUP_DIR, name)
            out.append({"name": name, "size_mb": round(os.path.getsize(p) / 1048576, 2),
                        "modified": timezone.datetime.fromtimestamp(os.path.getmtime(p))})
    return out[:15]


@platform_permission_required("system.view")
def superadmin_system_status(request):
    checks = []

    def add(name, ok, detail, warn=False):
        checks.append({"name": name, "state": "warn" if (ok and warn) else ("ok" if ok else "fail"),
                       "detail": detail})

    t0 = timezone.now()
    try:
        with connection.cursor() as c:
            c.execute("SELECT 1")
            c.fetchone()
        ms = (timezone.now() - t0).total_seconds() * 1000
        add("Database", True, f"{connection.vendor} reachable ({ms:.1f} ms)")
    except Exception as exc:
        add("Database", False, str(exc))

    try:
        ex = MigrationExecutor(connection)
        pending = ex.migration_plan(ex.loader.graph.leaf_nodes())
        add("Migrations", not pending, "All applied" if not pending else f"{len(pending)} pending")
    except Exception as exc:
        add("Migrations", False, str(exc))

    usage = shutil.disk_usage(settings.BASE_DIR)
    free_pct = usage.free / usage.total * 100
    add("Disk space", free_pct > 10,
        f"{usage.free / 1073741824:.1f} GB free ({free_pct:.0f}%)", warn=free_pct < 20)

    for label, path in (("Media folder", settings.MEDIA_ROOT),
                        ("Private media folder", os.path.join(settings.BASE_DIR, "private_media"))):
        add(label, os.path.isdir(path) and os.access(path, os.W_OK),
            "Writable" if os.path.isdir(path) and os.access(path, os.W_OK) else f"Not writable: {path}")

    add("Debug mode", not settings.DEBUG,
        "Off" if not settings.DEBUG else "DEBUG=True - disable in production", warn=settings.DEBUG)
    add("Email backend", "console" not in settings.EMAIL_BACKEND.lower(),
        settings.EMAIL_BACKEND, warn="console" in settings.EMAIL_BACKEND.lower())

    since = timezone.now() - timedelta(hours=24)
    failed = AuthLog.objects.filter(status=AuthLog.STATUS_FAILED, created_at__gte=since).count()
    add("Failed logins (24h)", True, str(failed), warn=failed >= 20)

    return render(request, "superadmin/system_status.html", {
        "checks": checks,
        "backups": _list_backups(),
        "is_sqlite": connection.vendor == "sqlite",
        "versions": {"Django": django.get_version(), "Python": sys.version.split()[0]},
    })


@require_POST
@platform_permission_required("system.backup")
def superadmin_backup_create(request):
    if connection.vendor != "sqlite":
        messages.error(request, "Automatic backup supports SQLite only. Use mysqldump / pg_dump for this database.")
        return redirect("superadmin_system_status")
    os.makedirs(BACKUP_DIR, exist_ok=True)
    name = "db-%s.sqlite3" % timezone.now().strftime("%Y%m%d-%H%M%S")
    dest = os.path.join(BACKUP_DIR, name)
    src = sqlite3.connect(str(settings.DATABASES["default"]["NAME"]))
    dst = sqlite3.connect(dest)
    try:
        src.backup(dst)
    finally:
        dst.close()
        src.close()
    write_audit(request, "OTHER", None, f"Created database backup {name}")
    messages.success(request, f"Backup created: {name}")
    return redirect("superadmin_system_status")


@platform_permission_required("system.backup")
def superadmin_backup_download(request, name):
    if not BACKUP_NAME_RE.match(name):
        raise Http404
    path = os.path.join(BACKUP_DIR, name)
    if not os.path.isfile(path):
        raise Http404
    write_audit(request, "OTHER", None, f"Downloaded database backup {name}")
    return FileResponse(open(path, "rb"), as_attachment=True, filename=name)
