// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using Microsoft.Extensions.StackTrace.Sources;
using ThrowingLibrary;
using Xunit;

namespace Microsoft.Extensions.Internal
{
    public class StackTraceHelperTest
    {
        [Fact]
        public void StackTraceHelper_IncludesLineNumbersForFiles()
        {
            // Arrange
            Exception exception = null;
            try
            {
                // Throwing an exception in the current assembly always seems to populate the full stack
                // trace regardless of symbol type. Crossing assembly boundaries ensures PortablePdbReader gets used
                // on desktop.
                Thrower.Throw();
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            Assert.Collection(stackFrames,
                frame =>
                {
                    Assert.Contains("Thrower.cs", frame.FilePath);
                    Assert.Equal(17, frame.LineNumber);
                },
                frame =>
                {
                    Assert.Contains("StackTraceHelperTest.cs", frame.FilePath);
                });
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForGenericMethods()
        {
            // Arrange
            var exception = Record.Exception(() => GenericMethod<string>(null));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.GenericMethod<T>(T val)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForMethodsWithOutParameters()
        {
            // Arrange
            var exception = Record.Exception(() => MethodWithOutParameter(out var value));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.MethodWithOutParameter(out int value)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForMethodsWithGenericOutParameters()
        {
            // Arrange
            var exception = Record.Exception(() => MethodWithGenericOutParameter("Test", out int value));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.MethodWithGenericOutParameter<TVal>(string a, out TVal value)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForMethodsWithRefParameters()
        {
            // Arrange
            var value = 0;
            var exception = Record.Exception(() => MethodWithRefParameter(ref value));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.MethodWithRefParameter(ref int value)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForMethodsWithGenericRefParameters()
        {
            // Arrange
            var value = 0;
            var exception = Record.Exception(() => MethodWithGenericRefParameter(ref value));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.MethodWithGenericRefParameter<TVal>(ref TVal value)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForMethodsWithNullableParameters()
        {
            // Arrange
            var value = 0;
            var exception = Record.Exception(() => MethodWithNullableParameter(value));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.MethodWithNullableParameter(Nullable<int> value)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_PrettyPrintsStackTraceForMethodsOnGenericTypes()
        {
            // Arrange
            var exception = Record.Exception(() => new GenericClass<int>().Throw(0));

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest+GenericClass<T>.Throw(T parameter)", methods[0]);
        }

        [Fact]
        public void StackTraceHelper_ProducesReadableOutput()
        {
            // Arrange
            var expectedCallStack = new List<string>()
            {
                "Microsoft.Extensions.Internal.StackTraceHelperTest.Iterator()+MoveNext()",
                "string.Join(string separator, IEnumerable<string> values)",
                "Microsoft.Extensions.Internal.StackTraceHelperTest+GenericClass<T>.GenericMethod<V>(ref V value)",
                "Microsoft.Extensions.Internal.StackTraceHelperTest.MethodAsync(int value)",
                "Microsoft.Extensions.Internal.StackTraceHelperTest.MethodAsync<TValue>(TValue value)",
                "Microsoft.Extensions.Internal.StackTraceHelperTest.Method(string value)",
                "Microsoft.Extensions.Internal.StackTraceHelperTest.StackTraceHelper_ProducesReadableOutput()",
            };

            Exception exception = null;
            try
            {
                Method("test");
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);
            var methodNames = stackFrames.Select(stackFrame => stackFrame.MethodDisplayInfo.ToString()).ToArray();

            // Assert
            Assert.Equal(expectedCallStack, methodNames);
        }

        [Fact]
        public void StackTraceHelper_DoesNotIncludeInstanceMethodsOnTypesWithStackTraceHiddenAttribute()
        {
            // Arrange
            var exception = Record.Exception(() => InvokeMethodOnTypeWithStackTraceHiddenAttribute());

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.ThrowCore()", methods[0]);
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.InvokeMethodOnTypeWithStackTraceHiddenAttribute()", methods[1]);
        }

        [Fact]
        public void StackTraceHelper_DoesNotIncludeStaticMethodsOnTypesWithStackTraceHiddenAttribute()
        {
            // Arrange
            var exception = Record.Exception(() => InvokeStaticMethodOnTypeWithStackTraceHiddenAttribute());

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.ThrowCore()", methods[0]);
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.InvokeStaticMethodOnTypeWithStackTraceHiddenAttribute()", methods[1]);
        }

        [Fact]
        public void StackTraceHelper_DoesNotIncludeMethodsWithStackTraceHiddenAttribute()
        {
            // Arrange
            var exception = Record.Exception(() => new TypeWithMethodWithStackTraceHiddenAttribute().Throw());

            // Act
            var stackFrames = StackTraceHelper.GetFrames(exception, out _);

            // Assert
            var methods = stackFrames.Select(frame => frame.MethodDisplayInfo.ToString()).ToArray();
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest.ThrowCore()", methods[0]);
            Assert.Equal("Microsoft.Extensions.Internal.StackTraceHelperTest+TypeWithMethodWithStackTraceHiddenAttribute.Throw()", methods[1]);
        }

        [Fact]
        public void GetFrames_DoesNotFailForDynamicallyGeneratedAssemblies()
        {
            // Arrange
            var action = (Action)Expression.Lambda(
                Expression.Throw(
                    Expression.New(typeof(Exception)))).Compile();
            var exception = Record.Exception(action);

            // Act
            var frames = StackTraceHelper.GetFrames(exception, out _).ToArray();

            // Assert
            var frame = frames[0];
            Assert.Null(frame.FilePath);
            // lambda_method{RandomNumber}(Closure )
            Assert.StartsWith("lambda_method", frame.MethodDisplayInfo.ToString());
            Assert.EndsWith("(Closure )", frame.MethodDisplayInfo.ToString());
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        async Task<string> MethodAsync(int value)
        {
            await Task.Delay(0);
            return GenericClass<byte>.GenericMethod(ref value);
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        async Task<string> MethodAsync<TValue>(TValue value)
        {
            return await MethodAsync(1);
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        string Method(string value)
        {
            return MethodAsync(value).GetAwaiter().GetResult();
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        static IEnumerable<string> Iterator()
        {
            yield return "Success";
            throw new Exception();
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void MethodWithOutParameter(out int value) => throw new Exception();

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void MethodWithGenericOutParameter<TVal>(string a, out TVal value) => throw new Exception();

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void MethodWithRefParameter(ref int value) => throw new Exception();

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void MethodWithGenericRefParameter<TVal>(ref TVal value) => throw new Exception();

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void MethodWithNullableParameter(int? value) => throw new Exception();

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void InvokeMethodOnTypeWithStackTraceHiddenAttribute() => new TypeWithStackTraceHiddenAttribute().Throw();

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        void InvokeStaticMethodOnTypeWithStackTraceHiddenAttribute() => TypeWithStackTraceHiddenAttribute.ThrowStatic();

        class GenericClass<T>
        {
            [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
            public static string GenericMethod<V>(ref V value)
            {
                var returnVal = "";
                for (var i = 0; i < 10; i++)
                {
                    returnVal += string.Join(", ", Iterator());
                }
                return returnVal;
            }

            [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
            public void Throw(T parameter) => throw new Exception();
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        private void GenericMethod<T>(T val) where T : class => throw new Exception();

        private class StackTraceHiddenAttribute : Attribute
        {
        }

        [StackTraceHidden]
        private class TypeWithStackTraceHiddenAttribute
        {
            [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
            public void Throw() => ThrowCore();

            [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
            public static void ThrowStatic() => ThrowCore();
        }

        private class TypeWithMethodWithStackTraceHiddenAttribute
        {
            [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
            [StackTraceHidden]
            public void MethodWithStackTraceHiddenAttribute()
            {
                ThrowCore();
            }

            [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
            public void Throw() => MethodWithStackTraceHiddenAttribute();
        }

        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
        private static void ThrowCore() => throw new Exception();
    }
}
