Lithium/Lithium/helper.cs

using System;
using System.Globalization;
using System.IO;
using System.Text.RegularExpressions;

namespace Lua
{
    static class Helper
    {
        /// <summary>
        // AA0030
        /// </summary>
        public static string[] ReadLinesSafe(string path)
        {
            try
            {
                if (!File.Exists(path)) return Array.Empty<string>();
                return File.ReadAllLines(path);
            }
            catch
            {
                // AA0031
                return Array.Empty<string>();
            }
        }

        /// <summary>
        // AA0032
        /// </summary>
        public static bool ParseBoolFromAssignment(string line, string key, out bool result)
        {
            result = false;
            var idx = line.IndexOf('=');
            if (idx < 0) return false;

            var lhs = line.Substring(0, idx).Trim();
            if (!string.Equals(lhs, key, StringComparison.OrdinalIgnoreCase)) return false;

            var rhs = line.Substring(idx + 1).Trim();
            if (rhs.Equals("true", StringComparison.OrdinalIgnoreCase))
            {
                result = true;
                return true;
            }
            if (rhs.Equals("false", StringComparison.OrdinalIgnoreCase))
            {
                result = false;
                return true;
            }

            // AA0033
            return bool.TryParse(rhs, out result);
        }

        // AA0034
        public static bool ParseIntFromAssignment(string line, string key, out int result)
        {
            result = 0;
            var idx = line.IndexOf('=');
            if (idx < 0) return false;

            var lhs = line.Substring(0, idx).Trim();
            if (!string.Equals(lhs, key, StringComparison.OrdinalIgnoreCase)) return false;

            var rhs = line.Substring(idx + 1).Trim();
            return int.TryParse(rhs, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
        }

        // AA0035
        public static bool ParseStringFromAssignment(string line, string key, out string result)
        {
            result = null;
            var idx = line.IndexOf('=');
            if (idx < 0) return false;

            var lhs = line.Substring(0, idx).Trim();
            if (!string.Equals(lhs, key, StringComparison.OrdinalIgnoreCase)) return false;

            result = line.Substring(idx + 1).Trim();

            // AA0036 - Fixed: Check length before substring to avoid negative index
            if (result.Length >= 2 && ((result.StartsWith("\"") && result.EndsWith("\"")) ||
                (result.StartsWith("'") && result.EndsWith("'"))))
            {
                result = result.Substring(1, result.Length - 2);
            }
            return true;
        }

        // AA0037
        public static bool ParseConsoleColorFromAssignment(string line, string key, out ConsoleColor color)
        {
            color = ConsoleColor.White;
            if (!ParseStringFromAssignment(line, key, out var s)) return false;
            return Enum.TryParse(s, true, out color);
        }

        /// <summary>
        // AA0038
        /// </summary>
        public static bool TryParseRecoilLine(string line, out string name, out double recoilX, out double recoilY)
        {
            name = null;
            recoilX = 0;
            recoilY = 0;

            // AA0039
            var pattern = @"\[\s*[""'](.+?)[""']\s*\]\s*=\s*\{\s*recoilX\s*=\s*([-\d\.eE]+)\s*,\s*recoilY\s*=\s*([-\d\.eE]+)\s*\}";
            var match = Regex.Match(line, pattern, RegexOptions.IgnoreCase);
            if (!match.Success) return false;

            name = match.Groups[1].Value.Trim();
            return double.TryParse(match.Groups[2].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out recoilX) &&
                   double.TryParse(match.Groups[3].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out recoilY);
        }

        /// <summary>
        // AA0040
        /// </summary>
        public static int SafeClampIndex(int idx, int size)
        {
            if (size <= 0) return 0;
            if (idx < 0) return 0;
            if (idx >= size) return size - 1;
            return idx;
        }

        public static bool ParseQuickSwap(string line, out int[] keys, out string targetOperator)
        {
            keys = null;
            targetOperator = null;

            var idx = line.IndexOf('=');
            if (idx < 0) return false;

            var lhs = line.Substring(0, idx).Trim();
            if (!string.Equals(lhs, "quickSwap", StringComparison.OrdinalIgnoreCase)) return false;

            var rhs = line.Substring(idx + 1).Trim();
            var parts = rhs.Split(new[] { "=>" }, StringSplitOptions.None);
            if (parts.Length != 2) return false;

            var keyPart = parts[0].Trim();
            var opPart = parts[1].Trim();

            if (opPart.Length >= 2 && ((opPart.StartsWith("\"") && opPart.EndsWith("\"")) ||
                                       (opPart.StartsWith("'") && opPart.EndsWith("'"))))
            {
                opPart = opPart.Substring(1, opPart.Length - 2);
            }

            targetOperator = opPart;

            var keyStrings = keyPart.Split('+');
            var keyList = new System.Collections.Generic.List<int>();
            foreach (var kStr in keyStrings)
            {
                var trimmed = kStr.Trim();
                int vk = 0;
                if (trimmed.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
                {
                    try { vk = Convert.ToInt32(trimmed, 16); } catch { return false; }
                }
                else if (int.TryParse(trimmed, out int val))
                {
                    vk = val;
                }
                else
                {
                    return false;
                }
                keyList.Add(vk);
            }

            if (keyList.Count == 0) return false;

            keys = keyList.ToArray();
            return true;
        }
    }
}