ScriptParser.cs

using System.Diagnostics;
using System.Globalization;

namespace FLAC_Benchmark_H
{
    public static class ScriptParser
    {
        /// <summary>
        /// Expands script lines like "-preset[fast,medium] -j[1..4]" into all possible parameter combinations.
        /// Uses square brackets [ ] to avoid conflict with FLAC's { } syntax (e.g. --picture={...}).
        /// Supports both explicit text values (e.g. [fast, medium, slow]) and numeric ranges (e.g. [1..4]).
        /// Handles nested brackets correctly.
        /// </summary>
        /// <param name="input">Input script string</param>
        /// <returns>List of expanded strings</returns>
        public static List<string> ExpandScriptLine(string input)
        {
            // Base case: if there are no brackets, return the input as is
            if (string.IsNullOrWhiteSpace(input) || !input.Contains('[') || !input.Contains(']'))
            {
                return [input];
            }

            // Check for balanced brackets
            if (input.Count(c => c == '[') != input.Count(c => c == ']'))
            {
                Debug.WriteLine("Mismatched brackets in script: " + input);
                return []; // Invalid syntax
            }

            // Find the innermost [...] block
            int lastOpenIndex = -1;
            int firstCloseIndex = -1;

            for (int i = 0; i < input.Length; i++)
            {
                if (input[i] == '[')
                {
                    lastOpenIndex = i;
                }
                else if (input[i] == ']')
                {
                    firstCloseIndex = i;
                    break; // Found the first closing bracket after the last open
                }
            }

            // If no valid pair found, return as is
            if (lastOpenIndex == -1 || firstCloseIndex == -1 || lastOpenIndex > firstCloseIndex)
            {
                return [input];
            }

            // Extract parts: prefix, content, suffix
            string prefix = input[..lastOpenIndex];
            string content = input.Substring(lastOpenIndex + 1, firstCloseIndex - lastOpenIndex - 1);
            string suffix = input[(firstCloseIndex + 1)..];

            // Parse the innermost content
            List<string> parsedValues = ParseRange(content);

            List<string> result = [];

            // For each possible value from the innermost range, recursively expand the full string
            foreach (string value in parsedValues)
            {
                string newInput = prefix + value + suffix;
                List<string> expanded = ExpandScriptLine(newInput); // Recursive call
                result.AddRange(expanded);
            }

            // Remove duplicates and sort naturally
            return [.. result.Distinct().OrderBy(x => x, new NaturalStringComparer())];
        }

        /// <summary>
        /// Parses a range string like "fast, medium..slow, 4.5" into a list of strings.
        /// Handles explicit values and numeric ranges.
        /// Text values are processed as-is. Numeric ranges are expanded.
        /// Empty values (e.g. from "[m,]") are treated as empty strings.
        /// </summary>
        /// <param name="content">Comma-separated values and ranges</param>
        /// <returns>List of strings from parsed values/ranges</returns>
        private static List<string> ParseRange(string content)
        {
            List<string> values = [];

            // Split by comma and process each part
            foreach (string part in content.Split(','))
            {
                string trimmed = part.Trim(); // Remove leading/trailing whitespace

                if (trimmed.Contains(".."))
                {
                    // --- Handle numeric ranges ---
                    string[] segments = [.. trimmed.Split([".."], StringSplitOptions.None).Select(s => s.Trim())];

                    // Check for empty segments (e.g., from "1...2")
                    bool hasEmptySegment = segments.Take(segments.Length - 1).Any(s => string.IsNullOrEmpty(s));
                    if (hasEmptySegment)
                    {
                        // If there's an invalid ellipsis, treat the whole part as a single text value
                        values.Add(trimmed);
                    }
                    else if (segments.Length >= 2)
                    {
                        // Try to parse as a numeric range
                        if (double.TryParse(segments[0], NumberStyles.Float, CultureInfo.InvariantCulture, out double start) &&
                            double.TryParse(segments[1], NumberStyles.Float, CultureInfo.InvariantCulture, out double end))
                        {
                            // It's a valid numeric range, expand it
                            double step = 1.0;
                            if (segments.Length > 2 &&
                                double.TryParse(segments[2], NumberStyles.Float, CultureInfo.InvariantCulture, out double parsedStep))
                            {
                                step = Math.Abs(parsedStep);
                                if (step == 0)
                                {
                                    step = 1.0;
                                }
                            }

                            if (start <= end)
                            {
                                for (double i = start; Math.Round(i, 6) <= end; i += step)
                                {
                                    values.Add(Math.Round(i, 6).ToString(CultureInfo.InvariantCulture));
                                }
                            }
                            else
                            {
                                for (double i = start; Math.Round(i, 6) >= end; i -= step)
                                {
                                    values.Add(Math.Round(i, 6).ToString(CultureInfo.InvariantCulture));
                                }
                            }
                        }
                        else
                        {
                            // Not a numeric range, treat each non-empty segment as a text value
                            foreach (string? segment in segments)
                            {
                                if (!string.IsNullOrEmpty(segment))
                                {
                                    values.Add(segment);
                                }
                            }
                        }
                    }
                    else
                    {
                        // Edge case, add the whole trimmed string
                        values.Add(trimmed);
                    }
                }
                else
                {
                    // --- Handle explicit text values, INCLUDING empty ones ---
                    // Add the trimmed string, even if it's empty
                    values.Add(trimmed);
                }
            }

            // Remove duplicates (empty strings are also considered)
            return [.. values.Distinct()];
        }

