admin-sync.js

import BasePlugin from "./base-plugin.js";
import axios from "axios";
import { promises as fsPromises } from "fs";
import path from "path";

export default class AdminSync extends BasePlugin {
  static get description() {
    return "Syncs the Admins.cfg file with admin data from a whitelist URL at regular intervals.";
  }

  static get defaultEnabled() {
    return true;
  }

  static get optionsSpecification() {
    return {
      whitelistUrl: {
        required: true,
        description: "URL or array of URLs to fetch admin whitelist data from.",
        example:
          'https://example.com/whitelist.txt or ["https://example.com/whitelist1.txt", "https://example.com/whitelist2.txt"]',
      },
      adminsFilePath: {
        required: true,
        description: "Path to the Admins.cfg file.",
        example: "/home/container/SquadGame/ServerConfig/Admins.cfg",
      },
      syncInterval: {
        required: false,
        description: "Interval in seconds between admin sync operations.",
        default: 300,
        example: 300,
      },
      updateOnStartup: {
        required: false,
        description: "Whether to update the admin list when the plugin starts.",
        default: true,
      },
      chatCommands: {
        required: false,
        description: "Array of chat commands that will trigger an admin sync.",
        default: ["!syncadmins", "!updateadmins"],
        example: ["!syncadmins", "!updateadmins"],
      },
      backupBeforeSync: {
        required: false,
        description: "Whether to create a backup of Admins.cfg before syncing.",
        default: true,
      },
      beautifyOutput: {
        required: false,
        description:
          "Whether to beautify and organize the admin data with comments, statistics, and group sections.",
        default: false,
      },
      maxBackupFiles: {
        required: false,
        description: "Maximum number of backup files to retain. Older backups are automatically deleted.",
        default: 5,
        example: 5,
      },
    };
  }

  constructor(server, options, connectors) {
    super(server, options, connectors);

    this.syncAdmins = this.syncAdmins.bind(this);
    this.onChatMessage = this.onChatMessage.bind(this);
    this.syncInterval = null;
    this.isCurrentlySyncing = false;
  }

  async mount() {
    this.verbose(1, "Admin Sync plugin mounted.");

    // Register for CHAT_MESSAGE events
    this.server.on("CHAT_MESSAGE", this.onChatMessage);

    // Run an initial sync if configured
    if (this.options.updateOnStartup) {
      this.verbose(1, "Running initial admin sync on startup.");
      await this.syncAdmins();
    }

    // Set up interval sync
    if (this.options.syncInterval > 0) {
      const intervalMs = this.options.syncInterval * 1000;
      this.verbose(
        1,
        `Setting up admin sync interval: ${this.options.syncInterval}s (${intervalMs}ms)`
      );
      this.syncInterval = setInterval(async () => {
        if (this.isCurrentlySyncing) {
          this.verbose(
            1,
            "Skipping scheduled sync - another sync is already in progress."
          );
          return;
        }
        this.verbose(1, "Running scheduled admin sync...");
        await this.syncAdmins();
      }, intervalMs);
    }
  }

  async unmount() {
    // Clear interval
    if (this.syncInterval) {
      clearInterval(this.syncInterval);
      this.syncInterval = null;
    }

    // Remove event listeners
    this.server.removeEventListener("CHAT_MESSAGE", this.onChatMessage);
  }

  async onChatMessage(info) {
    try {
      // Only process commands from admin chat
      if (info.chat !== "ChatAdmin") return;

      // Check if the message is a command
      const message = info.message.toLowerCase().trim();
      const isCommand = this.options.chatCommands.some(
        (cmd) => message === cmd.toLowerCase()
      );

      if (!isCommand) return;

      if (this.isCurrentlySyncing) {
        await this.server.rcon.warn(
          info.player.eosID,
          "Admin sync is already in progress. Please wait."
        );
        return;
      }

      this.verbose(
        1,
        `Admin ${info.player.name} (${info.player.eosID}) triggered admin sync via chat command.`
      );

      // Acknowledge the command
      await this.server.rcon.warn(
        info.player.eosID,
        "Admin sync started. Check server logs for results."
      );

      // Sync the admins
      const success = await this.syncAdmins();

      // Notify the admin of completion
      const resultMessage = success
        ? "Admin sync completed successfully."
        : "Admin sync failed. Check server logs for details.";
      await this.server.rcon.warn(info.player.eosID, resultMessage);
    } catch (error) {
      this.verbose(1, `Error processing chat command: ${error.message}`);
      try {
        await this.server.rcon.warn(
          info.player.eosID,
          "Admin sync failed due to an error."
        );
      } catch (rconError) {
        this.verbose(
          1,
          `Failed to send error message to admin: ${rconError.message}`
        );
      }
    }
  }

