// 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.

using System;
using System.Collections.Immutable;
using System.Diagnostics;
using System.IO;
using System.Reflection.Metadata;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.InteropServices;
using System.Text;
using Microsoft.CodeAnalysis.Debugging;
using Microsoft.CodeAnalysis.Emit;
using Microsoft.CodeAnalysis.ErrorReporting;
using Microsoft.DiaSymReader;

namespace Microsoft.CodeAnalysis.EditAndContinue;

/// <summary>
/// Reader of debug information needed for EnC.
/// This object does not own the underlying memory (SymReader/MetadataReader).
/// </summary>
internal abstract class EditAndContinueDebugInfoReader
{
    public abstract bool IsPortable { get; }
    public abstract EditAndContinueMethodDebugInformation GetDebugInfo(MethodDefinitionHandle methodHandle);
    public abstract StandaloneSignatureHandle GetLocalSignature(MethodDefinitionHandle methodHandle);
    public abstract ImmutableDictionary<string, string> GetCompilationOptions();

    /// <summary>
    /// Returns default source file encoding specified in the compilation options.
    /// </summary>
    /// <exception cref="NotSupportedException">The PDB does not support compilation options, the options do not include encoding, or the encoding is not supproted by the platform.</exception>
    public abstract Encoding? GetDefaultSourceFileEncoding();

    /// <summary>
    /// Reads document checksum.
    /// </summary>
    /// <returns>True if a document with given path is listed in the PDB.</returns>
    /// <exception cref="Exception">Error reading debug information from the PDB.</exception>
    public abstract bool TryGetDocumentChecksum(string documentPath, out ImmutableArray<byte> checksum, out Guid algorithmId);

    private sealed class Native : EditAndContinueDebugInfoReader
    {
        private readonly ISymUnmanagedReader5 _symReader;
        private readonly int _version;

        public Native(ISymUnmanagedReader5 symReader, int version)
        {
            Debug.Assert(symReader != null);
            Debug.Assert(version >= 1);

            _symReader = symReader;
            _version = version;
        }

        public override bool IsPortable => false;

        public override StandaloneSignatureHandle GetLocalSignature(MethodDefinitionHandle methodHandle)
        {
            var symMethod = (ISymUnmanagedMethod2)_symReader.GetMethodByVersion(MetadataTokens.GetToken(methodHandle), _version);

            // Compiler generated methods (e.g. async kick-off methods) might not have debug information.
            return symMethod == null ? default : MetadataTokens.StandaloneSignatureHandle(symMethod.GetLocalSignatureToken());
        }

        public override EditAndContinueMethodDebugInformation GetDebugInfo(MethodDefinitionHandle methodHandle)
        {
            var methodToken = MetadataTokens.GetToken(methodHandle);

            byte[]? debugInfo;
            try
            {
                debugInfo = _symReader.GetCustomDebugInfo(methodToken, _version);
            }
            catch (ArgumentOutOfRangeException)
            {
                // Sometimes the debugger returns the HRESULT for ArgumentOutOfRangeException, rather than E_FAIL,
                // for methods without custom debug info (https://github.com/dotnet/roslyn/issues/4138).
                debugInfo = null;
            }
            catch (Exception e) when (FatalError.ReportAndCatch(e)) // likely a bug in the compiler/debugger
            {
                throw new InvalidDataException(e.Message, e);
            }

            try
            {
                ImmutableArray<byte> localSlots, lambdaMap, stateMachineSuspensionPoints;
                if (debugInfo != null)
                {
                    localSlots = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(debugInfo, CustomDebugInfoKind.EditAndContinueLocalSlotMap);
                    lambdaMap = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(debugInfo, CustomDebugInfoKind.EditAndContinueLambdaMap);
                    stateMachineSuspensionPoints = CustomDebugInfoReader.TryGetCustomDebugInfoRecord(debugInfo, CustomDebugInfoKind.EditAndContinueStateMachineStateMap);
                }
                else
                {
                    localSlots = lambdaMap = stateMachineSuspensionPoints = default;
                }

                return EditAndContinueMethodDebugInformation.Create(localSlots, lambdaMap, stateMachineSuspensionPoints);
            }
            catch (InvalidOperationException e) when (FatalError.ReportAndCatch(e)) // likely a bug in the compiler/debugger
            {
                // TODO: CustomDebugInfoReader should throw InvalidDataException
                throw new InvalidDataException(e.Message, e);
            }
        }

        public override bool TryGetDocumentChecksum(string documentPath, out ImmutableArray<byte> checksum, out Guid algorithmId)
            => TryGetDocumentChecksum(_symReader, documentPath, out checksum, out algorithmId);

        public override ImmutableDictionary<string, string> GetCompilationOptions()
            // Windows PDBs do not store compilation options.
            => ImmutableDictionary<string, string>.Empty;

        public override Encoding? GetDefaultSourceFileEncoding()
            => throw new NotSupportedException("Windows PDB does not support compilation options.");
    }

    private sealed class Portable : EditAndContinueDebugInfoReader
    {
        private readonly MetadataReader _pdbReader;
        private readonly Lazy<Encoding?> _lazyDefaultSourceFileEncoding;
        private ImmutableDictionary<string, string>? _lazyCompilationOptions;

        public Portable(MetadataReader pdbReader)
        {
            _pdbReader = pdbReader;
            _lazyDefaultSourceFileEncoding = new(ReadDefaultSourceFileEncoding);
        }

