// 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.Generic;
using System.Collections.Immutable;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using Roslyn.Utilities;
 
namespace Microsoft.CodeAnalysis.MSBuild;
 
/// <summary>
/// A map of projects that can be optionally used with <see cref="MSBuildProjectLoader.LoadProjectInfoAsync"/> when loading a
/// project into a custom <see cref="Workspace"/>. To use, pass <see cref="Workspace.CurrentSolution"/> to <see cref="Create(Solution)"/>.
/// </summary>
public class ProjectMap
{
    /// <summary>
    /// A map of project path to <see cref="ProjectId"/>s. Note that there can be multiple <see cref="ProjectId"/>s per project path
    /// if the project is multi-targeted -- one for each target framework.
    /// </summary>
    private readonly Dictionary<string, HashSet<ProjectId>> _projectPathToProjectIdsMap;
 
    /// <summary>
    /// A map of project path to <see cref="ProjectInfo"/>s. Note that there can be multiple <see cref="ProjectId"/>s per project path
    /// if the project is multi-targeted -- one for each target framework.
    /// </summary>
    private readonly Dictionary<string, ImmutableArray<ProjectInfo>> _projectPathToProjectInfosMap;
 
    /// <summary>
    /// A map of <see cref="ProjectId"/> to the output file of the project (if any).
    /// </summary>
    private readonly Dictionary<ProjectId, string> _projectIdToOutputFilePathMap;
 
    /// <summary>
    /// A map of <see cref="ProjectId"/> to the output ref file of the project (if any).
    /// </summary>
    private readonly Dictionary<ProjectId, string> _projectIdToOutputRefFilePathMap;
 
    private ProjectMap()
    {
        _projectPathToProjectIdsMap = new Dictionary<string, HashSet<ProjectId>>(PathUtilities.Comparer);
        _projectPathToProjectInfosMap = new Dictionary<string, ImmutableArray<ProjectInfo>>(PathUtilities.Comparer);
        _projectIdToOutputFilePathMap = [];
        _projectIdToOutputRefFilePathMap = [];
    }
 
    /// <summary>
    /// Create an empty <see cref="ProjectMap"/>.
    /// </summary>
    public static ProjectMap Create() => new();
 
    /// <summary>
    /// Create a <see cref="ProjectMap"/> populated with the given <see cref="Solution"/>.
    /// </summary>
    /// <param name="solution">The <see cref="Solution"/> to populate the new <see cref="ProjectMap"/> with.</param>
    public static ProjectMap Create(Solution solution)
    {
        var projectMap = new ProjectMap();
 
        foreach (var project in solution.Projects)
        {
            projectMap.Add(project);
        }
 
        return projectMap;
    }
 
    /// <summary>
    /// Add a <see cref="Project"/> to this <see cref="ProjectMap"/>.
    /// </summary>
    /// <param name="project">The <see cref="Project"/> to add to this <see cref="ProjectMap"/>.</param>
    public void Add(Project project)
    {
        Add(project.Id, project.FilePath, project.OutputFilePath, project.OutputRefFilePath);
        AddProjectInfo(project.State.ProjectInfo);
    }
 
    private void Add(ProjectId projectId, string? projectPath, string? outputFilePath, string? outputRefFilePath)
    {
        if (!RoslynString.IsNullOrEmpty(projectPath))
        {
            _projectPathToProjectIdsMap.MultiAdd(projectPath, projectId);
        }
 
        if (!RoslynString.IsNullOrEmpty(outputFilePath))
        {
            _projectIdToOutputFilePathMap.Add(projectId, outputFilePath);
        }
 
        if (!RoslynString.IsNullOrEmpty(outputRefFilePath))
        {
            _projectIdToOutputRefFilePathMap.Add(projectId, outputRefFilePath);
        }
    }
 
    internal void AddProjectInfo(ProjectInfo projectInfo)
    {
        var projectFilePath = projectInfo.FilePath;
        if (RoslynString.IsNullOrEmpty(projectFilePath))
        {
            throw new ArgumentException(WorkspaceMSBuildResources.Project_does_not_have_a_path);
        }
 
        if (!_projectPathToProjectInfosMap.TryGetValue(projectFilePath, out var projectInfos))
        {
            projectInfos = [];
        }
 
        if (projectInfos.Contains(pi => pi.Id == projectInfo.Id))
        {
            throw new ArgumentException(WorkspaceMSBuildResources.Project_already_added);
        }
 
        projectInfos = projectInfos.Add(projectInfo);
 
        _projectPathToProjectInfosMap[projectFilePath] = projectInfos;
    }
 