  async syncAdmins() {
    if (this.isCurrentlySyncing) {
      this.verbose(1, "Sync already in progress, skipping...");
      return false;
    }

    this.isCurrentlySyncing = true;

    try {
      this.verbose(1, "Syncing admins...");

      // Convert single URL to array for consistency
      const urls = Array.isArray(this.options.whitelistUrl)
        ? this.options.whitelistUrl
        : [this.options.whitelistUrl];

      // Fetch data from all URLs concurrently
      const combinedContent = await this.fetchAdminDataFromUrls(urls);

      if (!combinedContent.trim()) {
        this.verbose(1, "No valid admin data found from any whitelist URL.");
        return false;
      }

      // Process content based on beautification setting
      const finalContent = this.options.beautifyOutput
        ? this.beautifyAdminData(combinedContent)
        : combinedContent;

      // Update the Admins.cfg file
      await this.updateAdminsFile(finalContent);

      this.verbose(1, "Admin sync completed successfully.");
      return true;
    } catch (error) {
      this.verbose(1, `Error syncing admins: ${error.message}`);
      this.verbose(2, `Stack trace: ${error.stack}`);
      return false;
    } finally {
      this.isCurrentlySyncing = false;
    }
  }

  async updateAdminsFile(content) {
    const filePath = this.options.adminsFilePath;

    try {
      // Create backup if requested
      if (this.options.backupBeforeSync) {
        await this.createBackup(filePath);
      }

      // Ensure the directory exists
      const dir = path.dirname(filePath);
      try {
        await fsPromises.access(dir);
      } catch {
        await fsPromises.mkdir(dir, { recursive: true });
        this.verbose(1, `Created directory: ${dir}`);
      }

      // Write the content to the file asynchronously
      await fsPromises.writeFile(filePath, content, "utf8");

      const mode = this.options.beautifyOutput ? "beautified" : "raw";
      this.verbose(
        1,
        `Updated Admins.cfg with ${content.length} characters of ${mode} admin data.`
      );
    } catch (error) {
      this.verbose(1, `Error updating admin file: ${error.message}`);
      throw error;
    }
  }