        /// <summary>
        /// Compares strings using natural sorting (e.g., "file2.txt" before "file10.txt").
        /// Ensures parameters like 1.2 appear before 1.10 in output.
        /// </summary>
        private class NaturalStringComparer : IComparer<string?>
        {
            public int Compare(string? x, string? y)
            {
                return x == null && y == null ? 0 : x == null ? -1 : y == null ? 1 : CompareNatural(x, y);
            }

            private static int CompareNatural(string strA, string strB)
            {
                int i1 = 0, i2 = 0;
                while (i1 < strA.Length && i2 < strB.Length)
                {
                    if (char.IsDigit(strA[i1]) || char.IsDigit(strB[i2]))
                    {
                        // Parse numbers (including decimals)
                        bool hasDecimalA = false, hasDecimalB = false;
                        long wholeA = 0, wholeB = 0;
                        long fracA = 0, fracB = 0;
                        int fracDigitsA = 0, fracDigitsB = 0;

                        // Parse first number
                        while (i1 < strA.Length)
                        {
                            char c = strA[i1];
                            if (c == '.' && !hasDecimalA)
                            {
                                hasDecimalA = true;
                                i1++;
                                continue;
                            }
                            else if (char.IsDigit(c))
                            {
                                if (hasDecimalA)
                                {
                                    fracA = (fracA * 10) + (c - '0');
                                    fracDigitsA++;
                                }
                                else
                                {
                                    wholeA = (wholeA * 10) + (c - '0');
                                }
                                i1++;
                            }
                            else
                            {
                                break;
                            }
                        }

                        // Parse second number
                        while (i2 < strB.Length)
                        {
                            char c = strB[i2];
                            if (c == '.' && !hasDecimalB)
                            {
                                hasDecimalB = true;
                                i2++;
                                continue;
                            }
                            else if (char.IsDigit(c))
                            {
                                if (hasDecimalB)
                                {
                                    fracB = (fracB * 10) + (c - '0');
                                    fracDigitsB++;
                                }
                                else
                                {
                                    wholeB = (wholeB * 10) + (c - '0');
                                }
                                i2++;
                            }
                            else
                            {
                                break;
                            }
                        }

                        // Normalize fractional parts to same scale
                        int maxFracDigits = Math.Max(fracDigitsA, fracDigitsB);
                        long scaledA = (wholeA * (long)Math.Pow(10, maxFracDigits)) +
                                      (fracA * (long)Math.Pow(10, maxFracDigits - fracDigitsA));
                        long scaledB = (wholeB * (long)Math.Pow(10, maxFracDigits)) +
                                      (fracB * (long)Math.Pow(10, maxFracDigits - fracDigitsB));

                        if (scaledA != scaledB)
                        {
                            return scaledA.CompareTo(scaledB);
                        }
                    }
                    else
                    {
                        int result = char.ToLowerInvariant(strA[i1]).CompareTo(char.ToLowerInvariant(strB[i2]));
                        if (result != 0)
                        {
                            return result;
                        }

                        i1++;
                        i2++;
                    }
                }

                return strA.Length.CompareTo(strB.Length);
            }
        }
    }
}