// 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 Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.Operations;
 
namespace Microsoft.Extensions.LocalAnalyzers.CallAnalysis;
 
public partial class CallAnalyzer
{
    /// <summary>
    /// Enables call analysis classes to register callbacks.
    /// </summary>
    internal sealed class Registrar
    {
        private readonly State _state;
 
        internal Registrar(State state, Compilation compilation)
        {
            _state = state;
            Compilation = compilation;
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever the given method is invoked directly in code.
        /// </summary>
        /// <remarks>
        /// Note that this is not designed for use with interface methods.
        /// </remarks>
        public void RegisterMethod(IMethodSymbol method, Action<OperationAnalysisContext, IInvocationOperation> action)
        {
            if (!_state.Methods.TryGetValue(method, out var l))
            {
                l = [];
                _state.Methods.Add(method, l);
            }
 
            l.Add(action);
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever the given method overloads are invoked directly in code.
        /// </summary>
        /// <remarks>
        /// Note that this is not designed for use with interface methods.
        /// </remarks>
        public void RegisterMethods(string typeName, string methodName, Action<OperationAnalysisContext, IInvocationOperation> action)
        {
            var dict = new Dictionary<string, string[]>
            {
                { typeName, new[] { methodName } },
            };
 
            RegisterMethods(dict, action);
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever any of the specified methods are invoked.
        /// </summary>
        /// <remarks>
        /// The input dictionary has type names as keys, and arrays of method names as values.
        /// </remarks>
        public void RegisterMethods(Dictionary<string, string[]> methods, Action<OperationAnalysisContext, IInvocationOperation> action)
        {
            foreach (var pair in methods)
            {
                var type = Compilation.GetTypeByMetadataName(pair.Key);
                if (type != null)
                {
                    foreach (var m in pair.Value)
                    {
                        foreach (var method in type.GetMembers(m).OfType<IMethodSymbol>())
                        {
                            RegisterMethod(method, action);
                        }
                    }
                }
            }
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever the specified constructor is invoked.
        /// </summary>
        public void RegisterConstructor(IMethodSymbol ctor, Action<OperationAnalysisContext, IObjectCreationOperation> action)
        {
            if (!_state.Ctors.TryGetValue(ctor, out var l))
            {
                l = [];
                _state.Ctors.Add(ctor, l);
            }
 
            l.Add(action);
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever constructors for the given type are invoked.
        /// </summary>
        public void RegisterConstructors(string typeName, Action<OperationAnalysisContext, IObjectCreationOperation> action)
        {
            RegisterConstructors(new[] { typeName }, action);
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever constructors for any of the given types are invoked.
        /// </summary>
        public void RegisterConstructors(string[] typeNames, Action<OperationAnalysisContext, IObjectCreationOperation> action)
        {
            foreach (var typeName in typeNames)
            {
                var type = Compilation.GetTypeByMetadataName(typeName);
                if (type != null)
                {
                    foreach (var ctor in type.Constructors)
                    {
                        RegisterConstructor(ctor, action);
                    }
                }
            }
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever the given property is invoked (set or get).
        /// </summary>
        public void RegisterProperty(IPropertySymbol prop, Action<OperationAnalysisContext, IPropertyReferenceOperation> action)
        {
            if (!_state.Props.TryGetValue(prop, out var l))
            {
                l = [];
                _state.Props.Add(prop, l);
            }
 
            l.Add(action);
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever any of the given properties are invoked (set or get).
        /// </summary>
        /// <remarks>
        /// The input dictionary has type names as keys, and arrays of method names as values.
        /// </remarks>
        public void RegisterProperties(Dictionary<string, string[]> props, Action<OperationAnalysisContext, IPropertyReferenceOperation> action)
        {
            foreach (var pair in props)
            {
                var type = Compilation.GetTypeByMetadataName(pair.Key);
                if (type != null)
                {
                    foreach (var m in pair.Value)
                    {
                        foreach (var prop in type.GetMembers(m).OfType<IPropertySymbol>())
                        {
                            RegisterProperty(prop, action);
                        }
                    }
                }
            }
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever the given interface method is invoked.
        /// </summary>
        public void RegisterInterfaceMethod(IMethodSymbol method, Action<OperationAnalysisContext, IInvocationOperation> action)
        {
            if (!_state.Interfaces.TryGetValue(method.ContainingType, out var handlers))
            {
                handlers = [];
                _state.Interfaces.Add(method.ContainingType, handlers);
            }
 
            bool found = false;
            foreach (var h in handlers)
            {
                if (SymbolEqualityComparer.Default.Equals(h.Method, method))
                {
                    h.Actions.Add(action);
                    found = true;
                    break;
                }
            }
 
            if (!found)
            {
                var h = new MethodHandlers(method);
                h.Actions.Add(action);
                handlers.Add(h);
            }
 
            _ = _state.InterfaceMethodNames.Add(method.Name);
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever any of the given interface methods are invoked.
        /// </summary>
        /// <remarks>
        /// The input dictionary has type names as keys, and arrays of method names as values.
        /// </remarks>
        public void RegisterInterfaceMethods(Dictionary<string, string[]> methods, Action<OperationAnalysisContext, IInvocationOperation> action)
        {
            foreach (var pair in methods)
            {
                var type = Compilation.GetTypeByMetadataName(pair.Key);
                if (type != null)
                {
                    foreach (var m in pair.Value)
                    {
                        foreach (var method in type.GetMembers(m).OfType<IMethodSymbol>())
                        {
                            RegisterInterfaceMethod(method, action);
                        }
                    }
                }
            }
        }
 
        /// <summary>
        /// Registers a callback to be invoked whenever any of the given exception types are thrown.
        /// </summary>
        public void RegisterExceptionTypes(string[] exceptionTypes, Action<OperationAnalysisContext, IThrowOperation> action)
        {
            foreach (var et in exceptionTypes)
            {
                var type = Compilation.GetTypeByMetadataName(et);
                if (type != null)
                {
                    if (!_state.ExceptionTypes.TryGetValue(type, out var l))
                    {
                        l = [];
                        _state.ExceptionTypes.Add(type, l);
                    }
 
                    l.Add(action);
                }
            }
        }
 
        public Compilation Compilation { get; }
    }
}