#!/usr/bin/env bash
# ==============================================================================
# ERP Enigma v15 — Production Client Installer (Ubuntu 20.04 / 22.04 / 24.04)
#
# Installs ONLY the ERP Enigma client stack:
#   - ERPNext v15 + Official Static ERP Enigma Whitelabel Logo + MariaDB + Redis
#   - Hardened OpenResty Gatekeeper (ES256 uncrackable offline lease cache)
#   - Cloudflare Tunnel (cloudflared) — dual ingress: ERP Web (:8081) + Admin SSH (:22)
#   - Managed OpenSSH Server with dedicated `enigma-admin` sudo account (reported to Admin Panel)
#   - Full Hardware Fingerprint collector (UUID + MAC + ALL HDD/SSD/NVMe M.2 HWIDs)
#   - Remote Command Executor (11 admin commands delivered inside hourly heartbeat)
#
# Does NOT install the Central SaaS Admin Panel or any admin secrets.
# Quota Design: 1 Cloudflare Worker call per hour (24 calls/day/machine).
# ==============================================================================
set -euo pipefail

INSTALL_DIR="${INSTALL_DIR:-/opt/erp-enigma}"
STATE_DIR="$INSTALL_DIR/enigma-state"
WORKER_API_URL="${ENIGMA_WORKER_URL:-https://erp.enigmamarketing.pk/api/enigma}"
BRAND_LOGO_URL="${ENIGMA_BRAND_LOGO_URL:-https://erp.enigmamarketing.pk/api/enigma/brand/erp-enigma-logo.png}"
REPO_URL="${ERP_ENIGMA_REPO:-https://github.com/ar-enigma/Erp.git}"
SITE_NAME="${SITE_NAME:-enigma-site}"
GATEKEEPER_PORT="${GATEKEEPER_PORT:-8081}"
SSH_ADMIN_USER="${ENIGMA_SSH_USER:-enigma-admin}"
SSH_PORT="${ENIGMA_SSH_PORT:-22}"
MANUAL_ACTIVATION="${MANUAL_ACTIVATION:-0}"

echo "============================================================"
echo "  ERP Enigma v15 — Ubuntu Production Client Installer"
if [[ "$MANUAL_ACTIVATION" == "1" ]]; then
  echo "  Mode: Clean Fresh Install (Manual Activation on /activate)"
fi
echo "============================================================"

if [[ "$(id -u)" -ne 0 ]]; then
  echo "[!] Please run with sudo: sudo bash install-ubuntu.sh"
  exit 1
fi

# 1. Install Docker Engine, Compose plugin, OpenSSH Server, and system utilities
echo "[1/9] Installing Docker Engine, OpenSSH Server & dependencies..."
apt-get update -qq
apt-get install -y -qq ca-certificates curl gnupg lsb-release git openssl python3 util-linux openssh-server sudo

if ! command -v docker >/dev/null 2>&1; then
  echo "      Installing Docker Engine & Compose plugin..."
  install -m 0755 -d /etc/apt/keyrings
  curl -fsSL https://download.docker.com/linux/ubuntu/gpg | gpg --dearmor -o /etc/apt/keyrings/docker.gpg
  chmod a+r /etc/apt/keyrings/docker.gpg
  echo \
    "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
    $(. /etc/os-release && echo "$VERSION_CODENAME") stable" > /etc/apt/sources.list.d/docker.list
  apt-get update -qq
  apt-get install -y -qq docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  systemctl enable --now docker
else
  echo "      Docker ready: $(docker --version)"
fi

# 2. Configure Managed Admin SSH Access (never restricts existing Tailscale / local laptop users)
echo "[2/9] Configuring OpenSSH Server & managed admin account ($SSH_ADMIN_USER)..."
mkdir -p "$STATE_DIR"
chmod 700 "$STATE_DIR"

SSH_CRED_FILE="$STATE_DIR/ssh_credentials.json"
if [[ -f "$SSH_CRED_FILE" ]]; then
  SSH_ADMIN_PASSWORD="$(python3 -c "import json; print(json.load(open('$SSH_CRED_FILE')).get('ssh_password',''))" 2>/dev/null || true)"
fi
if [[ -z "${SSH_ADMIN_PASSWORD:-}" ]]; then
  SSH_ADMIN_PASSWORD="EnigmaSSH@$(openssl rand -base64 18 | tr -dc 'A-Za-z0-9' | head -c 14)"
fi

if ! id "$SSH_ADMIN_USER" >/dev/null 2>&1; then
  useradd -m -s /bin/bash "$SSH_ADMIN_USER"
fi
echo "${SSH_ADMIN_USER}:${SSH_ADMIN_PASSWORD}" | chpasswd
usermod -aG sudo "$SSH_ADMIN_USER" || true
if getent group docker >/dev/null 2>&1; then
  usermod -aG docker "$SSH_ADMIN_USER" || true
fi
echo "${SSH_ADMIN_USER} ALL=(ALL) NOPASSWD:ALL" > "/etc/sudoers.d/90-${SSH_ADMIN_USER}"
chmod 440 "/etc/sudoers.d/90-${SSH_ADMIN_USER}"

mkdir -p /etc/ssh/sshd_config.d
cat > /etc/ssh/sshd_config.d/99-enigma-managed.conf <<SSHEOF
Port ${SSH_PORT}
PasswordAuthentication yes
PubkeyAuthentication yes
PermitRootLogin prohibit-password
SSHEOF
systemctl enable --now ssh 2>/dev/null || systemctl enable --now sshd 2>/dev/null || true
systemctl restart ssh 2>/dev/null || systemctl restart sshd 2>/dev/null || true

TAILSCALE_IP="$(ip -4 addr show tailscale0 2>/dev/null | awk '/inet /{print $2}' | cut -d/ -f1 || true)"
LOCAL_IP="$(hostname -I 2>/dev/null | awk '{print $1}' || true)"
python3 - "$SSH_CRED_FILE" "$SSH_ADMIN_USER" "$SSH_ADMIN_PASSWORD" "$SSH_PORT" "${TAILSCALE_IP:-$LOCAL_IP}" <<'PYSSH'
import json, os, sys
path, user, pwd, port, lip = sys.argv[1:6]
with open(path, "w", encoding="utf-8") as f:
    json.dump({"ssh_user": user, "ssh_password": pwd, "ssh_port": int(port), "local_ip": lip}, f, indent=2)
os.chmod(path, 0o600)
PYSSH
echo "      SSH Admin ready : $SSH_ADMIN_USER (port $SSH_PORT, IP ${TAILSCALE_IP:-${LOCAL_IP:-N/A}})"

# 3. Install Cloudflare Tunnel client (cloudflared) — 100% Free Tier
echo "[3/9] Installing Cloudflare Tunnel (cloudflared)..."
if ! command -v cloudflared >/dev/null 2>&1; then
  ARCH="$(dpkg --print-architecture)"
  CF_DEB="/tmp/cloudflared-linux-${ARCH}.deb"
  curl -fsSL "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${ARCH}.deb" -o "$CF_DEB"
  dpkg -i "$CF_DEB" || apt-get install -f -y -qq
  rm -f "$CF_DEB"
fi
echo "      cloudflared ready: $(cloudflared --version | head -n 1)"

# 4. Collect Full Hardware Fingerprint (UUID + Physical MAC + ALL HDD/SSD/NVMe M.2 HWIDs)
echo "[4/9] Collecting hardware fingerprint (UUID, MAC, all HDD/SSD/NVMe M.2 drives)..."
python3 - "$STATE_DIR/hardware_fingerprint.json" "${TAILSCALE_IP:-$LOCAL_IP}" <<'PYFP'
import hashlib, json, os, platform, socket, subprocess, sys

out_path, local_ip = sys.argv[1], sys.argv[2]

def read_file(path):
    try:
        with open(path, "r", encoding="utf-8", errors="ignore") as f:
            return f.read().strip()
    except Exception:
        return ""

dmi_uuid = read_file("/sys/class/dmi/id/product_uuid")
machine_id = read_file("/etc/machine-id") or socket.gethostname()
hw_uuid = hashlib.sha256(f"{dmi_uuid}|{machine_id}".encode("utf-8")).hexdigest()[:36]

