// 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.IO;
using System.Linq;
using System.Reflection.PortableExecutable;
using Microsoft.CodeAnalysis.Debugging;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.Emit
{
    /// <summary>
    /// Provides access to compilation outputs based only on the path of the output asssembly.
    /// If PDB path is known upfront use <see cref="CompilationOutputFiles"/> instead.
    /// </summary>
    internal sealed class CompilationOutputFilesWithImplicitPdbPath : CompilationOutputs
    {
        public string? AssemblyFilePath { get; }
 
        public CompilationOutputFilesWithImplicitPdbPath(string? assemblyFilePath = null)
        {
            if (assemblyFilePath != null)
            {
                CompilerPathUtilities.RequireAbsolutePath(assemblyFilePath, nameof(assemblyFilePath));
            }
 
            AssemblyFilePath = assemblyFilePath;
        }
 
        public override string? AssemblyDisplayPath => AssemblyFilePath;
 
        // heuristic for error messages (determining the actual path requires opening the assembly):
        public override string PdbDisplayPath => Path.GetFileNameWithoutExtension(AssemblyFilePath) + ".pdb";
 
        protected override Stream? OpenAssemblyStream()
            => TryOpenFileStream(AssemblyFilePath);
 
        // Not gonna be called since we override OpenPdb.
        protected override Stream OpenPdbStream()
            => throw ExceptionUtilities.Unreachable();
 
        public override DebugInformationReaderProvider? OpenPdb()
        {
            var assemblyStream = OpenAssemblyStream();
            if (assemblyStream == null)
            {
                return null;
            }
 
            // find associated PDB
            string pdbPath;
            using (var peReader = new PEReader(assemblyStream))
            {
                var debugDirectory = peReader.ReadDebugDirectory();
                var embeddedPdbEntry = debugDirectory.FirstOrDefault(e => e.Type == DebugDirectoryEntryType.EmbeddedPortablePdb);
                if (embeddedPdbEntry.DataSize != 0)
                {
                    return DebugInformationReaderProvider.CreateFromMetadataReader(peReader.ReadEmbeddedPortablePdbDebugDirectoryData(embeddedPdbEntry));
                }
 
                var codeViewEntry = debugDirectory.FirstOrDefault(e => e.Type == DebugDirectoryEntryType.CodeView);
                if (codeViewEntry.DataSize == 0)
                {
                    return null;
                }
 
                pdbPath = peReader.ReadCodeViewDebugDirectoryData(codeViewEntry).Path;
            }
 
            // First try to use the full path as specified in the PDB, then look next to the assembly.
            var pdbStream =
                TryOpenFileStream(pdbPath) ??
                TryOpenFileStream(Path.Combine(Path.GetDirectoryName(AssemblyFilePath)!, PathUtilities.GetFileName(pdbPath)));
 
            return (pdbStream != null) ? DebugInformationReaderProvider.CreateFromStream(pdbStream) : null;
        }
 
        private static Stream? TryOpenFileStream(string? path)
        {
            if (path == null)
            {
                return null;
            }
 
            try
            {
                return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete);
            }
            catch (Exception e) when (e is FileNotFoundException or DirectoryNotFoundException)
            {
                return null;
            }
            catch (Exception e) when (e is not IOException)
            {
                throw new IOException(e.Message, e);
            }
        }
    }
}