    private ProjectId CreateProjectId(string? projectPath, string? outputFilePath, string? outputRefFilePath)
    {
        var newProjectId = ProjectId.CreateNewId(debugName: projectPath);
        Add(newProjectId, projectPath, outputFilePath, outputRefFilePath);
        return newProjectId;
    }
 
    internal ProjectId GetOrCreateProjectId(string projectPath)
    {
        if (!_projectPathToProjectIdsMap.TryGetValue(projectPath, out var projectIds))
        {
            projectIds = [];
            _projectPathToProjectIdsMap.Add(projectPath, projectIds);
        }
 
        return projectIds.Count == 1
            ? projectIds.Single()
            : CreateProjectId(projectPath, outputFilePath: null, outputRefFilePath: null);
    }
 
    internal ProjectId GetOrCreateProjectId(ProjectFileInfo projectFileInfo)
    {
        var projectPath = projectFileInfo.FilePath;
        var outputFilePath = projectFileInfo.OutputFilePath;
        var outputRefFilePath = projectFileInfo.OutputRefFilePath;
 
        if (projectPath is not null && TryGetIdsByProjectPath(projectPath, out var projectIds))
        {
            if (TryFindOutputFileRefPathInProjectIdSet(outputRefFilePath, projectIds, out var projectId) ||
                TryFindOutputFilePathInProjectIdSet(outputFilePath, projectIds, out projectId))
            {
                return projectId;
            }
        }
 
        return CreateProjectId(projectPath, outputFilePath, outputRefFilePath);
    }
 
    private bool TryFindOutputFileRefPathInProjectIdSet(string? outputRefFilePath, HashSet<ProjectId> set, [NotNullWhen(true)] out ProjectId? result)
        => TryFindPathInProjectIdSet(outputRefFilePath, GetOutputRefFilePathById, set, out result);
 
    private bool TryFindOutputFilePathInProjectIdSet(string? outputFilePath, HashSet<ProjectId> set, [NotNullWhen(true)] out ProjectId? result)
        => TryFindPathInProjectIdSet(outputFilePath, GetOutputFilePathById, set, out result);
 
    private static bool TryFindPathInProjectIdSet(string? path, Func<ProjectId, string?> getPathById, HashSet<ProjectId> set, [NotNullWhen(true)] out ProjectId? result)
    {
        if (!RoslynString.IsNullOrEmpty(path))
        {
            foreach (var id in set)
            {
                var p = getPathById(id);
 
                if (PathUtilities.Comparer.Equals(p, path))
                {
                    result = id;
                    return true;
                }
            }
        }
 
        result = null;
        return false;
    }
 
    internal string? GetOutputRefFilePathById(ProjectId projectId)
        => TryGetOutputRefFilePathById(projectId, out var path)
            ? path
            : null;
 
    internal string? GetOutputFilePathById(ProjectId projectId)
        => TryGetOutputFilePathById(projectId, out var path)
            ? path
            : null;
 
    internal bool TryGetIdsByProjectPath(string projectPath, [NotNullWhen(true)] out HashSet<ProjectId>? ids)
        => _projectPathToProjectIdsMap.TryGetValue(projectPath, out ids);
 
    internal bool TryGetOutputFilePathById(ProjectId id, [NotNullWhen(true)] out string? outputFilePath)
        => _projectIdToOutputFilePathMap.TryGetValue(id, out outputFilePath);
 
    internal bool TryGetOutputRefFilePathById(ProjectId id, [NotNullWhen(true)] out string? outputRefFilePath)
        => _projectIdToOutputRefFilePathMap.TryGetValue(id, out outputRefFilePath);
 
    internal bool TryGetProjectInfosByProjectPath(string projectPath, out ImmutableArray<ProjectInfo> projectInfos)
        => _projectPathToProjectInfosMap.TryGetValue(projectPath, out projectInfos);
}