using System;

using System.Text;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Globalization;

using System.Runtime.CompilerServices;

​

public class Program

{

    // Define an enum to test with

    public enum TestEnum

    {

        Value1 = 1,

        Value2 = 2,

        Value3 = 3,

        Value10 = 10,

        Value100 = 100,

        VeryLongEnumNameForTesting = 999

    }

    // Cache for the optimized version with memoization

    private static readonly Dictionary<(Type, string), object> enumCache = new Dictionary<(Type, string), object>();

    // Test input data - mix of enum names, integers, invalid values, etc.

    private static readonly string[] testInputs = new string[] {

        "Value1", "Value2", "Value3", "Value10", "Value100", "VeryLongEnumNameForTesting",

        "1", "2", "3", "10", "100", "999",

        "", null, "InvalidValue", "999999"

    };

    public static void Main()

    {

        const int iterations = 10000;

        const int warmupIterations = 500;

        // Validate that all implementations return the same results

        ValidateImplementations();

        // Warmup

        Console.WriteLine("Warming up...");

        for (int i = 0; i < warmupIterations; i++)

        {

            foreach (var input in testInputs)

            {

                Original_StringToEnum<TestEnum>(input);

                Optimized1_StringToEnum<TestEnum>(input);

                Optimized2_StringToEnum<TestEnum>(input);

                Optimized3_StringToEnum<TestEnum>(input);

            }

        }

        // Define our benchmark methods

        var methods = new List<(string name, Func<TestEnum[]> method)>

        {

            ("Original", () => {

                var results = new TestEnum[testInputs.Length];

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

                    results[i] = Original_StringToEnum<TestEnum>(testInputs[i]);

                return results;

            }),

            ("Optimized1", () => {

                var results = new TestEnum[testInputs.Length];

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

                    results[i] = Optimized1_StringToEnum<TestEnum>(testInputs[i]);

                return results;

            }),

            ("Optimized2", () => {

                var results = new TestEnum[testInputs.Length];

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

                    results[i] = Optimized2_StringToEnum<TestEnum>(testInputs[i]);

                return results;

            }),

            ("Optimized3", () => {

                var results = new TestEnum[testInputs.Length];

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

                    results[i] = Optimized3_StringToEnum<TestEnum>(testInputs[i]);

                return results;

            })

        };

        // Run benchmarks and collect results

        var benchmarkResults = new List<BenchmarkResult>();

        foreach (var (name, method) in methods)

        {

            Console.WriteLine($"\nBenchmarking {name}");

            var result = BenchmarkMethod(name, iterations, method);

            benchmarkResults.Add(new BenchmarkResult { 

                Name = name, 

                AverageTime = result.Average, 

                MinTime = result.Min, 

                MaxTime = result.Max, 

                MemoryUsage = result.MemoryUsage 

            });

        }

        // Print summary results

        Console.WriteLine("\n===== BENCHMARK SUMMARY =====");

        foreach (var result in benchmarkResults)

        {

            Console.WriteLine($"{result.Name,-10} - Avg: {result.AverageTime,8:F3}ms, Min: {result.MinTime,8:F3}ms, Max: {result.MaxTime,8:F3}ms, Memory: {result.MemoryUsage,8:N0} bytes");

        }

        // Find and highlight the fastest method

        var fastestMethod = benchmarkResults.OrderBy(r => r.AverageTime).First();

        var lowestMemoryMethod = benchmarkResults.OrderBy(r => r.MemoryUsage).First();

        Console.WriteLine("\n===== RESULTS =====");

        Console.WriteLine($"FASTEST: {fastestMethod.Name} ({fastestMethod.AverageTime:F3}ms)");

        Console.WriteLine($"LOWEST MEMORY: {lowestMemoryMethod.Name} ({lowestMemoryMethod.MemoryUsage:N0} bytes)");

        // Show performance differences compared to original

        var originalResult = benchmarkResults.First(r => r.Name == "Original");

        Console.WriteLine("\n===== PERFORMANCE COMPARISON =====");

        foreach (var result in benchmarkResults.Where(r => r.Name != "Original"))

        {

            double timeImprovement = (originalResult.AverageTime - result.AverageTime) / originalResult.AverageTime * 100;

            double memoryImprovement = (originalResult.MemoryUsage - result.MemoryUsage) / (double)originalResult.MemoryUsage * 100;

            Console.WriteLine($"{result.Name} vs Original: " +

                             $"Time: {(timeImprovement >= 0 ? "faster by" : "slower by")} {Math.Abs(timeImprovement):F2}%, " +

                             $"Memory: {(memoryImprovement >= 0 ? "reduced by" : "increased by")} {Math.Abs(memoryImprovement):F2}%");

        }

    }