        public override bool IsPortable => true;

        public override StandaloneSignatureHandle GetLocalSignature(MethodDefinitionHandle methodHandle)
            => _pdbReader.GetMethodDebugInformation(methodHandle.ToDebugInformationHandle()).LocalSignature;

        public override EditAndContinueMethodDebugInformation GetDebugInfo(MethodDefinitionHandle methodHandle)
            => EditAndContinueMethodDebugInformation.Create(
                compressedSlotMap: GetCdiBytes(methodHandle, PortableCustomDebugInfoKinds.EncLocalSlotMap),
                compressedLambdaMap: GetCdiBytes(methodHandle, PortableCustomDebugInfoKinds.EncLambdaAndClosureMap),
                compressedStateMachineStateMap: GetCdiBytes(methodHandle, PortableCustomDebugInfoKinds.EncStateMachineStateMap));

        private ImmutableArray<byte> GetCdiBytes(MethodDefinitionHandle methodHandle, Guid kind)
            => _pdbReader.TryGetCustomDebugInformation(methodHandle, kind, out var cdi)
                ? _pdbReader.GetBlobContent(cdi.Value)
                : default;

        public override bool TryGetDocumentChecksum(string documentPath, out ImmutableArray<byte> checksum, out Guid algorithmId)
        {
            foreach (var documentHandle in _pdbReader.Documents)
            {
                var document = _pdbReader.GetDocument(documentHandle);

                if (_pdbReader.StringComparer.Equals(document.Name, documentPath, ignoreCase: false))
                {
                    checksum = _pdbReader.GetBlobContent(document.Hash);
                    algorithmId = _pdbReader.GetGuid(document.HashAlgorithm);
                    return true;
                }
            }

            checksum = default;
            algorithmId = default;
            return false;
        }

        public override ImmutableDictionary<string, string> GetCompilationOptions()
            => _lazyCompilationOptions ??= _pdbReader.GetCompilationOptions();

        public override Encoding? GetDefaultSourceFileEncoding()
            => _lazyDefaultSourceFileEncoding.Value;

        private Encoding? ReadDefaultSourceFileEncoding()
        {
            var options = GetCompilationOptions();

            if (!options.TryGetValue(CompilationOptionNames.DefaultEncoding, out var encodingName) &&
                !options.TryGetValue(CompilationOptionNames.FallbackEncoding, out encodingName))
            {
                return null;
            }

            try
            {
                return Encoding.GetEncoding(encodingName);
            }
            catch (Exception e)
            {
                throw new NotSupportedException($"Encoding '{encodingName}' not supported: {e.Message}");
            }
        }
    }

    /// <summary>
    /// Creates <see cref="EditAndContinueDebugInfoReader"/> backed by a given <see cref="ISymUnmanagedReader5"/>.
    /// </summary>
    /// <param name="symReader">SymReader open on a Portable or Windows PDB.</param>
    /// <param name="version">The version of the PDB to read.</param>
    /// <exception cref="ArgumentNullException"><paramref name="symReader"/> is null.</exception>
    /// <exception cref="ArgumentOutOfRangeException"><paramref name="version"/> is less than 1.</exception>
    /// <exception cref="COMException">Error reading debug information.</exception>
    /// <returns>
    /// The resulting reader does not take ownership of the <paramref name="symReader"/> or the memory it reads.
    /// </returns>
    /// <remarks>
    /// Automatically detects the underlying PDB format and returns the appropriate reader.
    /// </remarks>
    public static unsafe EditAndContinueDebugInfoReader Create(ISymUnmanagedReader5 symReader, int version = 1)
    {
        if (symReader == null)
        {
            throw new ArgumentNullException(nameof(symReader));
        }

        if (version <= 0)
        {
            throw new ArgumentOutOfRangeException(nameof(version));
        }

        var hr = symReader.GetPortableDebugMetadataByVersion(version, metadata: out var metadata, size: out var size);
        Marshal.ThrowExceptionForHR(hr);

        if (hr == 0)
        {
            return new Portable(new MetadataReader(metadata, size));
        }
        else
        {
            return new Native(symReader, version);
        }
    }

    /// <summary>
    /// Creates <see cref="EditAndContinueDebugInfoReader"/> back by a given <see cref="MetadataReader"/>.
    /// </summary>
    /// <param name="pdbReader"><see cref="MetadataReader"/> open on a Portable PDB.</param>
    /// <exception cref="ArgumentNullException"><paramref name="pdbReader"/> is null.</exception>
    /// <returns>
    /// The resulting reader does not take ownership of the <paramref name="pdbReader"/> or the memory it reads.
    /// </returns>
    public static unsafe EditAndContinueDebugInfoReader Create(MetadataReader pdbReader)
       => new Portable(pdbReader ?? throw new ArgumentNullException(nameof(pdbReader)));

    internal static bool TryGetDocumentChecksum(ISymUnmanagedReader5 symReader, string documentPath, out ImmutableArray<byte> checksum, out Guid algorithmId)
    {
        var symDocument = symReader.GetDocument(documentPath);

        // Make sure the full path matches.
        // Native SymReader allows partial match on the document file name.
        if (symDocument == null || !StringComparer.Ordinal.Equals(symDocument.GetName(), documentPath))
        {
            checksum = default;
            algorithmId = default;
            return false;
        }

        algorithmId = symDocument.GetHashAlgorithm();
        checksum = [.. symDocument.GetChecksum()];
        return true;
    }
}