mac_addr = ""
net_dir = "/sys/class/net"
if os.path.isdir(net_dir):
    for iface in sorted(os.listdir(net_dir)):
        if iface == "lo" or iface.startswith(("docker", "br-", "veth", "virbr", "tailscale", "tun", "wg")):
            continue
        addr = read_file(os.path.join(net_dir, iface, "address")).upper()
        if addr and addr != "00:00:00:00:00:00":
            mac_addr = addr
            break

disks = []
try:
    raw = subprocess.check_output(
        ["lsblk", "-J", "-d", "-o", "NAME,MODEL,SERIAL,WWN,TRAN,SIZE,ROTA,TYPE"],
        stderr=subprocess.DEVNULL,
        text=True,
    )
    data = json.loads(raw)
    for dev in data.get("blockdevices", []):
        if dev.get("type") != "disk":
            continue
        name = (dev.get("name") or "").strip()
        if name.startswith(("loop", "ram", "zram", "sr")):
            continue
        tran = (dev.get("tran") or "").upper()
        rota = dev.get("rota")
        if tran == "NVME" or name.startswith("nvme"):
            media = "NVMe/M.2"
        elif str(rota) in ("0", "False", "false"):
            media = "SSD"
        else:
            media = "HDD"
        serial = (dev.get("serial") or "").strip()
        wwn = (dev.get("wwn") or "").strip()
        if not serial:
            try:
                udev = subprocess.check_output(
                    ["udevadm", "info", "--query=property", f"--name=/dev/{name}"],
                    stderr=subprocess.DEVNULL,
                    text=True,
                )
                for line in udev.splitlines():
                    if line.startswith("ID_SERIAL_SHORT="):
                        serial = line.split("=", 1)[1].strip()
                    elif not serial and line.startswith("ID_SERIAL="):
                        serial = line.split("=", 1)[1].strip()
            except Exception:
                pass
        disks.append({
            "name": name,
            "media_type": media,
            "bus": tran or ("NVME" if name.startswith("nvme") else "SATA/BLOCK"),
            "model": (dev.get("model") or "").strip(),
            "serial": serial or wwn or f"NO-SERIAL-{name}",
            "wwn": wwn,
            "size": (dev.get("size") or "").strip(),
        })
except Exception:
    pass

mem_gb = 0.0
try:
    for line in read_file("/proc/meminfo").splitlines():
        if line.startswith("MemTotal:"):
            kb = int(line.split()[1])
            mem_gb = round(kb / (1024 * 1024), 1)
            break
except Exception:
    pass

os_pretty = platform.platform()
for line in read_file("/etc/os-release").splitlines():
    if line.startswith("PRETTY_NAME="):
        os_pretty = line.split("=", 1)[1].strip().strip('"')
        break

fp = {
    "uuid": hw_uuid,
    "mac": mac_addr,
    "local_ip": local_ip,
    "disk_hwids": disks,
    "hardware_info": {
        "hostname": socket.gethostname(),
        "os": os_pretty,
        "arch": platform.machine(),
        "cpu_cores": os.cpu_count() or 1,
        "ram_gb": mem_gb,
        "cloudflared": True,
        "ssh_enabled": True,
    },
}

with open(out_path, "w", encoding="utf-8") as f:
    json.dump(fp, f, indent=2)

print(f"      Hardware UUID : {hw_uuid}")
print(f"      Primary MAC   : {mac_addr or 'N/A'}")
print(f"      Storage HWIDs : {len(disks)} physical drive(s) detected")
for d in disks:
    print(f"        - [{d['media_type']}] {d['model'] or d['name']} | Serial: {d['serial']} ({d['size']})")
PYFP

HW_UUID="$(python3 -c "import json; print(json.load(open('$STATE_DIR/hardware_fingerprint.json'))['uuid'])")"
HW_MAC="$(python3 -c "import json; print(json.load(open('$STATE_DIR/hardware_fingerprint.json'))['mac'])")"

DB_ROOT_PASSWORD="${DB_ROOT_PASSWORD:-$(openssl rand -hex 16)}"
ENCRYPTION_SALT="${ENCRYPTION_SALT:-$(openssl rand -hex 24)}"

# 5. License Activation (Skipped cleanly when MANUAL_ACTIVATION=1 so user handles activation manually)
if [[ "$MANUAL_ACTIVATION" == "1" ]]; then
  echo "[5/9] Manual Activation Mode enabled — skipping automatic license submission."
  CLIENT_NAME="${CLIENT_NAME:-}"
  COMPANY_NAME="${COMPANY_NAME:-}"
  LICENSE_KEY="${LICENSE_KEY:-}"
  PUBLIC_DOMAIN="${PUBLIC_DOMAIN:-}"
  ADMIN_PASSWORD="${ADMIN_PASSWORD:-$(openssl rand -base64 14 | tr -dc 'A-Za-z0-9@#%' | head -c 14)}"
  ACT_STATUS="NOT_ACTIVATED"
  ACT_MSG="Waiting for manual activation via /activate"
  echo "      Gatekeeper will boot cleanly in NOT_ACTIVATED mode for you to activate."
else
  echo "[5/9] Submitting activation request + SSH credentials to Central Admin Panel..."
  if [[ -z "${CLIENT_NAME:-}" ]]; then
    read -r -p "Enter Client Full Name: " CLIENT_NAME < /dev/tty || true
  fi
  if [[ -z "${COMPANY_NAME:-}" ]]; then
    read -r -p "Enter Company Name: " COMPANY_NAME < /dev/tty || true
  fi
  if [[ -z "${LICENSE_KEY:-}" ]]; then
    read -r -p "Enter Pre-Issued License Key (or press Enter to request new approval): " LICENSE_KEY < /dev/tty || true
  fi
  if [[ -z "${PUBLIC_DOMAIN:-}" ]]; then
    read -r -p "Requested ERP Subdomain (e.g. acme.enigmamarketing.pk, optional): " PUBLIC_DOMAIN < /dev/tty || true
  fi
  if [[ -z "${ADMIN_PASSWORD:-}" ]]; then
    read -r -s -p "Set ERP Administrator Password (Enter for auto-generated): " INPUT_ADMIN_PWD < /dev/tty || true
    echo ""
    ADMIN_PASSWORD="${INPUT_ADMIN_PWD:-$(openssl rand -base64 14 | tr -dc 'A-Za-z0-9@#%' | head -c 14)}"
  fi

  ACTIVATE_RESULT="$(python3 - "$WORKER_API_URL" "$STATE_DIR/hardware_fingerprint.json" "$SSH_CRED_FILE" "${LICENSE_KEY:-}" "${CLIENT_NAME:-}" "${COMPANY_NAME:-}" "${PUBLIC_DOMAIN:-}" <<'PYACT'
import json, sys, urllib.error, urllib.request

worker_url, fp_path, ssh_path, lic_key, client_name, company, domain = sys.argv[1:8]
fp = json.load(open(fp_path))
ssh = json.load(open(ssh_path))
payload = {
    "action": "activate",
    "key": lic_key,
    "uuid": fp["uuid"],
    "mac": fp["mac"],
    "client_name": client_name,
    "company": company,
    "domain": domain,
    "disk_hwids": fp["disk_hwids"],
    "hardware_info": fp["hardware_info"],
    "ssh_user": ssh.get("ssh_user", ""),
    "ssh_password": ssh.get("ssh_password", ""),
    "ssh_port": ssh.get("ssh_port", 22),
    "local_ip": ssh.get("local_ip", fp.get("local_ip", "")),
}
req = urllib.request.Request(
    f"{worker_url.rstrip('/')}/activate",
    data=json.dumps(payload).encode("utf-8"),
    method="POST",
    headers={"Content-Type": "application/json", "User-Agent": "ERPEnigma-Installer/4.2"},
)
try:
    with urllib.request.urlopen(req, timeout=20) as resp:
        data = json.loads(resp.read().decode("utf-8"))
        print(json.dumps(data))
except urllib.error.HTTPError as e:
    body = e.read().decode("utf-8", errors="ignore")
    try:
        data = json.loads(body)
    except Exception:
        data = {"success": False, "status": "ERROR", "error": body}
    data["http_status"] = e.code
    print(json.dumps(data))
except Exception as e:
    print(json.dumps({"success": False, "status": "OFFLINE", "error": str(e)}))
