FieldNameScorer.cs

namespace TxFormFieldMapper;

internal static class FieldNameScorer
{
    public static double Score(FieldNameCandidate left, FieldNameCandidate right)
    {
        if (left.Normalized.Length == 0 || right.Normalized.Length == 0)
        {
            return 0;
        }

        if (string.Equals(left.Original, right.Original, StringComparison.Ordinal))
        {
            return 1;
        }

        if (string.Equals(left.Normalized, right.Normalized, StringComparison.Ordinal))
        {
            return 0.99;
        }

        return new[]
        {
            TokenSetScore(left.Tokens, right.Tokens),
            TokenContainmentScore(left.Tokens, right.Tokens),
            LevenshteinScore(left.Normalized, right.Normalized)
        }.Max();
    }

    private static double TokenSetScore(IReadOnlySet<string> left, IReadOnlySet<string> right)
    {
        if (left.Count == 0 || right.Count == 0)
        {
            return 0;
        }

        var intersection = left.Count(token => right.Contains(token));
        var union = left.Union(right, StringComparer.OrdinalIgnoreCase).Count();

        return (double)intersection / union;
    }

    private static double TokenContainmentScore(IReadOnlySet<string> left, IReadOnlySet<string> right)
    {
        if (left.Count == 0 || right.Count == 0)
        {
            return 0;
        }

        var intersection = left.Count(token => right.Contains(token));
        var smallerSetSize = Math.Min(left.Count, right.Count);
        var largerSetSize = Math.Max(left.Count, right.Count);

        if (intersection != smallerSetSize)
        {
            return 0;
        }

        return smallerSetSize == largerSetSize ? 0.99 : 0.86;
    }

    private static double LevenshteinScore(string left, string right)
    {
        var maxLength = Math.Max(left.Length, right.Length);
        if (maxLength == 0)
        {
            return 1;
        }

        return 1 - ((double)LevenshteinDistance(left, right) / maxLength);
    }

    private static int LevenshteinDistance(string left, string right)
    {
        var previous = new int[right.Length + 1];
        var current = new int[right.Length + 1];

        for (var j = 0; j <= right.Length; j++)
        {
            previous[j] = j;
        }

        for (var i = 1; i <= left.Length; i++)
        {
            current[0] = i;

            for (var j = 1; j <= right.Length; j++)
            {
                var cost = left[i - 1] == right[j - 1] ? 0 : 1;
                current[j] = Math.Min(
                    Math.Min(current[j - 1] + 1, previous[j] + 1),
                    previous[j - 1] + cost);
            }

            (previous, current) = (current, previous);
        }

        return previous[right.Length];
    }
}