  beautifyAdminData(rawContent) {
    const lines = rawContent.trim().split("\n");
    const groups = new Map();
    const admins = new Map();

    // Parse groups and admins
    for (const line of lines) {
      const trimmedLine = line.trim();
      if (!trimmedLine || trimmedLine.startsWith("//")) continue;

      if (trimmedLine.startsWith("Group=")) {
        const match = trimmedLine.match(/^Group=([^:]+):(.*)$/);
        if (match) {
          const [, groupName, permissions] = match;
          groups.set(groupName, permissions);
        }
      } else if (trimmedLine.startsWith("Admin=")) {
        const match = trimmedLine.match(/^Admin=([^:]+):([^\s]+)(.*)$/);
        if (match) {
          const [, id, groupName, comment] = match;
          const isEOS = /^[0-9a-f]{32}$/.test(id);
          const isSteam = id.startsWith("76561");

          if (!admins.has(groupName)) {
            admins.set(groupName, []);
          }

          admins.get(groupName).push({
            id,
            isEOS,
            isSteam,
            comment: comment.trim(),
            original: trimmedLine,
          });
        }
      }
    }

    // Calculate statistics
    let totalAdmins = 0;
    let totalEOS = 0;
    let totalSteam = 0;
    let totalGroups = groups.size;

    for (const groupAdmins of admins.values()) {
      totalAdmins += groupAdmins.length;
      totalEOS += groupAdmins.filter((a) => a.isEOS).length;
      totalSteam += groupAdmins.filter((a) => a.isSteam).length;
    }

    // Generate beautified output
    let output = [];

    // Header with statistics
    output.push(
      "//============================================================================="
    );
    output.push("// Squad Server Admin Configuration File");
    output.push("// Auto-beautified and organized by AdminSync plugin");
    output.push(
      "//============================================================================="
    );
    output.push("//");
    output.push(`// Total Statistics:`);
    output.push(`//   - Groups: ${totalGroups}`);
    output.push(`//   - Total Admins: ${totalAdmins}`);
    output.push(`//   - EOS IDs: ${totalEOS}`);
    output.push(`//   - Steam IDs: ${totalSteam}`);
    output.push(`//   - Last Sync: ${new Date().toISOString()}`);
    output.push("//");
    output.push(
      "//============================================================================="
    );
    output.push("// GROUP DEFINITIONS");
    output.push(
      "//============================================================================="
    );
    output.push("");

    // Sort groups by category
    const adminGroups = [];
    const clanGroups = [];
    const specialGroups = [];

    for (const [groupName, permissions] of groups) {
      if (groupName.startsWith("Admin")) {
        adminGroups.push([groupName, permissions]);
      } else if (groupName.startsWith("Clan")) {
        clanGroups.push([groupName, permissions]);
      } else {
        specialGroups.push([groupName, permissions]);
      }
    }

    // Output admin groups
    if (adminGroups.length > 0) {
      output.push("// Administrative Groups");
      for (const [groupName, permissions] of adminGroups.sort()) {
        const count = admins.get(groupName)?.length || 0;
        output.push(`Group=${groupName}:${permissions} // ${count} members`);
      }
      output.push("");
    }

    // Output special groups
    if (specialGroups.length > 0) {
      output.push("// Special Groups");
      for (const [groupName, permissions] of specialGroups.sort()) {
        const count = admins.get(groupName)?.length || 0;
        output.push(`Group=${groupName}:${permissions} // ${count} members`);
      }
      output.push("");
    }

    // Output clan groups
    if (clanGroups.length > 0) {
      output.push("// Clan Groups");
      for (const [groupName, permissions] of clanGroups.sort()) {
        const count = admins.get(groupName)?.length || 0;
        output.push(`Group=${groupName}:${permissions} // ${count} members`);
      }
      output.push("");
    }

    output.push(
      "//============================================================================="
    );
    output.push("// ADMIN ASSIGNMENTS");
    output.push(
      "//============================================================================="
    );
    output.push("");

    // Sort admin groups for output
    const sortedAdminGroups = Array.from(admins.keys()).sort((a, b) => {
      // Prioritize admin groups, then special, then clans
      const aIsAdmin = a.startsWith("Admin");
      const bIsAdmin = b.startsWith("Admin");
      const aIsClan = a.startsWith("Clan");
      const bIsClan = b.startsWith("Clan");

      if (aIsAdmin && !bIsAdmin) return -1;
      if (!aIsAdmin && bIsAdmin) return 1;
      if (!aIsClan && bIsClan) return -1;
      if (aIsClan && !bIsClan) return 1;

      return a.localeCompare(b);
    });

    // Output admin assignments by group
    for (const groupName of sortedAdminGroups) {
      const groupAdmins = admins.get(groupName);
      if (!groupAdmins || groupAdmins.length === 0) continue;

      const eosCount = groupAdmins.filter((a) => a.isEOS).length;
      const steamCount = groupAdmins.filter((a) => a.isSteam).length;

      output.push(
        `//-----------------------------------------------------------------------------`
      );
      output.push(
        `// ${groupName} (${groupAdmins.length} members: ${eosCount} EOS, ${steamCount} Steam)`
      );
      output.push(
        `//-----------------------------------------------------------------------------`
      );

      // Sort admins within group (EOS first, then Steam, then alphabetically)
      const sortedAdmins = [...groupAdmins].sort((a, b) => {
        if (a.isEOS && !b.isEOS) return -1;
        if (!a.isEOS && b.isEOS) return 1;
        return a.original.localeCompare(b.original);
      });

      for (const admin of sortedAdmins) {
        output.push(admin.original);
      }
      output.push("");
    }

    output.push(
      "//============================================================================="
    );
    output.push("// End of Configuration");
    output.push(
      "//============================================================================="
    );

    return output.join("\n");
  }

