#nullable disable
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
namespace StardewModdingAPI.Toolkit.Framework.Clients.Wiki
{
/// A set of changes which can be applied to a mod data field.
public class ChangeDescriptor
{
/*********
** Accessors
*********/
/// The values to add to the field.
public ISet Add { get; }
/// The values to remove from the field.
public ISet Remove { get; }
/// The values to replace in the field, if matched.
public IReadOnlyDictionary Replace { get; }
/// Whether the change descriptor would make any changes.
public bool HasChanges { get; }
/// Format a raw value into a normalized form.
public Func FormatValue { get; }
/*********
** Public methods
*********/
/// Construct an instance.
/// The values to add to the field.
/// The values to remove from the field.
/// The values to replace in the field, if matched.
/// Format a raw value into a normalized form.
public ChangeDescriptor(ISet add, ISet remove, IReadOnlyDictionary replace, Func formatValue)
{
this.Add = add;
this.Remove = remove;
this.Replace = replace;
this.HasChanges = add.Any() || remove.Any() || replace.Any();
this.FormatValue = formatValue;
}
/// Apply the change descriptors to a comma-delimited field.
/// The raw field text.
/// Returns the modified field.
public string ApplyToCopy(string rawField)
{
// get list
List values = !string.IsNullOrWhiteSpace(rawField)
? new List(rawField.Split(','))
: new List();
// apply changes
this.Apply(values);
// format
if (rawField == null && !values.Any())
return null;
return string.Join(", ", values);
}
/// Apply the change descriptors to the given field values.
/// The field values.
/// Returns the modified field values.
public void Apply(List values)
{
// replace/remove values
if (this.Replace.Any() || this.Remove.Any())
{
for (int i = values.Count - 1; i >= 0; i--)
{
string value = this.FormatValue(values[i]?.Trim() ?? string.Empty);
if (this.Remove.Contains(value))
values.RemoveAt(i);
else if (this.Replace.TryGetValue(value, out string newValue))
values[i] = newValue;
}
}
// add values
if (this.Add.Any())
{
HashSet curValues = new HashSet(values.Select(p => p?.Trim() ?? string.Empty), StringComparer.OrdinalIgnoreCase);
foreach (string add in this.Add)
{
if (!curValues.Contains(add))
{
values.Add(add);
curValues.Add(add);
}
}
}
}
///
public override string ToString()
{
if (!this.HasChanges)
return string.Empty;
List descriptors = new List(this.Add.Count + this.Remove.Count + this.Replace.Count);
foreach (string add in this.Add)
descriptors.Add($"+{add}");
foreach (string remove in this.Remove)
descriptors.Add($"-{remove}");
foreach (var pair in this.Replace)
descriptors.Add($"{pair.Key} → {pair.Value}");
return string.Join(", ", descriptors);
}
/// Parse a raw change descriptor string into a model.
/// The raw change descriptor.
/// The human-readable error message describing any invalid values that were ignored.
/// Format a raw value into a normalized form if needed.
public static ChangeDescriptor Parse(string descriptor, out string[] errors, Func formatValue = null)
{
// init
formatValue ??= p => p;
var add = new HashSet(StringComparer.OrdinalIgnoreCase);
var remove = new HashSet(StringComparer.OrdinalIgnoreCase);
var replace = new Dictionary(StringComparer.OrdinalIgnoreCase);
// parse each change in the descriptor
if (!string.IsNullOrWhiteSpace(descriptor))
{
List rawErrors = new List();
foreach (string rawEntry in descriptor.Split(','))
{
// normalize entry
string entry = rawEntry.Trim();
if (entry == string.Empty)
continue;
// parse as replace (old value → new value)
if (entry.Contains('→'))
{
string[] parts = entry.Split(new[] { '→' }, 2);
string oldValue = formatValue(parts[0].Trim());
string newValue = formatValue(parts[1].Trim());
if (oldValue == string.Empty)
{
rawErrors.Add($"Failed parsing '{rawEntry}': can't map from a blank old value. Use the '+value' format to add a value.");
continue;
}
if (newValue == string.Empty)
{
rawErrors.Add($"Failed parsing '{rawEntry}': can't map to a blank value. Use the '-value' format to remove a value.");
continue;
}
replace[oldValue] = newValue;
}
// else as remove
else if (entry.StartsWith("-"))
{
entry = formatValue(entry.Substring(1).Trim());
remove.Add(entry);
}
// else as add
else
{
if (entry.StartsWith("+"))
entry = formatValue(entry.Substring(1).Trim());
add.Add(entry);
}
}
errors = rawErrors.ToArray();
}
else
errors = Array.Empty();
// build model
return new ChangeDescriptor(
add: add,
remove: remove,
replace: new ReadOnlyDictionary(replace),
formatValue: formatValue
);
}
}
}