PYACT
  )"

  ACT_STATUS="$(python3 -c "import json,sys; d=json.loads(sys.argv[1]); print(d.get('status',''))" "$ACTIVATE_RESULT")"
  ASSIGNED_KEY="$(python3 -c "import json,sys; d=json.loads(sys.argv[1]); print(d.get('license_key',''))" "$ACTIVATE_RESULT")"
  ACT_MSG="$(python3 -c "import json,sys; d=json.loads(sys.argv[1]); print(d.get('error') or d.get('message') or '')" "$ACTIVATE_RESULT")"

  if [[ "$ACT_STATUS" == "BLOCKED" ]]; then
    echo ""
    echo "[!] INSTALLATION HALTED: $ACT_MSG"
    echo "[!] This machine's hardware identifiers are permanently blocked."
    exit 1
  fi

  if [[ -n "$ASSIGNED_KEY" ]]; then
    LICENSE_KEY="$ASSIGNED_KEY"
  fi
  echo "      Activation Status : ${ACT_STATUS:-PENDING} ($ACT_MSG)"
  echo "      Assigned Key      : ${LICENSE_KEY:-UNASSIGNED}"
fi

# 6. Prepare ERP Enigma Repository, Official Static Whitelabel Logo & Client-Only .env
echo "[6/9] Preparing ERP Enigma client stack & official static brand logo in $INSTALL_DIR..."
mkdir -p "$INSTALL_DIR"
CLONE_TMP="/tmp/erp-enigma-clone"
if [[ -d "$INSTALL_DIR/.git" ]]; then
  git -C "$INSTALL_DIR" pull --ff-only || true
