// Copyright (c) .NET Foundation and contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
using System.Collections.Immutable;
using System.Diagnostics;
using ILLink.Shared.DataFlow;
using ILLink.Shared.TrimAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Linker.Steps;
using MultiValue = ILLink.Shared.DataFlow.ValueSet<ILLink.Shared.DataFlow.SingleValue>;
 
namespace Mono.Linker.Dataflow
{
    public readonly record struct TrimAnalysisMethodCallPattern
    {
        public readonly Instruction Operation;
        public readonly MethodReference CalledMethod;
        public readonly MultiValue Instance;
        public readonly ImmutableArray<MultiValue> Arguments;
        public readonly MessageOrigin Origin;
 
        public TrimAnalysisMethodCallPattern(
            Instruction operation,
            MethodReference calledMethod,
            MultiValue instance,
            ImmutableArray<MultiValue> arguments,
            MessageOrigin origin)
        {
            Debug.Assert(origin.Provider is MethodDefinition);
            Operation = operation;
            CalledMethod = calledMethod;
            Instance = instance.DeepCopy();
            if (arguments.IsEmpty)
            {
                Arguments = ImmutableArray<MultiValue>.Empty;
            }
            else
            {
                var builder = ImmutableArray.CreateBuilder<MultiValue>();
                foreach (var argument in arguments)
                    builder.Add(argument.DeepCopy());
                Arguments = builder.ToImmutableArray();
            }
            Origin = origin;
        }
 
        public TrimAnalysisMethodCallPattern Merge(ValueSetLattice<SingleValue> lattice, TrimAnalysisMethodCallPattern other)
        {
            Debug.Assert(Operation == other.Operation);
            Debug.Assert(Origin == other.Origin);
            Debug.Assert(CalledMethod == other.CalledMethod);
            Debug.Assert(Arguments.Length == other.Arguments.Length);
 
            var argumentsBuilder = ImmutableArray.CreateBuilder<MultiValue>();
            for (int i = 0; i < Arguments.Length; i++)
                argumentsBuilder.Add(lattice.Meet(Arguments[i], other.Arguments[i]));
 
            return new TrimAnalysisMethodCallPattern(
                Operation,
                CalledMethod,
                lattice.Meet(Instance, other.Instance),
                argumentsBuilder.ToImmutable(),
                Origin);
        }
 
        public void MarkAndProduceDiagnostics(ReflectionMarker reflectionMarker, MarkStep markStep, LinkContext context)
        {
            bool diagnosticsEnabled = !context.Annotations.ShouldSuppressAnalysisWarningsForRequiresUnreferencedCode(Origin.Provider, out _);
            var diagnosticContext = new DiagnosticContext(Origin, diagnosticsEnabled, context);
            ReflectionMethodBodyScanner.HandleCall(Operation, CalledMethod, Instance, Arguments,
                diagnosticContext,
                reflectionMarker,
                context,
                markStep);
        }
    }
}