using System;
using System.Diagnostics;
using System.Linq;

class Benchmark
{
    static Action[] Tests = 
    {
        LambdaInt32,
        LambdaString,
        FakeCachedLambdaInt32,
        FakeCachedLambdaString,
        GenericMethodGroupInt32,
        GenericMethodGroupString,
        NonGenericMethodGroupInt32,
        NonGenericMethodGroupString,
        StaticMethodOnGenericTypeInt32,
        StaticMethodOnGenericTypeString,
        InstanceMethodOnGenericTypeInt32,
        InstanceMethodOnGenericTypeString,
    };
    
    // Test methods
    private static void LambdaInt32()
    {
        Lambda<int>();
    }

    private static void LambdaString()
    {
        Lambda<string>();
    }
    
    private static void FakeCachedLambdaInt32()
    {
        FakeCachedLambda<int>();
    }

    private static void FakeCachedLambdaString()
    {
        FakeCachedLambda<string>();
    }

    private static void GenericMethodGroupInt32()
    {
        GenericMethodGroup<int>();
    }

    private static void GenericMethodGroupString()
    {
        GenericMethodGroup<string>();
    }

    private static void NonGenericMethodGroupInt32()
    {
        NonGenericMethodGroup<int>();
    }
    
    private static void NonGenericMethodGroupString()
    {
        NonGenericMethodGroup<string>();
    }

    private static void StaticMethodOnGenericTypeInt32()
    {
        StaticMethodOnGenericType<int>();
    }

    private static void StaticMethodOnGenericTypeString()
    {
        StaticMethodOnGenericType<string>();
    }
    
    private static void InstanceMethodOnGenericTypeInt32()
    {
        InstanceMethodOnGenericType<int>();
    }

    private static void InstanceMethodOnGenericTypeString()
    {
        InstanceMethodOnGenericType<string>();
    }

    // Methods called by the test methods
    private static void Lambda<T>()
    {
        Action foo = () => {};
        if (foo == null)
        {
            throw new Exception();
        }
    }

    private static void FakeCachedLambda<T>()
    {
        if (FakeLambdaCache<T>.CachedAction == null)
        {
            FakeLambdaCache<T>.CachedAction = FakeLambdaCache<T>.NoOp;
        }
        Action foo = FakeLambdaCache<T>.CachedAction;
        if (foo == null)
        {
            throw new Exception();
        }
    }
    
    private static class FakeLambdaCache<T>
    {
        internal static Action CachedAction;
        internal static void NoOp() {}
    }
    
    private static void GenericMethodGroup<T>()
    {
        Action foo = NoOp<T>;
        if (foo == null)
        {
            throw new Exception();
        }
    }

    private static void NonGenericMethodGroup<T>()
    {
        Action foo = NoOp;
        if (foo == null)
        {
            throw new Exception();
        }
    }
    
    private static void StaticMethodOnGenericType<T>()
    {
        Action foo = SampleGenericClass<T>.NoOpStatic;
        if (foo == null)
        {
            throw new Exception();
        }
    }

    private static void InstanceMethodOnGenericType<T>()
    {
        Action foo = ClassHolder<T>.SampleInstance.NoOpInstance;
        if (foo == null)
        {
            throw new Exception();
        }
    }
    
    private static void NoOp() {}
    private static void NoOp<T>() {}
    
    private class ClassHolder<T>
    {
        internal static SampleGenericClass<T> SampleInstance = new SampleGenericClass<T>();
    }
    
    private class SampleGenericClass<T>
    {
        internal static void NoOpStatic()
        {
        }

        internal void NoOpInstance()
        {
        }
    }
    
    // -------------- INFRASTRUCTURE BELOW HERE --------------
    const int Iterations = 10000000;
    
    static void Main()
    {
        Console.WriteLine("Environment: CLR {0} on {1}", Environment.Version, Environment.OSVersion);
        // Warm up
        RunTests(1, false, 0);
     
        int maxMethodLength = Tests.Select(x => x.Method.Name.Length).Max();
        
        // Real thing
        RunTests(Iterations, true, maxMethodLength);
    }
    
    static void RunTests(int count, bool displayResults, int maxLength)
    {
        foreach (Action action in Tests)
        {
            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < count; i++)
            {
                action();
            }
            sw.Stop();            
            if (displayResults)
            {
                Console.WriteLine("{0}: {1}ms", action.Method.Name.PadRight(maxLength),
                                  ((int) sw.ElapsedMilliseconds).ToString().PadLeft(6));
            }
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
        }
    }
}