using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using System.Diagnostics.CodeAnalysis;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Text;

using System.Text.RegularExpressions;

using UnityEngine;

using Debug = UnityEngine.Debug;

using ModuleManager.Logging;

using ModuleManager.Extensions;

using ModuleManager.Collections;

using ModuleManager.Tags;

using ModuleManager.Threading;

using ModuleManager.Patches;

using ModuleManager.Progress;

using NodeStack = ModuleManager.Collections.ImmutableStack<ConfigNode>;

namespace ModuleManager

{

public delegate void ModuleManagerPostPatchCallback();

[SuppressMessage("ReSharper", "StringLastIndexOfIsCultureSpecific.1")]

[SuppressMessage("ReSharper", "StringIndexOfIsCultureSpecific.1")]

public class MMPatchLoader : LoadingSystem

{

public string status = "";

public string errors = "";

public static bool keepPartDB = false;

private string activity = "Module Manager";

private static readonly Dictionary<string, Regex> regexCache = new Dictionary<string, Regex>();

private static string cachePath;

internal static string techTreeFile;

internal static string techTreePath;

internal static string physicsFile;

internal static string physicsPath;

private static string defaultPhysicsPath;

internal static string partDatabasePath;

private static string shaPath;

private UrlDir.UrlFile physicsUrlFile;

private string configSha;

private Dictionary<string, string> filesSha = new Dictionary<string, string>();

private static readonly List<ModuleManagerPostPatchCallback> postPatchCallbacks = new List<ModuleManagerPostPatchCallback>();

private const float yieldInterval = 1f/30f; // Patch at ~30fps

private IBasicLogger logger;

private float progressFraction = 0;

public static MMPatchLoader Instance { get; private set; }

private void Awake()

{

if (Instance != null)

{

DestroyImmediate(this);

return;

}

Instance = this;

DontDestroyOnLoad(gameObject);

cachePath = Path.Combine(Path.Combine(KSPUtil.ApplicationRootPath, "GameData"), "ModuleManager.ConfigCache");

techTreeFile = Path.Combine("GameData", "ModuleManager.TechTree");

techTreePath = Path.Combine(KSPUtil.ApplicationRootPath, techTreeFile);

physicsFile = Path.Combine("GameData", "ModuleManager.Physics");

physicsPath = Path.Combine(KSPUtil.ApplicationRootPath, physicsFile);

defaultPhysicsPath = Path.Combine(KSPUtil.ApplicationRootPath, "Physics.cfg");

partDatabasePath = Path.Combine(KSPUtil.ApplicationRootPath, "PartDatabase.cfg");

shaPath = Path.Combine(Path.Combine(KSPUtil.ApplicationRootPath, "GameData"), "ModuleManager.ConfigSHA");

logger = new ModLogger("ModuleManager", new UnityLogger(Debug.unityLogger));

}

private bool ready;

public override bool IsReady()

{

return ready;

}

public override float ProgressFraction() => progressFraction;

public override string ProgressTitle()

{

return activity;

}

public override void StartLoad()

{

ready = false;

// DB check used to track the now fixed TextureReplacer corruption

//checkValues();

StartCoroutine(ProcessPatch());

}

public static void AddPostPatchCallback(ModuleManagerPostPatchCallback callback)

{

if (!postPatchCallbacks.Contains(callback))

postPatchCallbacks.Add(callback);

}

private IEnumerator ProcessPatch()

{

Stopwatch patchSw = new Stopwatch();

patchSw.Start();

status = "Checking Cache";

logger.Info(status);

yield return null;

bool useCache = false;

try

{

useCache = IsCacheUpToDate();

}

catch (Exception ex)

{

logger.Exception("Exception in IsCacheUpToDate", ex);

}

#if DEBUG

//useCache = false;

#endif

yield return null;

if (!useCache)

{

IPatchProgress progress = new PatchProgress(logger);

status = "Pre patch init";

logger.Info(status);

IEnumerable<string> mods = ModListGenerator.GenerateModList(progress, logger);

yield return null;

// If we don't use the cache then it is best to clean the PartDatabase.cfg

if (!keepPartDB && File.Exists(partDatabasePath))

File.Delete(partDatabasePath);

LoadPhysicsConfig();

#region Sorting Patches

status = "Extracting patches";

logger.Info(status);

yield return null;

UrlDir gameData = GameDatabase.Instance.root.children.First(dir => dir.type == UrlDir.DirectoryType.GameData && dir.name == "");

INeedsChecker needsChecker = new NeedsChecker(mods, gameData, progress, logger);

ITagListParser tagListParser = new TagListParser(progress);

IProtoPatchBuilder protoPatchBuilder = new ProtoPatchBuilder(progress);

IPatchCompiler patchCompiler = new PatchCompiler();

PatchExtractor extractor = new PatchExtractor(progress, logger, needsChecker, tagListParser, protoPatchBuilder, patchCompiler);

// Have to convert to an array because we will be removing patches

UrlDir.UrlConfig[] allConfigs = GameDatabase.Instance.root.AllConfigs.ToArray();

IEnumerable<IPatch> extractedPatches = allConfigs.Select(urlConfig => extractor.ExtractPatch(urlConfig));

PatchList patchList = new PatchList(mods, extractedPatches.Where(patch => patch != null), progress);

#endregion

#region Applying patches

status = "Applying patches";

logger.Info(status);

yield return null;

MessageQueue<ILogMessage> logQueue = new MessageQueue<ILogMessage>();

IBasicLogger patchLogger = new QueueLogger(logQueue);

IPatchProgress threadPatchProgress = new PatchProgress(progress, patchLogger);

PatchApplier applier = new PatchApplier(threadPatchProgress, patchLogger);

logger.Info("Starting patch thread");

ITaskStatus patchThread = BackgroundTask.Start(delegate

{

applier.ApplyPatches(GameDatabase.Instance.root.AllConfigFiles.ToArray(), patchList);

});

float nextYield = Time.realtimeSinceStartup + yieldInterval;

float updateTimeRemaining()

{

float timeRemaining = nextYield - Time.realtimeSinceStartup;

if (timeRemaining < 0)

{

nextYield = Time.realtimeSinceStartup + yieldInterval;

StatusUpdate(progress);

activity = applier.Activity;

}

return timeRemaining;

}

while (patchThread.IsRunning)

{

foreach (ILogMessage message in logQueue.TakeAll())

{

message.LogTo(logger);

if (updateTimeRemaining() < 0) yield return null;

}

float timeRemaining = updateTimeRemaining();

if (timeRemaining > 0) System.Threading.Thread.Sleep((int)(timeRemaining * 1000));

yield return null;

}

StatusUpdate(progress);

activity = "ModuleManager - finishing up";

yield return null;

// Clear any log messages that might still be in the queue

foreach (ILogMessage message in logQueue.TakeAll())

{

message.LogTo(logger);

}

if (patchThread.IsExitedWithError)

{

progress.Exception("The patch runner threw an exception", patchThread.Exception);

FatalErrorHandler.HandleFatalError("The patch runner threw an exception");

yield break;

}

logger.Info("Done patching");

yield return null;

PurgeUnused();

#endregion Applying patches

#region Saving Cache

foreach (KeyValuePair<string, int> item in progress.Counter.warningFiles)

{

logger.Warning(item.Value + " warning" + (item.Value > 1 ? "s" : "") + " related to GameData/" + item.Key);

}

if (progress.Counter.errors > 0 || progress.Counter.exceptions > 0)

{

foreach (KeyValuePair<string, int> item in progress.Counter.errorFiles)

{

errors += item.Value + " error" + (item.Value > 1 ? "s" : "") + " related to GameData/" + item.Key

+ "\n";

}

logger.Warning("Errors in patch prevents the creation of the cache");

try

{

if (File.Exists(cachePath))

File.Delete(cachePath);

if (File.Exists(shaPath))

File.Delete(shaPath);

}

catch (Exception e)

{

logger.Exception("Exception while deleting stale cache ", e);

}

}

else

{

status = "Saving Cache";

logger.Info(status);

yield return null;

CreateCache(progress.Counter.patchedNodes);

}

StatusUpdate(progress);

#endregion Saving Cache

SaveModdedTechTree();

SaveModdedPhysics();

}

else

{

status = "Loading from Cache";

logger.Info(status);

yield return null;

LoadCache();

}

logger.Info(status + "\n" + errors);

#if DEBUG

RunTestCases();

#endif

// TODO : Remove if we ever get a way to load sooner

logger.Info("Reloading resources definitions");

PartResourceLibrary.Instance.LoadDefinitions();

logger.Info("Reloading Trait configs");

GameDatabase.Instance.ExperienceConfigs.LoadTraitConfigs();

logger.Info("Reloading Part Upgrades");

PartUpgradeManager.Handler.FillUpgrades();

foreach (ModuleManagerPostPatchCallback callback in postPatchCallbacks)

{

try

{

callback();

}

catch (Exception e)

{

logger.Exception("Exception while running a post patch callback", e);

}

yield return null;

}

yield return null;

// Call all "public static void ModuleManagerPostLoad()" on all class

foreach (Assembly ass in AppDomain.CurrentDomain.GetAssemblies())

{

try

{

foreach (Type type in ass.GetTypes())

{

MethodInfo method = type.GetMethod("ModuleManagerPostLoad", BindingFlags.Public | BindingFlags.Static);

if (method != null && method.GetParameters().Length == 0)

{

try

{

logger.Info("Calling " + ass.GetName().Name + "." + type.Name + "." + method.Name + "()");

method.Invoke(null, null);

}

catch (Exception e)

{

logger.Exception("Exception while calling " + ass.GetName().Name + "." + type.Name + "." + method.Name + "()", e);

}

}

}

}

catch (Exception e)

{

logger.Exception("Post run call threw an exception in loading " + ass.FullName, e);

}

}

yield return null;

// Call "public void ModuleManagerPostLoad()" on all active MonoBehaviour instance

foreach (MonoBehaviour obj in FindObjectsOfType<MonoBehaviour>())

{

MethodInfo method = obj.GetType().GetMethod("ModuleManagerPostLoad", BindingFlags.Public | BindingFlags.Instance);

if (method != null && method.GetParameters().Length == 0)

{

try

{

logger.Info("Calling " + obj.GetType().Name + "." + method.Name + "()");

method.Invoke(obj, null);

}

catch (Exception e)

{

logger.Exception("Exception while calling " + obj.GetType().Name + "." + method.Name + "() :\n", e);

}

}

}

yield return null;

if (ModuleManager.dumpPostPatch)

ModuleManager.OutputAllConfigs();

yield return null;

patchSw.Stop();

logger.Info("Ran in " + ((float)patchSw.ElapsedMilliseconds / 1000).ToString("F3") + "s");

ready = true;

}

private void LoadPhysicsConfig()

{

logger.Info("Loading Physics.cfg");

UrlDir gameDataDir = GameDatabase.Instance.root.AllDirectories.First(d => d.path.EndsWith("GameData") && d.name == "" && d.url == "");

// need to use a file with a cfg extension to get the right fileType or you can't AddConfig on it

physicsUrlFile = new UrlDir.UrlFile(gameDataDir, new FileInfo(defaultPhysicsPath));

// Since it loaded the default config badly (sub node only) we clear it first

physicsUrlFile.configs.Clear();

// And reload it properly

ConfigNode physicsContent = ConfigNode.Load(defaultPhysicsPath);

physicsContent.name = "PHYSICSGLOBALS";

physicsUrlFile.AddConfig(physicsContent);

gameDataDir.files.Add(physicsUrlFile);

}

private void SaveModdedPhysics()

{

List<UrlDir.UrlConfig> configs = physicsUrlFile.configs;

if (configs.Count == 0)

{

logger.Info("No PHYSICSGLOBALS node found. No custom Physics config will be saved");

return;

}

if (configs.Count > 1)

{

logger.Info(configs.Count + " PHYSICSGLOBALS node found. A patch may be wrong. Using the first one");

}

configs[0].config.Save(physicsPath);

}

private bool IsCacheUpToDate()

{

Stopwatch sw = new Stopwatch();

sw.Start();

System.Security.Cryptography.SHA256 sha = System.Security.Cryptography.SHA256.Create();

System.Security.Cryptography.SHA256 filesha = System.Security.Cryptography.SHA256.Create();

UrlDir.UrlFile[] files = GameDatabase.Instance.root.AllConfigFiles.ToArray();

for (int i = 0; i < files.Length; i++)

{

// Hash the file path so the checksum change if files are moved

byte[] pathBytes = Encoding.UTF8.GetBytes(files[i].url);

sha.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0);

// hash the file content

byte[] contentBytes = File.ReadAllBytes(files[i].fullPath);

sha.TransformBlock(contentBytes, 0, contentBytes.Length, contentBytes, 0);

filesha.ComputeHash(contentBytes);

if (!filesSha.ContainsKey(files[i].url))

{

filesSha.Add(files[i].url, BitConverter.ToString(filesha.Hash));

}

else

{

logger.Warning("Duplicate fileSha key. This should not append. The key is " + files[i].url);

}

}

// Hash the mods dll path so the checksum change if dlls are moved or removed (impact NEEDS)

foreach (AssemblyLoader.LoadedAssembly dll in AssemblyLoader.loadedAssemblies)

{

string path = dll.url + "/" + dll.name;

byte[] pathBytes = Encoding.UTF8.GetBytes(path);

sha.TransformBlock(pathBytes, 0, pathBytes.Length, pathBytes, 0);

}

byte[] godsFinalMessageToHisCreation = Encoding.UTF8.GetBytes("We apologize for the inconvenience.");

sha.TransformFinalBlock(godsFinalMessageToHisCreation, 0, godsFinalMessageToHisCreation.Length);

configSha = BitConverter.ToString(sha.Hash);

sha.Clear();

filesha.Clear();

sw.Stop();

logger.Info("SHA generated in " + ((float)sw.ElapsedMilliseconds / 1000).ToString("F3") + "s");

logger.Info(" SHA = " + configSha);

bool useCache = false;

if (File.Exists(shaPath))

{

ConfigNode shaConfigNode = ConfigNode.Load(shaPath);

if (shaConfigNode != null && shaConfigNode.HasValue("SHA") && shaConfigNode.HasValue("version") && shaConfigNode.HasValue("KSPVersion"))

{

string storedSHA = shaConfigNode.GetValue("SHA");

string version = shaConfigNode.GetValue("version");

string kspVersion = shaConfigNode.GetValue("KSPVersion");

ConfigNode filesShaNode = shaConfigNode.GetNode("FilesSHA");

useCache = CheckFilesChange(files, filesShaNode);

useCache = useCache && storedSHA.Equals(configSha);

useCache = useCache && version.Equals(Assembly.GetExecutingAssembly().GetName().Version.ToString());

useCache = useCache && kspVersion.Equals(Versioning.version_major + "." + Versioning.version_minor + "." + Versioning.Revision + "." + Versioning.BuildID);

useCache = useCache && File.Exists(cachePath);

useCache = useCache && File.Exists(physicsPath);

useCache = useCache && File.Exists(techTreePath);

logger.Info("Cache SHA = " + storedSHA);

logger.Info("useCache = " + useCache);

}

}

return useCache;

}

private bool CheckFilesChange(UrlDir.UrlFile[] files, ConfigNode shaConfigNode)

{

bool noChange = true;

StringBuilder changes = new StringBuilder();

changes.Append("Changes :\n");

for (int i = 0; i < files.Length; i++)

{

ConfigNode fileNode = GetFileNode(shaConfigNode, files[i].url);

string fileSha = fileNode?.GetValue("SHA");

if (fileNode == null)

continue;

if (fileSha == null || filesSha[files[i].url] != fileSha)

{

changes.Append("Changed : " + fileNode.GetValue("filename") + ".cfg\n");

noChange = false;

}

}

for (int i = 0; i < files.Length; i++)

{

ConfigNode fileNode = GetFileNode(shaConfigNode, files[i].url);

if (fileNode == null)

{

changes.Append("Added : " + files[i].url + ".cfg\n");

noChange = false;

}

shaConfigNode.RemoveNode(fileNode);

}

foreach (ConfigNode fileNode in shaConfigNode.GetNodes())

{

changes.Append("Deleted : " + fileNode.GetValue("filename") + ".cfg\n");

noChange = false;

}

if (!noChange)

logger.Info(changes.ToString());

return noChange;

}

private ConfigNode GetFileNode(ConfigNode shaConfigNode, string filename)

{

for (int i = 0; i < shaConfigNode.nodes.Count; i++)

{

ConfigNode file = shaConfigNode.nodes[i];

if (file.name == "FILE" && file.GetValue("filename") == filename)

return file;

}

return null;

}

private void CreateCache(int patchedNodeCount)

{

ConfigNode shaConfigNode = new ConfigNode();

shaConfigNode.AddValue("SHA", configSha);

shaConfigNode.AddValue("version", Assembly.GetExecutingAssembly().GetName().Version.ToString());

shaConfigNode.AddValue("KSPVersion", Versioning.version_major + "." + Versioning.version_minor + "." + Versioning.Revision + "." + Versioning.BuildID);

ConfigNode filesSHANode = shaConfigNode.AddNode("FilesSHA");

ConfigNode cache = new ConfigNode();

cache.AddValue("patchedNodeCount", patchedNodeCount.ToString());

foreach (UrlDir.UrlConfig config in GameDatabase.Instance.root.AllConfigs)

{

ConfigNode node = cache.AddNode("UrlConfig");

node.AddValue("name", config.name);

node.AddValue("type", config.type);

node.AddValue("parentUrl", config.parent.url);

node.AddNode(config.config);

}

foreach (var file in GameDatabase.Instance.root.AllConfigFiles)

{

// "/Physics" is the node we created manually to loads the PHYSIC config

if (file.url != "/Physics" && filesSha.ContainsKey(file.url))

{

ConfigNode shaNode = filesSHANode.AddNode("FILE");

shaNode.AddValue("filename", file.url);

shaNode.AddValue("SHA", filesSha[file.url]);

filesSha.Remove(file.url);

}

}

logger.Info("Saving cache");

try

{

shaConfigNode.Save(shaPath);

}

catch (Exception e)

{

logger.Exception("Exception while saving the sha", e);

}

try

{

cache.Save(cachePath);

return;

}

catch (NullReferenceException e)

{

logger.Exception("NullReferenceException while saving the cache", e);

}

catch (Exception e)

{

logger.Exception("Exception while saving the cache", e);

}

try

{

logger.Error("An error occured while creating the cache. Deleting the cache files to avoid keeping a bad cache");

if (File.Exists(cachePath))

File.Delete(cachePath);

if (File.Exists(shaPath))

File.Delete(shaPath);

}

catch (Exception e)

{

logger.Exception("Exception while deleting the cache", e);

}

}

private void SaveModdedTechTree()

{

UrlDir.UrlConfig[] configs = GameDatabase.Instance.GetConfigs("TechTree");

if (configs.Length == 0)

{

logger.Info("No TechTree node found. No custom TechTree will be saved");

return;

}

if (configs.Length > 1)

{

logger.Info(configs.Length + " TechTree node found. A patch may be wrong. Using the first one");

}

ConfigNode techNode = new ConfigNode("TechTree");

techNode.AddNode(configs[0].config);

techNode.Save(techTreePath);

}

private void LoadCache()

{

// Clear the config DB

foreach (UrlDir.UrlFile files in GameDatabase.Instance.root.AllConfigFiles)

{

files.configs.Clear();

}

// And then load all the cached configs

ConfigNode cache = ConfigNode.Load(cachePath);

if (cache.HasValue("patchedNodeCount") && int.TryParse(cache.GetValue("patchedNodeCount"), out int patchedNodeCount))

status = "ModuleManager: " + patchedNodeCount + " patch" + (patchedNodeCount != 1 ? "es" : "") + " loaded from cache";

// Create the fake file where we load the physic config cache

UrlDir gameDataDir = GameDatabase.Instance.root.AllDirectories.First(d => d.path.EndsWith("GameData") && d.name == "" && d.url == "");

// need to use a file with a cfg extension to get the right fileType or you can't AddConfig on it

physicsUrlFile = new UrlDir.UrlFile(gameDataDir, new FileInfo(defaultPhysicsPath));

gameDataDir.files.Add(physicsUrlFile);

foreach (ConfigNode node in cache.nodes)

{

string name = node.GetValue("name");

string type = node.GetValue("type");

string parentUrl = node.GetValue("parentUrl");

UrlDir.UrlFile parent = GameDatabase.Instance.root.AllConfigFiles.FirstOrDefault(f => f.url == parentUrl);

if (parent != null)

{

parent.AddConfig(node.nodes[0]);

}

else

{

logger.Warning("Parent null for " + parentUrl);

}

}

progressFraction = 1;

logger.Info("Cache Loaded");

}

private void StatusUpdate(IPatchProgress progress)

{

progressFraction = progress.ProgressFraction;

status = "ModuleManager: " + progress.Counter.patchedNodes + " patch" + (progress.Counter.patchedNodes != 1 ? "es" : "") + " applied";

if (progress.Counter.warnings > 0)

status += ", found <color=yellow>" + progress.Counter.warnings + " warning" + (progress.Counter.warnings != 1 ? "s" : "") + "</yellow>";

if (progress.Counter.errors > 0)

status += ", found <color=orange>" + progress.Counter.errors + " error" + (progress.Counter.errors != 1 ? "s" : "") + "</color>";

if (progress.Counter.exceptions > 0)

status += ", encountered <color=red>" + progress.Counter.exceptions + " exception" + (progress.Counter.exceptions != 1 ? "s" : "") + "</color>";

}

private static void PurgeUnused()

{

foreach (UrlDir.UrlConfig mod in GameDatabase.Instance.root.AllConfigs.ToArray())

{

string name = mod.type.RemoveWS();

if (CommandParser.Parse(name, out name) != Command.Insert)

mod.parent.configs.Remove(mod);

}

}

#region Applying Patches

// Name is group 1, index is group 2, vector related filed is group 3, vector separator is group 4, operator is group 5

private static Regex parseValue = new Regex(@"([\w\&\-\.\?\*+/^!\(\) ]+(?:,[^*\d][\w\&\-\.\?\*\(\) ]*)*)(?:,(-?[0-9\*]+))?(?:\[((?:[0-9\*]+)+)(?:,(.))?\])?");

// ModifyNode applies the ConfigNode mod as a 'patch' to ConfigNode original, then returns the patched ConfigNode.

// it uses FindConfigNodeIn(src, nodeType, nodeName, nodeTag) to recurse.

public static ConfigNode ModifyNode(NodeStack original, ConfigNode mod, PatchContext context)

{

ConfigNode newNode = original.value.DeepCopy();

NodeStack nodeStack = original.ReplaceValue(newNode);

#region Values

#if LOGSPAM

string vals = "[ModuleManager] modding values";

#endif

foreach (ConfigNode.Value modVal in mod.values)

{

#if LOGSPAM

vals += "\n " + modVal.name + "= " + modVal.value;

#endif

Command cmd = CommandParser.Parse(modVal.name, out string valName);

Operator op;

if (valName.Length > 2 && valName[valName.Length - 2] == ',')

op = Operator.Assign;

else

op = OperatorParser.Parse(valName, out valName);

if (cmd == Command.Special)

{

ConfigNode.Value val = RecurseVariableSearch(valName, nodeStack.Push(mod), context);

if (val == null)

{

context.progress.Error(context.patchUrl, "Error - Cannot find value assigning command: " + valName);

continue;

}

if (op != Operator.Assign)

{

if (double.TryParse(modVal.value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double s)

&& double.TryParse(val.value, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out double os))

{

switch (op)

{

case Operator.Multiply:

val.value = (os * s).ToString(CultureInfo.InvariantCulture);

break;

case Operator.Divide:

val.value = (os / s).ToString(CultureInfo.InvariantCulture);

break;

case Operator.Add:

val.value = (os + s).ToString(CultureInfo.InvariantCulture);

break;

case Operator.Subtract:

val.value = (os - s).ToString(CultureInfo.InvariantCulture);

break;

case Operator.Exponentiate:

val.value = Math.Pow(os, s).ToString(CultureInfo.InvariantCulture);

break;

}

}

}

else

{

val.value = modVal.value;

}

continue;

}

Match match = parseValue.Match(valName);

if (!match.Success)

{

context.progress.Error(context.patchUrl, "Error - Cannot parse value modifying command: " + valName);

continue;

}

// Get the bits and pieces from the regexp

valName = match.Groups[1].Value;

// Get a position for editing a vector

int position = 0;

bool isPosStar = false;

if (match.Groups[3].Success)

{

if (match.Groups[3].Value == "*")

isPosStar = true;

else if (!int.TryParse(match.Groups[3].Value, out position))

{

context.progress.Error(context.patchUrl, "Error - Unable to parse number as number. Very odd.");

continue;

}

}

char seperator = ',';

if (match.Groups[4].Success)

{

seperator = match.Groups[4].Value[0];

}

// In this case insert the value at position index (with the same node names)

int index = 0;

bool isStar = false;

if (match.Groups[2].Success)

{

if (match.Groups[2].Value == "*")

isStar = true;

// can have "node,n *" (for *= ect)

else if (!int.TryParse(match.Groups[2].Value, out index))

{

context.progress.Error(context.patchUrl, "Error - Unable to parse number as number. Very odd.");

continue;

}

}

int valCount = 0;

for (int i=0; i<newNode.CountValues; i++)

if (newNode.values[i].name == valName)

valCount++;

string varValue;

switch (cmd)

{

case Command.Insert:

if (match.Groups[5].Success)

{

context.progress.Error(context.patchUrl, "Error - Cannot use operators with insert value: " + mod.name);

}

else

{

// Insert at the end by default

varValue = ProcessVariableSearch(modVal.value, nodeStack, context);

if (varValue != null)

InsertValue(newNode, match.Groups[2].Success ? index : int.MaxValue, valName, varValue);

else

context.progress.Error(context.patchUrl, "Error - Cannot parse variable search when inserting new key " + valName + " = " +

modVal.value);

}

break;

case Command.Replace:

if (match.Groups[2].Success || match.Groups[5].Success || valName.Contains('*')

|| valName.Contains('?'))

{

if (match.Groups[2].Success)

context.progress.Error(context.patchUrl, "Error - Cannot use index with replace (%) value: " + mod.name);

if (match.Groups[5].Success)

context.progress.Error(context.patchUrl, "Error - Cannot use operators with replace (%) value: " + mod.name);

if (valName.Contains('*') || valName.Contains('?'))

context.progress.Error(context.patchUrl, "Error - Cannot use wildcards (* or ?) with replace (%) value: " + mod.name);

}

else

{

varValue = ProcessVariableSearch(modVal.value, nodeStack, context);

if (varValue != null)

{

newNode.RemoveValues(valName);

newNode.AddValue(valName, varValue);

}

else

{

context.progress.Error(context.patchUrl, "Error - Cannot parse variable search when replacing (%) key " + valName + " = " +

modVal.value);

}

}

break;

case Command.Edit:

case Command.Copy:

// Format is @key = value or @key *= value or @key += value or @key -= value

// or @key,index = value or @key,index *= value or @key,index += value or @key,index -= value

while (index < valCount)

{

varValue = ProcessVariableSearch(modVal.value, nodeStack, context);

if (varValue != null)

{

string value = FindAndReplaceValue(

mod,

ref valName,

varValue, newNode,

op,

index,

out ConfigNode.Value origVal,

context,

match.Groups[3].Success,

position,

isPosStar,

seperator

);

if (value != null)

{

#if LOGSPAM

if (origVal.value != value)

vals += ": " + origVal.value + " -> " + value;

#endif

if (cmd != Command.Copy)

origVal.value = value;

else

newNode.AddValue(valName, value);

}

}

else

{

context.progress.Error(context.patchUrl, "Error - Cannot parse variable search when editing key " + valName + " = " + modVal.value);

}

if (isStar) index++;

else break;

}

break;

case Command.Delete:

if (match.Groups[5].Success)

{

context.progress.Error(context.patchUrl, "Error - Cannot use operators with delete (- or !) value: " + mod.name);

}

else if (match.Groups[2].Success)

{

while (index < valCount)

{

// If there is an index, use it.

ConfigNode.Value v = FindValueIn(newNode, valName, index);

if (v != null)

newNode.values.Remove(v);

if (isStar) index++;

else break;

}

}

else if (valName.Contains('*') || valName.Contains('?'))

{

// Delete all matching wildcard

ConfigNode.Value last = null;

while (true)

{

ConfigNode.Value v = FindValueIn(newNode, valName, index++);

if (v == last)

break;

last = v;

newNode.values.Remove(v);

}

}

else

{

// Default is to delete ALL values that match. (backwards compatibility)

newNode.RemoveValues(valName);

}

break;

case Command.Rename:

if (nodeStack.IsRoot)

{

context.progress.Error(context.patchUrl, "Error - Renaming nodes does not work on top nodes");

break;

}

newNode.name = modVal.value;

break;

case Command.Create:

if (match.Groups[2].Success || match.Groups[5].Success || valName.Contains('*')

|| valName.Contains('?'))

{

if (match.Groups[2].Success)

context.progress.Error(context.patchUrl, "Error - Cannot use index with create (&) value: " + mod.name);

if (match.Groups[5].Success)

context.progress.Error(context.patchUrl, "Error - Cannot use operators with create (&) value: " + mod.name);

if (valName.Contains('*') || valName.Contains('?'))

context.progress.Error(context.patchUrl, "Error - Cannot use wildcards (* or ?) with create (&) value: " + mod.name);

}

else

{

varValue = ProcessVariableSearch(modVal.value, nodeStack, context);

if (varValue != null)

{

if (!newNode.HasValue(valName))