ConfigSync.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;

namespace ModSync
{
    /// <summary>
    /// Handles reading and in-memory application of BepInEx config files.
    /// Nothing is ever written to disk on the client — BoxedValue is set directly
    /// on each ConfigEntry so values revert to the player's own settings naturally
    /// when they restart or re-bind their config.
    /// </summary>
    internal static class ConfigSync
    {
        private static readonly ManualLogSource Log = Plugin.Logger;

        // -----------------------------------------------------------------
        // Reading (host side)
        // -----------------------------------------------------------------

        /// <summary>
        /// Reads all config files for installed plugins (except ModSync itself)
        /// and returns them as a dictionary of { filename -> raw file content }.
        /// </summary>
        internal static Dictionary<string, string> GetLocalConfigs()
        {
            var configs = new Dictionary<string, string>();
            var configDir = Paths.ConfigPath;

            foreach (var kvp in Chainloader.PluginInfos)
            {
                if (kvp.Key == MyPluginInfo.PLUGIN_GUID)
                    continue;

                var configPath = Path.Combine(configDir, $"{kvp.Key}.cfg");
                if (File.Exists(configPath))
                {
                    try
                    {
                        configs[Path.GetFileName(configPath)] = File.ReadAllText(configPath);
                    }
                    catch (Exception ex)
                    {
                        Log.LogWarning($"[ConfigSync] Could not read config for {kvp.Key}: {ex.Message}");
                    }
                }
            }

            return configs;
        }

        // -----------------------------------------------------------------
        // Serialization
        // -----------------------------------------------------------------

        /// <summary>
        /// Serializes a config dictionary to a byte array for Photon transmission.
        /// Format: [int32 count] [ (string key, string value) ... ]
        /// </summary>
        internal static byte[] Serialize(Dictionary<string, string> configs)
        {
            using var ms = new MemoryStream();
            using var bw = new BinaryWriter(ms, Encoding.UTF8);

            bw.Write(configs.Count);
            foreach (var kvp in configs)
            {
                bw.Write(kvp.Key);
                bw.Write(kvp.Value);
            }

            return ms.ToArray();
        }

        internal static Dictionary<string, string> Deserialize(byte[] data)
        {
            var configs = new Dictionary<string, string>();
            using var ms = new MemoryStream(data);
            using var br = new BinaryReader(ms, Encoding.UTF8);

            int count = br.ReadInt32();
            for (int i = 0; i < count; i++)
            {
                string key = br.ReadString();
                string value = br.ReadString();
                configs[key] = value;
            }

            return configs;
        }

        // -----------------------------------------------------------------
        // Applying (client side — in-memory only, no disk writes)
        // -----------------------------------------------------------------

        /// <summary>
        /// Parses each received config file and sets BoxedValue on matching
        /// ConfigEntries in-memory. The client's files on disk are never touched.
        /// Returns the number of individual settings applied.
        /// </summary>
        internal static int ApplyInMemory(Dictionary<string, string> receivedConfigs)
        {
            int applied = 0;

            foreach (var kvp in receivedConfigs)
            {
                var guid = Path.GetFileNameWithoutExtension(kvp.Key);

                if (!Chainloader.PluginInfos.TryGetValue(guid, out var pluginInfo))
                {
                    Log.LogDebug($"[ConfigSync] Skipping config for uninstalled mod: {guid}");
                    continue;
                }

                var configFile = pluginInfo.Instance.Config;
                var parsed = ParseIni(kvp.Value);

                // Disable auto-save so BoxedValue setter doesn't trigger Save() on each change.
                // We never call Save() ourselves — no disk writes occur.
                var previousSaveOnSet = configFile.SaveOnConfigSet;
                configFile.SaveOnConfigSet = false;
                try
                {
                    foreach (var definition in configFile.Keys)
                    {
                        if (!parsed.TryGetValue(definition.Section, out var section))
                            continue;
                        if (!section.TryGetValue(definition.Key, out var rawValue))
                            continue;

                        var entry = configFile[definition];
                        try
                        {
                            // TomlTypeConverter handles all BepInEx-supported types
                            // (bool, int, float, string, enums, KeyCode, Color, etc.)
                            entry.BoxedValue = TomlTypeConverter.ConvertToValue(rawValue, entry.SettingType);
                            applied++;
                        }
                        catch (Exception ex)
                        {
                            Log.LogWarning($"[ConfigSync] Could not apply {guid}/{definition.Section}/{definition.Key}: {ex.Message}");
                        }
                    }
                }
                finally
                {
                    // Always restore the original flag, even if something throws
                    configFile.SaveOnConfigSet = previousSaveOnSet;
                }

                Log.LogInfo($"[ConfigSync] Applied in-memory config for: {guid}");
            }

            return applied;
        }

        // -----------------------------------------------------------------
        // INI parser
        // -----------------------------------------------------------------

        /// <summary>
        /// Parses a BepInEx .cfg file into { Section -> { Key -> Value } }.
        /// Skips comment lines (## and #) and blank lines.
        /// Values are trimmed; inline comments after the value are not stripped
        /// because BepInEx doesn't use them.
        /// </summary>
        private static Dictionary<string, Dictionary<string, string>> ParseIni(string content)
        {
            var result = new Dictionary<string, Dictionary<string, string>>(StringComparer.OrdinalIgnoreCase);
            Dictionary<string, string>? currentSection = null;

            foreach (var rawLine in content.Split('\n'))
            {
                var line = rawLine.Trim();

                if (string.IsNullOrEmpty(line) || line.StartsWith("#"))
                    continue;

                if (line.StartsWith("[") && line.EndsWith("]"))
                {
                    var sectionName = line.Substring(1, line.Length - 2).Trim();
                    if (!result.TryGetValue(sectionName, out currentSection))
                    {
                        currentSection = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                        result[sectionName] = currentSection;
                    }
                    continue;
                }

                var eqIdx = line.IndexOf('=');
                if (eqIdx > 0 && currentSection != null)
                {
                    var key = line.Substring(0, eqIdx).Trim();
                    var value = line.Substring(eqIdx + 1).Trim();
                    currentSection[key] = value;
                }
            }

            return result;
        }
    }
}