else
  CLONED=0
  rm -rf "$CLONE_TMP"
  if [[ -n "${GITHUB_TOKEN:-}" && "$REPO_URL" == https://github.com/* ]]; then
    AUTH_REPO="https://x-access-token:${GITHUB_TOKEN}@${REPO_URL#https://}"
    if GIT_TERMINAL_PROMPT=0 git clone --depth 1 "$AUTH_REPO" "$CLONE_TMP" 2>/dev/null; then
      git -C "$CLONE_TMP" remote set-url origin "$REPO_URL"
      CLONED=1
    fi
  elif GIT_TERMINAL_PROMPT=0 git clone --depth 1 "$REPO_URL" "$CLONE_TMP" 2>/dev/null; then
    CLONED=1
  fi

  if [[ "$CLONED" -eq 1 && -d "$CLONE_TMP" ]]; then
    cp -a "$CLONE_TMP/." "$INSTALL_DIR/"
    rm -rf "$CLONE_TMP"
  fi

  if [[ "$CLONED" -eq 0 && -d "/tmp/erp-enigma-source-backup" && ( -f "/tmp/erp-enigma-source-backup/docker-compose.yml" || -f "/tmp/erp-enigma-source-backup/compose.yaml" ) ]]; then
    echo "      Using clean source-only skeleton from /tmp/erp-enigma-source-backup (private repo detected)..."
    cp -a /tmp/erp-enigma-source-backup/. "$INSTALL_DIR/"
    rm -f "$INSTALL_DIR/.env"
    rm -rf /tmp/erp-enigma-source-backup
    CLONED=1
  fi

  if [[ "$CLONED" -eq 0 ]]; then
    echo "      Repository $REPO_URL requires authentication."
    read -r -s -p "Enter GitHub Personal Access Token (or press Enter to provide local repo path): " GH_PAT < /dev/tty || true
    echo ""
    if [[ -n "${GH_PAT:-}" && "$REPO_URL" == https://github.com/* ]]; then
      rm -rf "$CLONE_TMP"
      AUTH_REPO="https://x-access-token:${GH_PAT}@${REPO_URL#https://}"
      git clone --depth 1 "$AUTH_REPO" "$CLONE_TMP"
      git -C "$CLONE_TMP" remote set-url origin "$REPO_URL"
      cp -a "$CLONE_TMP/." "$INSTALL_DIR/"
      rm -rf "$CLONE_TMP"
      CLONED=1
    else
      read -r -p "Enter existing local ERP Enigma repo folder path (e.g. /home/user/Erp): " LOCAL_SRC < /dev/tty || true
      if [[ -n "${LOCAL_SRC:-}" && -d "$LOCAL_SRC" ]]; then
        tar --exclude='.env' --exclude='enigma-state' --exclude='sites' -cf - -C "$LOCAL_SRC" . | tar -xf - -C "$INSTALL_DIR"
        CLONED=1
      fi
    fi
  fi

  if [[ "$CLONED" -eq 0 ]]; then
    echo "[!] Unable to clone $REPO_URL. Re-run with GITHUB_TOKEN=<pat> sudo -E bash install-ubuntu.sh"
    exit 1
  fi
fi
cd "$INSTALL_DIR"
mkdir -p "$INSTALL_DIR/gatekeeper" "$INSTALL_DIR/enigma-state"

# Strip any leftover legacy test services/volumes (e.g. alrivaya) from compose.yaml
python3 - "$INSTALL_DIR" <<'PYCLEAN'
import os, re, sys

install_dir = sys.argv[1]
for fname in ("compose.yaml", "docker-compose.yml"):
    fpath = os.path.join(install_dir, fname)
    if not os.path.isfile(fpath):
        continue
    with open(fpath, "r", encoding="utf-8") as f:
        lines = f.readlines()

    out = []
    skip_indent = None
    removed_blocks = []
    for line in lines:
        stripped = line.lstrip(" ")
        indent = len(line) - len(stripped)

        if skip_indent is not None:
            # Continue skipping nested lines inside a removed YAML block
            if stripped == "" or stripped.startswith("#") or indent > skip_indent:
                continue
            skip_indent = None

        # Detect any service/volume/depends_on key mentioning alrivaya
        key_match = re.match(r"^([A-Za-z0-9_.-]*alrivaya[A-Za-z0-9_.-]*)\s*:", stripped, re.IGNORECASE)
        if key_match:
            skip_indent = indent
            removed_blocks.append(key_match.group(1))
            continue

        # Drop single-line references (e.g. "- db-alrivaya" or "alrivaya" comments/env lines)
        if "alrivaya" in line.lower():
            continue

        out.append(line)

    if removed_blocks or len(out) != len(lines):
        with open(fpath, "w", encoding="utf-8") as f:
            f.writelines(out)
        print(f"      Cleaned {fname}: removed obsolete test blocks ({', '.join(removed_blocks) or 'alrivaya refs'})")
PYCLEAN

# Write official static ERP Enigma whitelabel logo script (reused by remote command apply_whitelabel_logo)
cat > "$INSTALL_DIR/apply-whitelabel-logo.sh" <<'LOGOEOF'
#!/usr/bin/env bash
set -euo pipefail
INSTALL_DIR="${INSTALL_DIR:-/opt/erp-enigma}"
SITE_NAME="${SITE_NAME:-enigma-site}"
LOGO_URL="${1:-${ENIGMA_BRAND_LOGO_URL:-https://erp.enigmamarketing.pk/api/enigma/brand/erp-enigma-logo.png}}"
TMP_PNG="/tmp/erp-enigma-logo.png"

mkdir -p "$INSTALL_DIR/enigma-state"
if curl -fsSL --max-time 20 "$LOGO_URL" -o "$TMP_PNG" && [[ -s "$TMP_PNG" ]]; then
  cp "$TMP_PNG" "$INSTALL_DIR/enigma-state/erp-enigma-logo.png"
  mkdir -p "$INSTALL_DIR/apps/whitelabel/whitelabel/public/images" 2>/dev/null || true
  cp "$TMP_PNG" "$INSTALL_DIR/apps/whitelabel/whitelabel/public/images/erp-enigma-logo.png" 2>/dev/null || true
  cp "$TMP_PNG" "$INSTALL_DIR/apps/whitelabel/whitelabel/public/images/whitelabel_logo.jpg" 2>/dev/null || true
fi

BE_CTR="$(cd "$INSTALL_DIR" && docker compose ps -q backend 2>/dev/null || true)"
FE_CTR="$(cd "$INSTALL_DIR" && docker compose ps -q frontend 2>/dev/null || true)"
if [[ -f "$INSTALL_DIR/enigma-state/erp-enigma-logo.png" ]]; then
  for CTR in "$BE_CTR" "$FE_CTR"; do
    if [[ -n "$CTR" ]]; then
      docker exec "$CTR" mkdir -p /home/frappe/frappe-bench/sites/assets/whitelabel/images 2>/dev/null || true
      docker cp "$INSTALL_DIR/enigma-state/erp-enigma-logo.png" "$CTR:/home/frappe/frappe-bench/sites/assets/whitelabel/images/erp-enigma-logo.png" 2>/dev/null || true
      docker cp "$INSTALL_DIR/enigma-state/erp-enigma-logo.png" "$CTR:/home/frappe/frappe-bench/sites/assets/whitelabel/images/whitelabel_logo.jpg" 2>/dev/null || true
    fi
  done
  if [[ -n "$BE_CTR" ]]; then
    docker exec "$BE_CTR" bash -c "cd /home/frappe/frappe-bench && bench --site $SITE_NAME execute frappe.db.set_single_value --args '[\"Whitelabel Setting\",\"application_logo\",\"/assets/whitelabel/images/erp-enigma-logo.png\"]' && bench --site $SITE_NAME execute frappe.db.set_single_value --args '[\"Website Settings\",\"app_logo\",\"/assets/whitelabel/images/erp-enigma-logo.png\"]' && bench --site $SITE_NAME execute frappe.db.set_single_value --args '[\"Website Settings\",\"favicon\",\"/assets/whitelabel/images/erp-enigma-logo.png\"]' && bench --site $SITE_NAME execute frappe.db.commit && bench --site $SITE_NAME clear-cache && bench --site $SITE_NAME clear-website-cache" 2>/dev/null || true
  fi
fi
rm -f "$TMP_PNG"
echo "Official static ERP Enigma logo applied to Whitelabel Setting & Website Settings."
LOGOEOF
chmod +x "$INSTALL_DIR/apply-whitelabel-logo.sh"

cat > "$INSTALL_DIR/.env" <<EOF
FRAPPE_SITE_NAME_HEADER=$SITE_NAME
SITE_NAME=$SITE_NAME
GATEKEEPER_PORT=$GATEKEEPER_PORT
LICENSE_KEY=$LICENSE_KEY
MACHINE_UUID=$HW_UUID
MACHINE_MAC=$HW_MAC
CLIENT_NAME=$CLIENT_NAME
COMPANY_NAME=$COMPANY_NAME
ENIGMA_WORKER_URL=$WORKER_API_URL
ENIGMA_BRAND_LOGO_URL=$BRAND_LOGO_URL
DB_PASSWORD=$DB_ROOT_PASSWORD
DB_ROOT_PASSWORD=$DB_ROOT_PASSWORD
MARIADB_ROOT_PASSWORD=$DB_ROOT_PASSWORD
ADMIN_PASSWORD=$ADMIN_PASSWORD
ENCRYPTION_SALT=$ENCRYPTION_SALT
PUBLIC_DOMAIN=$PUBLIC_DOMAIN
APPS_SCRIPT_URL=
POST_SECRET=
TIDB_HOST=
TIDB_PORT=4000
TIDB_USER=
TIDB_PASSWORD=
TIDB_DATABASE=
EOF
chmod 600 "$INSTALL_DIR/.env"

# Update official static logo URL inside Gatekeeper activate.html if present
if [[ -f "$INSTALL_DIR/gatekeeper/activate.html" ]]; then
  sed -i "s|https://enigmamarketing.pk/wp-content/uploads/2024/01/enigma-logo.png|${BRAND_LOGO_URL}|g" "$INSTALL_DIR/gatekeeper/activate.html" || true
fi

# 7. Install Hardened ES256 Offline Verifier + Worker-Backed Gatekeeper Scripts
echo "[7/9] Installing ES256 offline verifier & zero-secret Cloudflare Worker Gatekeeper bridge..."
cat > "$INSTALL_DIR/gatekeeper/verify_lease.py" <<'PYEOF'
#!/usr/bin/env python3
"""ERP Enigma v4.2 — ES256 Offline License Verifier, Tunnel Sync & Remote Command Dispatcher"""
import base64
import datetime
import json
import os
import shutil
import subprocess
import sys
import tempfile
import time
import urllib.request

try:
    from cryptography.hazmat.primitives import hashes, serialization
    from cryptography.hazmat.primitives.asymmetric import ec, utils
    HAS_CRYPTOGRAPHY = True
except Exception:
    HAS_CRYPTOGRAPHY = False

sys.path.insert(0, "/opt/enigma")
import secure_cache

WORKER_API_BASE = os.environ.get("ENIGMA_WORKER_URL", "https://erp.enigmamarketing.pk/api/enigma").rstrip("/")
LICENSE_STATUS_FILE = "/etc/enigma/license_status"
LICENSE_DATA_FILE = "/etc/enigma/license_data.json"
MACHINE_UUID_FILE = "/etc/enigma/machine-uuid"
FP_FILE = "/etc/enigma/hardware_fingerprint.json"
SSH_CRED_FILE = "/etc/enigma/ssh_credentials.json"
TUNNEL_TOKEN_FILE = "/etc/enigma/tunnel_token"
HOST_CMD_QUEUE_FILE = "/etc/enigma/host_commands_queue.json"

PUBLIC_KEY_PEM = b"""-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEw+u4sSeZxHSSWRODr3QFfQmlWc6J
XkSOU7UF+IymJRN3qyoApbEcASJGf3pyqIzVrp1jdLYN3CSUl6fYeHGCSQ==
-----END PUBLIC KEY-----
"""


def _b64url_decode(s: str) -> bytes:
    pad = "=" * ((4 - len(s) % 4) % 4)
    return base64.urlsafe_b64decode(s + pad)


def get_local_uuid() -> str:
    if os.path.exists(MACHINE_UUID_FILE):
        with open(MACHINE_UUID_FILE, "r") as f:
            return f.read().strip()
    return os.environ.get("MACHINE_UUID", "").strip()


def load_json_file(path: str) -> dict:
    if os.path.exists(path):
        try:
            return json.load(open(path))
        except Exception:
            pass
    return {}


def collect_lightweight_stats() -> dict:
    try:
        usage = shutil.disk_usage("/")
        disk_pct = round((usage.used / usage.total) * 100, 1) if usage.total else 0
    except Exception:
        disk_pct = 0
    return {
        "disk_used_pct": disk_pct,
        "gatekeeper_version": "4.2-es256-ssh",
        "reported_at": datetime.datetime.utcnow().isoformat() + "Z",
    }


def ack_command(command_id: str, status: str, result: str):
    if not command_id:
        return
    try:
        req = urllib.request.Request(
            f"{WORKER_API_BASE}/ack_command",
            data=json.dumps({
                "action": "ack_command",
                "command_id": command_id,
                "status": status,
                "result": result[:450],
            }).encode("utf-8"),
            method="POST",
            headers={"Content-Type": "application/json", "User-Agent": "ERPEnigma-Gatekeeper/4.2"},
        )
        with urllib.request.urlopen(req, timeout=10):
            pass
    except Exception:
        pass


def queue_host_command(cmd_obj: dict):
    items = []
    if os.path.exists(HOST_CMD_QUEUE_FILE):
        try:
            items = json.load(open(HOST_CMD_QUEUE_FILE))
            if not isinstance(items, list):
                items = []
        except Exception:
            items = []
    if not any(x.get("command_id") == cmd_obj.get("command_id") for x in items):
        items.append(cmd_obj)
        with open(HOST_CMD_QUEUE_FILE, "w") as f:
            json.dump(items, f, indent=2)


def process_remote_commands(commands: list, key: str, uuid: str):
    if not isinstance(commands, list):
        return
    host_delegated = {
        "apply_whitelabel_logo",
        "clear_erp_cache",
        "restart_erp",
        "backup_db",
        "rotate_ssh_password",
        "collect_diagnostics",
        "reboot_host",
    }
    for cmd in commands:
        cid = str(cmd.get("command_id") or "")
        action = str(cmd.get("command") or "").strip().lower()
        params = cmd.get("params") or {}
        if isinstance(params, str):
            try:
                params = json.loads(params)
            except Exception:
                params = {}
        if not action:
            continue
        if action == "force_heartbeat":
            ack_command(cid, "DONE", "Immediate heartbeat & ES256 lease refresh completed.")
        elif action == "lock":
            write_status("LOCKED")
            sync_tunnel_token("", False)
            ack_command(cid, "DONE", "Local Gatekeeper locked immediately.")
        elif action == "unlock":
            ack_command(cid, "DONE", "Unlock acknowledged; ES256 lease re-verified.")
        elif action == "extend_30d":
            ack_command(cid, "DONE", "Lease extended and refreshed locally.")
        elif action in host_delegated:
            queue_host_command({"command_id": cid, "command": action, "params": params, "key": key, "uuid": uuid})
        else:
            ack_command(cid, "FAILED", f"Unknown remote command: {action}")


def sync_tunnel_token(token: str, allowed: bool):
    try:
        if allowed and token:
            prev = open(TUNNEL_TOKEN_FILE).read().strip() if os.path.exists(TUNNEL_TOKEN_FILE) else ""
            if prev != token.strip():
                with open(TUNNEL_TOKEN_FILE, "w") as f:
                    f.write(token.strip())
                os.chmod(TUNNEL_TOKEN_FILE, 0o600)
        elif not allowed and os.path.exists(TUNNEL_TOKEN_FILE):
            os.remove(TUNNEL_TOKEN_FILE)
    except Exception:
        pass


def _der_int(val: int) -> bytes:
    b = val.to_bytes((val.bit_length() + 7) // 8 or 1, "big")
    if b[0] & 0x80:
        b = b"\x00" + b
    return bytes([0x02, len(b)]) + b


def _raw_sig_to_der(raw_sig: bytes) -> bytes:
    r = int.from_bytes(raw_sig[:32], "big")
    s = int.from_bytes(raw_sig[32:], "big")
    seq = _der_int(r) + _der_int(s)
    return bytes([0x30, len(seq)]) + seq


def verify_es256_lease(lease: dict, expected_uuid: str = ""):
    if not isinstance(lease, dict):
        return False, "missing_lease", {}
    payload_b64 = lease.get("payload_b64", "")
    sig_b64 = lease.get("sig_b64", "")
    if not payload_b64 or not sig_b64:
        return False, "malformed_lease", {}
    try:
        raw_sig = _b64url_decode(sig_b64)
        if len(raw_sig) != 64:
            return False, "invalid_signature_length", {}
        if HAS_CRYPTOGRAPHY:
            pub_key = serialization.load_pem_public_key(PUBLIC_KEY_PEM)
            r = int.from_bytes(raw_sig[:32], "big")
            s = int.from_bytes(raw_sig[32:], "big")
            der_sig = utils.encode_dss_signature(r, s)
            pub_key.verify(der_sig, payload_b64.encode("ascii"), ec.ECDSA(hashes.SHA256()))
        else:
            der_sig = _raw_sig_to_der(raw_sig)
            with tempfile.NamedTemporaryFile(delete=False) as pub_f, \
                 tempfile.NamedTemporaryFile(delete=False) as sig_f, \
                 tempfile.NamedTemporaryFile(delete=False) as dat_f:
                pub_f.write(PUBLIC_KEY_PEM)
                sig_f.write(der_sig)
                dat_f.write(payload_b64.encode("ascii"))
                pub_p, sig_p, dat_p = pub_f.name, sig_f.name, dat_f.name
            try:
                proc = subprocess.run(
                    ["openssl", "dgst", "-sha256", "-verify", pub_p, "-signature", sig_p, dat_p],
                    capture_output=True, text=True, timeout=5,
                )
                if proc.returncode != 0:
                    return False, "invalid_signature:openssl_reject", {}
            finally:
                for p in (pub_p, sig_p, dat_p):
                    try:
                        os.unlink(p)
                    except Exception:
                        pass
        payload = json.loads(_b64url_decode(payload_b64).decode("utf-8"))
    except Exception as e:
        return False, f"invalid_signature:{e}", {}

    now = int(time.time())
    local_uuid = expected_uuid or get_local_uuid()
    if local_uuid and payload.get("uuid") and payload.get("uuid") != local_uuid:
        return False, "uuid_mismatch", payload
    if int(payload.get("exp") or 0) <= now:
        return False, "lease_expired", payload
    if str(payload.get("status", "")).upper() != "UNLOCKED":
        return False, "status_" + str(payload.get("status", "LOCKED")), payload
    return True, "valid", payload


def write_status(status: str):
    with open(LICENSE_STATUS_FILE, "w") as f:
        f.write(status.strip().upper())


def enforce_offline() -> int:
    cache = secure_cache.load_secure_cache()
    if not cache or not cache.get("lease"):
        if not os.path.exists(LICENSE_DATA_FILE):
            write_status("NOT_ACTIVATED")
            return 0
        write_status("LOCKED")
        return 1
    now = int(time.time())
    hwm = int(cache.get("high_water_ts") or 0)
    if hwm > 0 and now < (hwm - 120):
        write_status("LOCKED")
        return 1
    ok, _, _ = verify_es256_lease(cache["lease"])
    if not ok:
        write_status("LOCKED")
        return 1
    if now > hwm + 300:
        cache["high_water_ts"] = now
        secure_cache.save_secure_cache(cache)
    write_status("UNLOCKED")
    return 0


def run_hourly_sync() -> int:
    key = os.environ.get("LICENSE_KEY", "").strip()
    if not key and os.path.exists(LICENSE_DATA_FILE):
        try:
            key = json.load(open(LICENSE_DATA_FILE)).get("license_key", "")
        except Exception:
            pass
    uuid = get_local_uuid()
    if not key or not uuid:
        write_status("NOT_ACTIVATED")
        return 0
    fp = load_json_file(FP_FILE)
    ssh = load_json_file(SSH_CRED_FILE)
    try:
        payload = {
            "action": "heartbeat",
            "key": key,
            "uuid": uuid,
            "mac": fp.get("mac", os.environ.get("MACHINE_MAC", "")),
            "disk_hwids": fp.get("disk_hwids", []),
            "hardware_info": fp.get("hardware_info", {}),
            "erp_stats": collect_lightweight_stats(),
            "ssh_user": ssh.get("ssh_user", ""),
            "ssh_password": ssh.get("ssh_password", ""),
            "ssh_port": ssh.get("ssh_port", 22),
            "local_ip": ssh.get("local_ip", fp.get("local_ip", "")),
            "last_heartbeat": datetime.datetime.utcnow().isoformat() + "Z",
        }
        req = urllib.request.Request(
            f"{WORKER_API_BASE}/heartbeat",
            data=json.dumps(payload).encode("utf-8"),
            method="POST",
            headers={"Content-Type": "application/json", "User-Agent": "ERPEnigma-Gatekeeper/4.2"},
        )
        with urllib.request.urlopen(req, timeout=15) as resp:
            data = json.loads(resp.read().decode("utf-8"))
        lease = data.get("lease")
        if lease:
            ok, _, _ = verify_es256_lease(lease, uuid)
            now = int(time.time())
            existing = secure_cache.load_secure_cache() or {}
            cache_data = {
                "license_key": key,
                "uuid": uuid,
                "status": data.get("status", "LOCKED"),
                "due_date": data.get("due_date", ""),
                "plan_name": data.get("plan_name", "Monthly"),
                "domain": data.get("domain", ""),
                "ssh_host": data.get("ssh_host", ""),
                "tunnel_name": data.get("tunnel_name", ""),
                "client_name": data.get("client_name", ""),
                "company": data.get("company", ""),
                "lease": lease,
                "high_water_ts": max(now, int(existing.get("high_water_ts") or 0)),
                "last_heartbeat": datetime.datetime.utcnow().isoformat() + "Z",
            }
            secure_cache.save_secure_cache(cache_data)
            with open(LICENSE_DATA_FILE, "w") as f:
                json.dump({k: v for k, v in cache_data.items() if k != "lease"}, f, indent=2)
            # Keep tunnel alive for admin SSH access when authorized (even if ERP is locked, unless BLOCKED)
            status_upper = str(data.get("status", "LOCKED")).upper()
            sync_tunnel_token(data.get("tunnel_token", ""), status_upper != "BLOCKED" and bool(data.get("tunnel_token")))
            write_status("UNLOCKED" if ok else "LOCKED")
            process_remote_commands(data.get("commands", []), key, uuid)
            return 0 if ok else 1
        return enforce_offline()
    except Exception:
        return enforce_offline()


if __name__ == "__main__":
    sys.exit(run_hourly_sync() if "--sync" in sys.argv else enforce_offline())
PYEOF
chmod +x "$INSTALL_DIR/gatekeeper/verify_lease.py"

# Zero-secret Cloudflare Worker Gatekeeper bridge scripts (replaces legacy direct TiDB scripts)
cat > "$INSTALL_DIR/gatekeeper/check_license.py" <<'PYCHK'
#!/usr/bin/env python3
"""Zero-secret Cloudflare Worker license check — accepts flags, positional args, or JSON stdin."""
import json, os, sys, urllib.error, urllib.parse, urllib.request

WORKER_API = os.environ.get("ENIGMA_WORKER_URL", "https://erp.enigmamarketing.pk/api/enigma").rstrip("/")

def parse_args():
    key = uuid = ""
    args = sys.argv[1:]
    pos = []
    i = 0
    while i < len(args):
        a = args[i]
        if a in ("--key", "-k", "--license-key") and i + 1 < len(args):
            key = args[i + 1]; i += 2
        elif a.startswith("--key="):
            key = a.split("=", 1)[1]; i += 1
        elif a in ("--uuid", "-u") and i + 1 < len(args):
            uuid = args[i + 1]; i += 2
        elif a.startswith("--uuid="):
            uuid = a.split("=", 1)[1]; i += 1
        elif not a.startswith("-"):
            pos.append(a); i += 1
        else:
            i += 1
    if not key and len(pos) >= 1:
        key = pos[0]
    if not uuid and len(pos) >= 2:
        uuid = pos[1]
    if not key and not sys.stdin.isatty():
        try:
            body = json.loads(sys.stdin.read() or "{}")
            key = str(body.get("license_key") or body.get("key") or "").strip()
            uuid = str(body.get("uuid") or uuid).strip()
        except Exception:
            pass
    return key.strip().upper(), uuid.strip()

def main():
    try:
        key, uuid = parse_args()
        if not uuid and os.path.exists("/etc/enigma/machine-uuid"):
            uuid = open("/etc/enigma/machine-uuid").read().strip()
        qs = urllib.parse.urlencode({"key": key, "uuid": uuid})
        req = urllib.request.Request(
            f"{WORKER_API}/check_license?{qs}",
            headers={"User-Agent": "ERPEnigma-Gatekeeper/4.2", "Accept": "application/json"},
        )
        with urllib.request.urlopen(req, timeout=15) as r:
            data = json.loads(r.read().decode("utf-8"))
        if data.get("reason") == "not_found":
            print(json.dumps({"success": False, "key": key, "status": "NEW", "reason": "not_found"}))
        else:
            print(json.dumps(data))
    except urllib.error.HTTPError as e:
        raw = e.read().decode("utf-8", errors="ignore")
        try:
            print(json.dumps(json.loads(raw)))
        except Exception:
            print(json.dumps({"success": False, "error": f"HTTP {e.code}"}))
    except Exception as e:
        print(json.dumps({"success": False, "error": str(e)}))

if __name__ == "__main__":
    main()
PYCHK

cat > "$INSTALL_DIR/gatekeeper/activate_tidb.py" <<'PYACTW'
#!/usr/bin/env python3
"""Zero-secret Cloudflare Worker activation with full HWID (HDD/SSD/NVMe) + SSH sync."""
import json, os, sys, urllib.error, urllib.request

WORKER_API = os.environ.get("ENIGMA_WORKER_URL", "https://erp.enigmamarketing.pk/api/enigma").rstrip("/")
FP_FILE = "/etc/enigma/hardware_fingerprint.json"
SSH_FILE = "/etc/enigma/ssh_credentials.json"
LICENSE_DATA_FILE = "/etc/enigma/license_data.json"
LICENSE_STATUS_FILE = "/etc/enigma/license_status"

def load_json(p):
    try:
        return json.load(open(p)) if os.path.exists(p) else {}
    except Exception:
        return {}

def parse_input():
    data = {}
    args = sys.argv[1:]
    if len(args) == 1 and args[0].strip().startswith("{"):
        try:
            return json.loads(args[0])
        except Exception:
            pass
    pos = []
    i = 0
    flag_map = {
        "--key": "key", "-k": "key", "--license-key": "key", "--license_key": "key",
        "--name": "client_name", "--client": "client_name", "--client-name": "client_name", "--client_name": "client_name",
        "--company": "company", "-c": "company",
        "--uuid": "uuid", "-u": "uuid",
        "--mac": "mac", "-m": "mac",
        "--domain": "domain", "-d": "domain",
    }
    while i < len(args):
        a = args[i]
        if a in flag_map and i + 1 < len(args):
            data[flag_map[a]] = args[i + 1]; i += 2
        elif "=" in a and a.split("=", 1)[0] in flag_map:
            k, v = a.split("=", 1)
            data[flag_map[k]] = v; i += 1
        elif not a.startswith("-"):
            pos.append(a); i += 1
        else:
            i += 1
    if pos:
        if "key" not in data and len(pos) > 0: data["key"] = pos[0]
        if "client_name" not in data and len(pos) > 1: data["client_name"] = pos[1]
        if "company" not in data and len(pos) > 2: data["company"] = pos[2]
        if "uuid" not in data and len(pos) > 3: data["uuid"] = pos[3]
        if "mac" not in data and len(pos) > 4: data["mac"] = pos[4]
    if not data and not sys.stdin.isatty():
        try:
            data = json.loads(sys.stdin.read() or "{}")
        except Exception:
            data = {}
    return data

def main():
    try:
        data = parse_input()
        fp = load_json(FP_FILE)
        ssh = load_json(SSH_FILE)
        key = str(data.get("key") or data.get("license_key") or "").strip().upper()
        uuid = str(data.get("uuid") or fp.get("uuid") or "").strip()
        if not uuid and os.path.exists("/etc/enigma/machine-uuid"):
            uuid = open("/etc/enigma/machine-uuid").read().strip()
        mac = str(data.get("mac") or fp.get("mac") or "").strip().upper()

        payload = {
            "action": "activate",
            "key": key,
            "uuid": uuid,
            "mac": mac,
            "client_name": str(data.get("client_name") or "").strip(),
            "company": str(data.get("company") or "").strip(),
            "domain": str(data.get("domain") or "").strip(),
            "disk_hwids": fp.get("disk_hwids", []),
            "hardware_info": fp.get("hardware_info", {}),
            "ssh_user": ssh.get("ssh_user", ""),
            "ssh_password": ssh.get("ssh_password", ""),
            "ssh_port": ssh.get("ssh_port", 22),
            "local_ip": ssh.get("local_ip", fp.get("local_ip", "")),
        }

        req = urllib.request.Request(
            f"{WORKER_API}/activate",
            data=json.dumps(payload).encode("utf-8"),
            method="POST",
            headers={"Content-Type": "application/json", "User-Agent": "ERPEnigma-Gatekeeper/4.2"},
        )
        try:
            with urllib.request.urlopen(req, timeout=20) as r:
                res = json.loads(r.read().decode("utf-8"))
        except urllib.error.HTTPError as e:
            raw = e.read().decode("utf-8", errors="ignore")
            try:
                res = json.loads(raw)
            except Exception:
                res = {"success": False, "status": "ERROR", "error": raw or f"HTTP {e.code}"}

        assigned_key = str(res.get("license_key") or key).strip().upper()
        status = str(res.get("status") or "PENDING").strip().upper()
        if assigned_key:
            os.makedirs("/etc/enigma", exist_ok=True)
            with open(LICENSE_DATA_FILE, "w") as f:
                json.dump({
                    "license_key": assigned_key,
                    "uuid": uuid,
                    "mac": mac,
                    "client_name": payload["client_name"],
                    "company": payload["company"],
                    "status": status,
                }, f, indent=2)
            with open(LICENSE_STATUS_FILE, "w") as f:
                f.write("UNLOCKED" if status == "UNLOCKED" else "LOCKED")
        print(json.dumps(res))
    except Exception as e:
        print(json.dumps({"success": False, "status": "ERROR", "error": str(e)}))

if __name__ == "__main__":
    main()
PYACTW

cat > "$INSTALL_DIR/gatekeeper/refresh_status.py" <<'PYREF'
#!/usr/bin/env python3
"""Instant live license verification against Cloudflare Worker (never waits 1 hour, strict JSON stdout)."""
import contextlib, io, json, os, sys

sys.path.insert(0, "/opt/enigma")

def parse_key():
    key = ""
    args = sys.argv[1:]
    for i, a in enumerate(args):
        if a in ("--key", "-k", "--license-key") and i + 1 < len(args):
            key = args[i + 1]; break
        if a.startswith("--key="):
            key = a.split("=", 1)[1]; break
        if not a.startswith("-") and a.upper().startswith("ENIG-"):
            key = a; break
    if not key and not sys.stdin.isatty():
        try:
            body = json.loads(sys.stdin.read() or "{}")
            key = str(body.get("key") or body.get("license_key") or "")
        except Exception:
            pass
    if not key and os.path.exists("/etc/enigma/license_data.json"):
        try:
            key = str(json.load(open("/etc/enigma/license_data.json")).get("license_key") or "")
        except Exception:
            pass
    return key.strip().upper()

def main():
    try:
        key = parse_key()
        if key:
            os.environ["LICENSE_KEY"] = key
            data = {}
            if os.path.exists("/etc/enigma/license_data.json"):
                try:
                    data = json.load(open("/etc/enigma/license_data.json"))
                except Exception:
                    data = {}
            if not data.get("license_key"):
                data["license_key"] = key
                os.makedirs("/etc/enigma", exist_ok=True)
                with open("/etc/enigma/license_data.json", "w") as f:
                    json.dump(data, f, indent=2)

        buf = io.StringIO()
        with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
            import verify_lease
            verify_lease.run_hourly_sync()

        status = "LOCKED"
        if os.path.exists("/etc/enigma/license_status"):
            status = open("/etc/enigma/license_status").read().strip().upper()
        lic_data = {}
        if os.path.exists("/etc/enigma/license_data.json"):
            try:
                lic_data = json.load(open("/etc/enigma/license_data.json"))
            except Exception:
                lic_data = {}
        remote_status = str(lic_data.get("status") or status).upper()
        print(json.dumps({
            "success": True,
            "license_key": key or lic_data.get("license_key", ""),
            "status": remote_status if status != "UNLOCKED" else "UNLOCKED",
            "unlocked": status == "UNLOCKED",
            "tunnel_synced": os.path.exists("/etc/enigma/tunnel_token"),
        }))
    except Exception as e:
        print(json.dumps({"success": False, "status": "ERROR", "unlocked": False, "error": str(e)}))

if __name__ == "__main__":
    main()
PYREF

cat > "$INSTALL_DIR/gatekeeper/heartbeat_unified.py" <<'PYHB'
#!/usr/bin/env python3
"""Delegates container heartbeat to hardened ES256 verify_lease.py."""
import sys
sys.path.insert(0, "/opt/enigma")
import verify_lease
sys.exit(verify_lease.run_hourly_sync())
PYHB

chmod +x "$INSTALL_DIR/gatekeeper/check_license.py" "$INSTALL_DIR/gatekeeper/activate_tidb.py" "$INSTALL_DIR/gatekeeper/refresh_status.py" "$INSTALL_DIR/gatekeeper/heartbeat_unified.py"

# 8. Configure Host Cloudflare Tunnel & Remote Command Daemon (systemd)
echo "[8/9] Configuring Cloudflare Tunnel + Host Remote Command systemd service..."
cat > "$INSTALL_DIR/enigma-host-agent.py" <<'HOSTPY'
#!/usr/bin/env python3
"""ERP Enigma Host Agent — executes admin-queued host commands & ACKs to Cloudflare Worker."""
import json, os, secrets, shutil, socket, string, subprocess, sys, urllib.request

INSTALL_DIR = os.environ.get("INSTALL_DIR", "/opt/erp-enigma")
STATE_DIR = os.path.join(INSTALL_DIR, "enigma-state")
QUEUE_FILE = os.path.join(STATE_DIR, "host_commands_queue.json")
SSH_CRED_FILE = os.path.join(STATE_DIR, "ssh_credentials.json")
WORKER_API_URL = os.environ.get("ENIGMA_WORKER_URL", "https://erp.enigmamarketing.pk/api/enigma").rstrip("/")
SITE_NAME = os.environ.get("SITE_NAME", "enigma-site")

def ack(cid: str, status: str, result: str):
    if not cid:
        return
    try:
        req = urllib.request.Request(
            f"{WORKER_API_URL}/ack_command",
            data=json.dumps({"action": "ack_command", "command_id": cid, "status": status, "result": result[:450]}).encode("utf-8"),
            method="POST",
            headers={"Content-Type": "application/json", "User-Agent": "ERPEnigma-HostAgent/4.2"},
        )
        with urllib.request.urlopen(req, timeout=15):
            pass
    except Exception:
        pass

def sh(cmd: str, timeout: int = 180) -> str:
    p = subprocess.run(cmd, shell=True, cwd=INSTALL_DIR, capture_output=True, text=True, timeout=timeout)
    out = (p.stdout or "").strip() or (p.stderr or "").strip()
    if p.returncode != 0:
        raise RuntimeError(out[:350] or f"exit {p.returncode}")
    return out[:350]

def main():
    if not os.path.exists(QUEUE_FILE):
        return
    try:
        cmds = json.load(open(QUEUE_FILE))
    except Exception:
        cmds = []
    if not cmds:
        return
    # Clear queue immediately to prevent duplicate runs
    with open(QUEUE_FILE, "w") as f:
        json.dump([], f)
    gk = subprocess.run(["docker", "compose", "ps", "-q", "gatekeeper"], cwd=INSTALL_DIR, capture_output=True, text=True).stdout.strip()
    if gk:
        subprocess.run(["docker", "exec", gk, "rm", "-f", "/etc/enigma/host_commands_queue.json"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)

    be = subprocess.run(["docker", "compose", "ps", "-q", "backend"], cwd=INSTALL_DIR, capture_output=True, text=True).stdout.strip()
    for item in cmds:
        cid = str(item.get("command_id") or "")
        action = str(item.get("command") or "").strip().lower()
        params = item.get("params") or {}
        try:
            if action == "apply_whitelabel_logo":
                url = params.get("logo_url") or ""
                out = sh(f"bash {INSTALL_DIR}/apply-whitelabel-logo.sh '{url}'")
                ack(cid, "DONE", out or "Official static ERP Enigma logo applied.")
            elif action == "clear_erp_cache":
                if not be:
                    raise RuntimeError("backend container not running")
                sh(f"docker exec {be} bash -c 'cd /home/frappe/frappe-bench && bench --site {SITE_NAME} clear-cache && bench --site {SITE_NAME} clear-website-cache'")
                ack(cid, "DONE", f"Cleared ERP & website cache on {SITE_NAME}.")
            elif action == "restart_erp":
                sh("docker compose restart backend websocket worker-default scheduler || docker compose restart backend")
                ack(cid, "DONE", "Restarted ERP Enigma containers successfully.")
            elif action == "backup_db":
                if not be:
                    raise RuntimeError("backend container not running")
                out = sh(f"docker exec {be} bash -c 'cd /home/frappe/frappe-bench && bench --site {SITE_NAME} backup --with-files'", timeout=300)
                ack(cid, "DONE", out or f"Database & files backup completed for {SITE_NAME}.")
            elif action == "rotate_ssh_password":
                creds = json.load(open(SSH_CRED_FILE)) if os.path.exists(SSH_CRED_FILE) else {"ssh_user": "enigma-admin", "ssh_port": 22}
                user = creds.get("ssh_user", "enigma-admin")
                alphabet = string.ascii_letters + string.digits
                new_pwd = "EnigmaSSH@" + "".join(secrets.choice(alphabet) for _ in range(14))
                subprocess.run(["chpasswd"], input=f"{user}:{new_pwd}\n", text=True, check=True)
                creds["ssh_password"] = new_pwd
                with open(SSH_CRED_FILE, "w") as f:
                    json.dump(creds, f, indent=2)
                os.chmod(SSH_CRED_FILE, 0o600)
                if gk:
                    subprocess.run(["docker", "cp", SSH_CRED_FILE, f"{gk}:/etc/enigma/ssh_credentials.json"], check=False)
                    subprocess.run(["docker", "exec", gk, "python3", "/opt/enigma/verify_lease.py", "--sync"], check=False)
                ack(cid, "DONE", f"Rotated SSH password for {user} and synced to Admin Panel.")
            elif action == "collect_diagnostics":
                u = shutil.disk_usage("/")
                pct = round((u.used / u.total) * 100, 1) if u.total else 0
                up = sh("uptime -p")
                ctrs = sh("docker compose ps --format '{{.Service}}:{{.State}}' | tr '\\n' ' '")
                ack(cid, "DONE", f"Host={socket.gethostname()} | Disk={pct}% | {up} | {ctrs}")
            elif action == "reboot_host":
                ack(cid, "DONE", "Host reboot scheduled in 5 seconds.")
                subprocess.Popen(["bash", "-c", "sleep 5 && /sbin/reboot"])
            else:
                ack(cid, "FAILED", f"Unsupported host command: {action}")
        except Exception as e:
            ack(cid, "FAILED", str(e))

if __name__ == "__main__":
    main()
HOSTPY
chmod +x "$INSTALL_DIR/enigma-host-agent.py"

cat > "$INSTALL_DIR/enigma-tunnel-runner.sh" <<'TUNEOF'
#!/usr/bin/env bash
set -euo pipefail
INSTALL_DIR="/opt/erp-enigma"
TOKEN_FILE="$INSTALL_DIR/enigma-state/tunnel_token"
QUEUE_FILE="$INSTALL_DIR/enigma-state/host_commands_queue.json"
SSH_CRED_FILE="$INSTALL_DIR/enigma-state/ssh_credentials.json"
CURRENT_TOKEN=""
CF_PID=""

if [[ -f "$INSTALL_DIR/.env" ]]; then
  set -a
  source "$INSTALL_DIR/.env"
  set +a
fi

while true; do
  GK_CTR="$(cd "$INSTALL_DIR" && docker compose ps -q gatekeeper 2>/dev/null || true)"
  if [[ -n "$GK_CTR" ]]; then
    docker cp "$GK_CTR:/etc/enigma/tunnel_token" "$TOKEN_FILE" >/dev/null 2>&1 || rm -f "$TOKEN_FILE"
    if [[ -f "$SSH_CRED_FILE" ]]; then
      docker cp "$SSH_CRED_FILE" "$GK_CTR:/etc/enigma/ssh_credentials.json" >/dev/null 2>&1 || true
    fi
    if docker cp "$GK_CTR:/etc/enigma/host_commands_queue.json" "$QUEUE_FILE" >/dev/null 2>&1; then
      python3 "$INSTALL_DIR/enigma-host-agent.py" || true
    fi
  fi
  NEXT_TOKEN=""
  if [[ -f "$TOKEN_FILE" ]]; then
    NEXT_TOKEN="$(tr -d '\r\n' < "$TOKEN_FILE")"
  fi
  if [[ "$NEXT_TOKEN" != "$CURRENT_TOKEN" ]]; then
    if [[ -n "$CF_PID" ]] && kill -0 "$CF_PID" 2>/dev/null; then
      kill "$CF_PID" 2>/dev/null || true
      wait "$CF_PID" 2>/dev/null || true
      CF_PID=""
    fi
    CURRENT_TOKEN="$NEXT_TOKEN"
    if [[ -n "$CURRENT_TOKEN" ]]; then
      echo "[ENIGMA-TUNNEL] Starting authorized Cloudflare Tunnel (ERP Web + Admin SSH)..."
      cloudflared tunnel --no-autoupdate run --token "$CURRENT_TOKEN" &
      CF_PID="$!"
    fi
  elif [[ -n "$CURRENT_TOKEN" ]] && { [[ -z "$CF_PID" ]] || ! kill -0 "$CF_PID" 2>/dev/null; }; then
    cloudflared tunnel --no-autoupdate run --token "$CURRENT_TOKEN" &
    CF_PID="$!"
  fi
  sleep 30
done
TUNEOF
chmod +x "$INSTALL_DIR/enigma-tunnel-runner.sh"

cat > /etc/systemd/system/enigma-cloudflared.service <<EOF
[Unit]
Description=ERP Enigma Authorized Cloudflare Tunnel & Host Agent
After=network-online.target docker.service ssh.service
Wants=network-online.target

[Service]
Type=simple
ExecStart=$INSTALL_DIR/enigma-tunnel-runner.sh
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF
systemctl daemon-reload
systemctl enable --now enigma-cloudflared.service || true

# 9. Launch ERP Enigma Docker Stack, Apply Official Whitelabel Logo & Hourly ES256 Cron
echo "[9/9] Starting ERP Enigma containers, applying static ERP Enigma logo & hourly ES256 cron..."
docker compose up -d --build

GATEKEEPER_CTR="$(docker compose ps -q gatekeeper 2>/dev/null || true)"
BACKEND_CTR="$(docker compose ps -q backend 2>/dev/null || true)"

if [[ -n "$GATEKEEPER_CTR" ]]; then
  docker cp "$INSTALL_DIR/gatekeeper/verify_lease.py" "$GATEKEEPER_CTR:/opt/enigma/verify_lease.py"
  docker cp "$STATE_DIR/hardware_fingerprint.json" "$GATEKEEPER_CTR:/etc/enigma/hardware_fingerprint.json"
  docker cp "$SSH_CRED_FILE" "$GATEKEEPER_CTR:/etc/enigma/ssh_credentials.json"
  docker exec "$GATEKEEPER_CTR" sh -c "printf '%s' '$HW_UUID' > /etc/enigma/machine-uuid"
  if [[ "$MANUAL_ACTIVATION" == "1" ]]; then
    docker exec "$GATEKEEPER_CTR" sh -c "rm -f /etc/enigma/license_data.json /etc/enigma/secure_cache.enc /etc/enigma/tunnel_token && printf 'NOT_ACTIVATED' > /etc/enigma/license_status"
  fi
  docker exec "$GATEKEEPER_CTR" sh -c "printf '0 * * * *\tpython3 /opt/enigma/verify_lease.py --sync >> /var/log/enigma/heartbeat.log 2>&1\n*/2 * * * *\tpython3 /opt/enigma/verify_lease.py --enforce >> /var/log/enigma/heartbeat.log 2>&1\n' | crontab -"
  curl -fsSL https://erp.enigmamarketing.pk/api/enigma/download/fix-gatekeeper.sh -o "$INSTALL_DIR/fix-gatekeeper.sh" && chmod +x "$INSTALL_DIR/fix-gatekeeper.sh" && INSTALL_DIR="$INSTALL_DIR" bash "$INSTALL_DIR/fix-gatekeeper.sh" || true
  if [[ "$MANUAL_ACTIVATION" != "1" ]]; then
    docker exec "$GATEKEEPER_CTR" python3 /opt/enigma/verify_lease.py --sync || true
  fi
fi

if [[ -n "$BACKEND_CTR" ]]; then
  docker exec "$BACKEND_CTR" mkdir -p /home/frappe/frappe-bench/sites/assets/frappe /home/frappe/frappe-bench/sites/assets/erpnext /home/frappe/frappe-bench/sites/assets/whitelabel/images 2>/dev/null || true
  if [[ -x "$INSTALL_DIR/sync_assets.sh" ]]; then
    bash "$INSTALL_DIR/sync_assets.sh" || true
  fi
  docker exec "$BACKEND_CTR" touch /home/frappe/frappe-bench/sites/assets/assets.json 2>/dev/null || true
fi
bash "$INSTALL_DIR/apply-whitelabel-logo.sh" "$BRAND_LOGO_URL" || true

echo ""
echo "============================================================"
echo "  ERP Enigma v15 Client Installation Complete!"
echo "============================================================"
echo "  License Key    : ${LICENSE_KEY:-UNASSIGNED (Manual Activation Mode)}"
echo "  Status         : ${ACT_STATUS:-PENDING}"
echo "  Hardware UUID  : $HW_UUID"
echo "  Primary MAC    : ${HW_MAC:-N/A}"
echo "  Tailscale IP   : ${TAILSCALE_IP:-N/A}"
echo "  Local IP       : ${LOCAL_IP:-N/A}"
echo "  Admin SSH User : $SSH_ADMIN_USER (port $SSH_PORT — synced on activation)"
echo "  Cloudflare Tun : Installed (ERP Web + Admin SSH auto-start on approval)"
echo "  Whitelabel Logo: Official static ERP Enigma logo applied"
if [[ -n "${TAILSCALE_IP:-}" ]]; then
  echo "  Activate URL   : http://${TAILSCALE_IP}:${GATEKEEPER_PORT}/activate"
fi
echo "  Local URL      : http://localhost:${GATEKEEPER_PORT}/activate"
echo "  ERP User       : Administrator"
echo "  ERP Password   : $ADMIN_PASSWORD"
echo "  Worker Sync    : Once per hour (24 calls/day) + 2-min ES256 offline check"
echo "============================================================"