    // Validate that all implementations return the same results

    private static void ValidateImplementations()

    {

        Console.WriteLine("Validating implementation correctness...");

        bool allValid = true;

        foreach (var input in testInputs)

        {

            try

            {

                var original = Original_StringToEnum<TestEnum>(input);

                var opt1 = Optimized1_StringToEnum<TestEnum>(input);

                var opt2 = Optimized2_StringToEnum<TestEnum>(input);

                var opt3 = Optimized3_StringToEnum<TestEnum>(input);

                if (!EqualityComparer<TestEnum>.Default.Equals(original, opt1) ||

                    !EqualityComparer<TestEnum>.Default.Equals(original, opt2) ||

                    !EqualityComparer<TestEnum>.Default.Equals(original, opt3))

                {

                    Console.WriteLine($"Inconsistent results for input '{input ?? "null"}': " +

                                     $"Original={original}, Opt1={opt1}, Opt2={opt2}, Opt3={opt3}");

                    allValid = false;

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine($"Error validating input '{input ?? "null"}': {ex.Message}");

                allValid = false;

            }

        }

        if (allValid)

        {

            Console.WriteLine("All implementations return consistent results.");

        }

        else

        {

            Console.WriteLine("WARNING: Implementations return different results!");

        }

    }

    private static (double Average, double Min, double Max, long MemoryUsage) BenchmarkMethod(

        string name, 

        int iterations, 

        Func<TestEnum[]> method)

    {

        const int trials = 5;

        var times = new double[trials];

        long memoryUsage = 0;

        for (int trial = 0; trial < trials; trial++)

        {

            // Force garbage collection before each trial

            GC.Collect();

            GC.WaitForPendingFinalizers();

            GC.Collect();

            // Measure memory before (only on first trial)

            long memoryBefore = trial == 0 ? GC.GetTotalMemory(true) : 0;

            var sw = Stopwatch.StartNew();

            for (int i = 0; i < iterations; i++)

            {

                method();

            }

            sw.Stop();

            // Measure memory after (only on first trial)

            long memoryAfter = trial == 0 ? GC.GetTotalMemory(false) : 0;

            if (trial == 0)

            {

                memoryUsage = memoryAfter - memoryBefore;

            }

            times[trial] = sw.ElapsedMilliseconds;

            Console.WriteLine($"{name} Trial {trial + 1}: {times[trial]:F3}ms");

        }

        return (

            Average: times.Average(),

            Min: times.Min(),

            Max: times.Max(),

            MemoryUsage: memoryUsage

        );

    }

    // Helper class for benchmark results

    public class BenchmarkResult

    {

        public string Name { get; set; }

        public double AverageTime { get; set; }

        public double MinTime { get; set; }

        public double MaxTime { get; set; }

        public long MemoryUsage { get; set; }

    }

    // Original Implementation - Fixed to handle exceptions

    public static T Original_StringToEnum<T>(string Value)

    {

        if (string.IsNullOrEmpty(Value))

        {

            return default;

        }

        else if (IsInteger(Value))

        {

            try

            {

                var result = (T)Enum.ToObject(typeof(T), BC_Fmt.CInt(Value));

                if (!Enum.IsDefined(typeof(T), result))

                {

                    return default;

                }

                return result;

            }

            catch

            {

                return default;

            }

        }

        else

        {

            try

            {

                T res = (T)Enum.Parse(typeof(T), Value);

                if (!Enum.IsDefined(typeof(T), res))

                {

                    return default;

                }

                return res;

            }

            catch

            {

                return default;

            }

        }

    }

    // Optimized Implementation 1: Using TryParse to avoid exceptions

    public static T Optimized1_StringToEnum<T>(string Value) where T : struct

    {

        if (string.IsNullOrEmpty(Value))

        {

            return default;

        }

        // Fast path for integer values

        if (int.TryParse(Value, out int intValue))

        {

            try

            {

                T result = (T)Enum.ToObject(typeof(T), intValue);

                if (Enum.IsDefined(typeof(T), result))

                {

                    return result;

                }

            }

            catch

            {

                // Fall through to default

            }

            return default;

        }

        // String path using TryParse to avoid exceptions

        if (Enum.TryParse<T>(Value, true, out T parsedValue) && 

            Enum.IsDefined(typeof(T), parsedValue))

        {

            return parsedValue;

        }

        return default;

    }

    // Optimized Implementation 2: Using caching/memoization for parsed values

    public static T Optimized2_StringToEnum<T>(string Value) where T : struct

    {

        if (string.IsNullOrEmpty(Value))

        {

            return default;

        }

        var key = (typeof(T), Value);

        // Check if we have this value cached

        if (enumCache.TryGetValue(key, out object cachedValue))

        {

            return (T)cachedValue;

        }

        // Parse the value

        T result;

        if (int.TryParse(Value, out int intValue))

        {

            try

            {

                result = (T)Enum.ToObject(typeof(T), intValue);

                if (!Enum.IsDefined(typeof(T), result))

                {

                    result = default;

                }

            }

            catch

            {

                result = default;

            }

        }

        else if (Enum.TryParse<T>(Value, true, out T parsedValue) && 

                Enum.IsDefined(typeof(T), parsedValue))

        {

            result = parsedValue;

        }

        else

        {

            result = default;

        }

        // Cache the result

        enumCache[key] = result;

        return result;

    }

    // Optimized Implementation 3: Fast path for common cases, without struct constraint

    public static T Optimized3_StringToEnum<T>(string Value)

    {

        if (string.IsNullOrEmpty(Value))

        {

            return default;

        }

        Type enumType = typeof(T);

        // Fast path for integer values

        if (Value.Length > 0 && char.IsDigit(Value[0]))

        {

            // Quick path for single-digit integers (very common)

            if (Value.Length == 1)

            {

                int digit = Value[0] - '0';

                try

                {

                    T result = (T)Enum.ToObject(enumType, digit);

                    if (Enum.IsDefined(enumType, result))

                    {

                        return result;

                    }

                }

                catch

                {

                    // Fall through to default

                }

                return default;

            }

            // For larger integers, use TryParse

            if (int.TryParse(Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out int intValue))

            {

                try

                {

                    T result = (T)Enum.ToObject(enumType, intValue);

                    if (Enum.IsDefined(enumType, result))

                    {

                        return result;

                    }

                }

                catch

                {

                    // Fall through to default

                }

                return default;

            }

        }

        // String path - use Parse with exception handling since we can't use TryParse<T>

        try

        {

            T result = (T)Enum.Parse(enumType, Value, true);

            if (Enum.IsDefined(enumType, result))

            {

                return result;

            }

        }

        catch

        {

            // Fall through to default

        }

        return default;

    }

    // Helper functions

    public static bool IsInteger(string Value)

    {

        // Performance test: https://dotnetfiddle.net/h02lLS

        if (string.IsNullOrEmpty(Value))

        {

            return false;

        }

​

        ReadOnlySpan<char> span = Value.AsSpan().Trim();

        int startIndex = 0;

​

        // Check for single leading + or -

        if (span.Length > 0 && (span[0] == '-' || span[0] == '+'))

        {

            if (span.Length == 1)

            {

                return false;

            }

            startIndex = 1;

        }

​

        // Fast path: check if all remaining characters are digits

        for (int i = startIndex; i < span.Length; i++)

        {

            if ((uint)(span[i] - '0') > 9)

            {

                return false;

            }

        }

​

        return true;

    }

    public static class BC_Fmt

    {

        public static int CInt<T>(T Value)

        {

            if (Value == null)

            {

                throw new ArgumentNullException(nameof(Value), "BC_Fmt.CInt() failed to convert Value is null");

            }

​

            // Optimized for string input, which is the most common case

            if (Value is string strValue)

            {

                // Fast path for pure integers

                if (int.TryParse(strValue, out int result))

                {

                    return result;

                }

​

                // Fall back to double parsing for decimal numbers

                if (double.TryParse(strValue, out double dblResult))

                {

                    return (int)dblResult;

                }

​

                throw new FormatException($"BC_Fmt.CInt() failed to convert string '{strValue}' to int");

            }

​

            // Fall back to original conversion for non-string types

            if (Value is IConvertible convertible)

            {

                return convertible.ToInt32(null);

            }

​

            throw new InvalidCastException($"BC_Fmt.CInt() failed to convert {Value.GetType()} to int");

        }

    }

}