// 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.Collections.Immutable;
using System.IO;
using Microsoft.CodeAnalysis.Diagnostics;
using Microsoft.CodeAnalysis.PooledObjects;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.Serialization;

internal static class SerializationExtensions
{
    public static WellKnownSynchronizationKind GetWellKnownSynchronizationKind(this object value)
        => value switch
        {
            SolutionCompilationStateChecksums => WellKnownSynchronizationKind.SolutionCompilationState,
            SolutionStateChecksums => WellKnownSynchronizationKind.SolutionState,
            ProjectStateChecksums => WellKnownSynchronizationKind.ProjectState,
            SolutionInfo.SolutionAttributes => WellKnownSynchronizationKind.SolutionAttributes,
            ProjectInfo.ProjectAttributes => WellKnownSynchronizationKind.ProjectAttributes,
            DocumentInfo.DocumentAttributes => WellKnownSynchronizationKind.DocumentAttributes,
            CompilationOptions => WellKnownSynchronizationKind.CompilationOptions,
            ParseOptions => WellKnownSynchronizationKind.ParseOptions,
            ProjectReference => WellKnownSynchronizationKind.ProjectReference,
            MetadataReference => WellKnownSynchronizationKind.MetadataReference,
            AnalyzerReference => WellKnownSynchronizationKind.AnalyzerReference,
            SerializableSourceText => WellKnownSynchronizationKind.SerializableSourceText,
            SourceGeneratedDocumentIdentity => WellKnownSynchronizationKind.SourceGeneratedDocumentIdentity,
            SourceGeneratorExecutionVersionMap => WellKnownSynchronizationKind.SourceGeneratorExecutionVersionMap,
            ImmutableDictionary<string, StructuredAnalyzerConfigOptions> => WellKnownSynchronizationKind.FallbackAnalyzerOptions,
            _ => throw ExceptionUtilities.UnexpectedValue(value),
        };

    public static CompilationOptions FixUpCompilationOptions(this ProjectInfo.ProjectAttributes info, CompilationOptions compilationOptions)
    {
        return compilationOptions.WithXmlReferenceResolver(GetXmlResolver(info.FilePath))
                                 .WithStrongNameProvider(new DesktopStrongNameProvider(GetStrongNameKeyPaths(info), Path.GetTempPath()));
    }

    private static XmlFileResolver GetXmlResolver(string? filePath)
    {
        // Given filePath can be any arbitrary string project is created with.
        // for primary solution in host such as VSWorkspace, ETA or MSBuildWorkspace
        // filePath will point to actual file on disk, but in memory solultion, or
        // one from AdhocWorkspace and etc, FilePath can be a random string.
        // Make sure we return only if given filePath is in right form.
        if (!PathUtilities.IsAbsolute(filePath))
        {
            // xmlFileResolver can only deal with absolute path
            // return Default
            return XmlFileResolver.Default;
        }

        return new XmlFileResolver(PathUtilities.GetDirectoryName(filePath));
    }

    private static ImmutableArray<string> GetStrongNameKeyPaths(ProjectInfo.ProjectAttributes info)
    {
        // Given FilePath/OutputFilePath can be any arbitrary strings project is created with.
        // for primary solution in host such as VSWorkspace, ETA or MSBuildWorkspace
        // filePath will point to actual file on disk, but in memory solultion, or
        // one from AdhocWorkspace and etc, FilePath/OutputFilePath can be a random string.
        // Make sure we return only if given filePath is in right form.
        if (info is { FilePath: null, OutputFilePath: null })
        {
            // return empty since that is what IDE does for this case
            // see AbstractProject.GetStrongNameKeyPaths
            return [];
        }

        var builder = ArrayBuilder<string>.GetInstance();
        if (PathUtilities.IsAbsolute(info.FilePath))
        {
            // desktop strong name provider only knows how to deal with absolute path
            builder.Add(PathUtilities.GetDirectoryName(info.FilePath));
        }

        if (PathUtilities.IsAbsolute(info.OutputFilePath))
        {
            // desktop strong name provider only knows how to deal with absolute path
            builder.Add(PathUtilities.GetDirectoryName(info.OutputFilePath));
        }

        return builder.ToImmutableAndFree();
    }
}