// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
 
#nullable disable
 
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.Shared.Extensions;
 
namespace Roslyn.VisualStudio.DiagnosticsWindow;
 
/// <summary>
/// Interaction logic for TelemetryPanel.xaml
/// </summary>
public partial class TelemetryPanel : UserControl
{
    public TelemetryPanel()
    {
        InitializeComponent();
    }
 
    private void OnDump(object sender, RoutedEventArgs e)
    {
        _ = OnDumpImplAsync();
 
        async Task OnDumpImplAsync()
        {
            using (Disable(DumpButton))
            using (Disable(CopyButton))
            {
                GenerationProgresBar.IsIndeterminate = true;
 
                var text = await Task.Run(GetTelemetryString).ConfigureAwait(true);
 
                this.Result.Text = text;
 
                GenerationProgresBar.IsIndeterminate = false;
            }
        }
    }
 
    private void OnCopy(object sender, RoutedEventArgs e)
    {
        Clipboard.SetText(this.Result.Text);
    }
 
    private static string GetTelemetryString()
    {
        var fixAllScopeValues = Enum.GetValues(typeof(FixAllScope));
 
        var sb = new StringBuilder();
        var seenType = new HashSet<Type>();
 
        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
        {
            var result = ScanAssembly(assembly);
            if (result.Length > 0)
            {
                sb.AppendLine($"Searching: {assembly.FullName}");
                sb.AppendLine(result);
            }
        }
 
        return sb.ToString();
 
        string ScanAssembly(Assembly assembly)
        {
            var typeDiscovered = new StringBuilder();
            try
            {
                foreach (var module in assembly.GetModules())
                {
                    foreach (var type in module.GetTypes())
                    {
                        ScanType(type, typeDiscovered);
                    }
                }
            }
            catch
            {
                // ignore
            }
 
            return typeDiscovered.ToString();
        }
 
        void ScanType(Type type, StringBuilder typeDiscovered)
        {
            type = type.GetTypeForTelemetry();
 
            if (!seenType.Add(type))
            {
                return;
            }
 
            RecordIfCodeAction(type, typeDiscovered);
 
            foreach (var nestedTypeInfo in type.GetNestedTypes(BindingFlags.Public | BindingFlags.NonPublic))
            {
                ScanType(nestedTypeInfo, typeDiscovered);
            }
        }
 
        void RecordIfCodeAction(Type type, StringBuilder typeDiscovered)
        {
            if (!IsCodeAction(type))
            {
                return;
            }
 
            var telemetryId = type.GetTelemetryId();
 
            typeDiscovered.AppendLine($"Found: {type.FullName}: {telemetryId.ToString()}");
        }
 
        bool IsCodeAction(Type type)
        {
            if (type == null)
            {
                return false;
            }
 
            var codeActionType = typeof(CodeAction);
            return codeActionType.IsAssignableFrom(type);
        }
    }
 
    private static IDisposable Disable(UIElement control)
    {
        control.IsEnabled = false;
        return new RAII(() => control.IsEnabled = true);
    }
 
    private sealed class RAII : IDisposable
    {
        private readonly Action _action;
 
        public RAII(Action disposeAction)
        {
            _action = disposeAction;
        }
        public void Dispose()
        {
            _action?.Invoke();
        }
    }
}