  async createBackup(filePath) {
    try {
      await fsPromises.access(filePath);
    } catch {
      this.verbose(1, "No existing Admins.cfg file to backup.");
      return;
    }

    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
    const backupPath = `${filePath}.backup.${timestamp}`;

    try {
      await fsPromises.copyFile(filePath, backupPath);
      this.verbose(1, `Created backup: ${backupPath}`);
      
      // Clean up old backups
      await this.cleanupOldBackups(filePath);
    } catch (error) {
      this.verbose(1, `Failed to create backup: ${error.message}`);
      throw error;
    }
  }

  async cleanupOldBackups(filePath) {
    try {
      const dir = path.dirname(filePath);
      const basename = path.basename(filePath);
      const maxBackups = this.options.maxBackupFiles;

      if (maxBackups <= 0) {
        this.verbose(2, "Backup cleanup disabled (maxBackupFiles <= 0)");
        return;
      }

      // Get all backup files for this admin file
      const files = await fsPromises.readdir(dir);
      const backupFiles = files.filter(file => 
        file.startsWith(`${basename}.backup.`) && file !== basename
      );

      if (backupFiles.length <= maxBackups) {
        this.verbose(2, `No cleanup needed. ${backupFiles.length} backups (max: ${maxBackups})`);
        return;
      }

      // Sort backup files by creation time (oldest first)
      const backupFilesWithStats = await Promise.all(
        backupFiles.map(async (file) => {
          const fullPath = path.join(dir, file);
          const stats = await fsPromises.stat(fullPath);
          return { file, fullPath, ctime: stats.ctime };
        })
      );

      const sortedBackups = backupFilesWithStats.sort((a, b) => 
        a.ctime.getTime() - b.ctime.getTime()
      );

      // Delete oldest backups to keep only maxBackupFiles
      const filesToDelete = sortedBackups.slice(0, sortedBackups.length - maxBackups);
      
      for (const { file, fullPath } of filesToDelete) {
        try {
          await fsPromises.unlink(fullPath);
          this.verbose(1, `Deleted old backup: ${file}`);
        } catch (deleteError) {
          this.verbose(1, `Failed to delete backup ${file}: ${deleteError.message}`);
        }
      }

      this.verbose(1, `Backup cleanup completed. Kept ${maxBackups} most recent backups.`);
    } catch (error) {
      this.verbose(1, `Error during backup cleanup: ${error.message}`);
      // Don't throw error here as backup cleanup failure shouldn't stop the sync
    }
  }

  async fetchAdminDataFromUrls(urls) {
    const axiosConfig = {
      timeout: 30000,
      headers: {
        "User-Agent": "SquadJS-AdminSync/1.0",
        Accept: "text/plain, */*",
      },
    };

    const fetchPromises = urls.map(async (url) => {
      if (!url) return "";

      try {
        this.verbose(1, `Fetching admin data from: ${url}`);

        // Add cache busting parameter
        const separator = url.includes("?") ? "&" : "?";
        const cacheBuster = `${separator}t=${Date.now()}`;

        const response = await axios.get(`${url}${cacheBuster}`, axiosConfig);

        if (!response.data) {
          this.verbose(1, `No data received from whitelist URL: ${url}`);
          return "";
        }

        this.verbose(
          1,
          `Fetched ${response.data.length} characters from: ${url}`
        );
        return response.data;
      } catch (error) {
        this.verbose(1, `Error fetching from ${url}: ${error.message}`);
        if (error.code === "ECONNABORTED") {
          this.verbose(1, `Request timeout for ${url}`);
        } else if (error.response) {
          this.verbose(1, `HTTP ${error.response.status} for ${url}`);
        } else if (error.request) {
          this.verbose(1, `Network error for ${url}`);
        }
        return "";
      }
    });

    const results = await Promise.allSettled(fetchPromises);

    let combinedContent = "";
    let successCount = 0;

    for (const result of results) {
      if (result.status === "fulfilled" && result.value) {
        if (combinedContent && !combinedContent.endsWith("\n")) {
          combinedContent += "\n";
        }
        combinedContent += result.value;
        successCount++;
      }
    }

    this.verbose(
      1,
      `Successfully fetched data from ${successCount}/${urls.length} URLs`
    );

    if (successCount === 0) {
      throw new Error("Failed to fetch data from any whitelist URL");
    }

    return combinedContent;
  }
}