// 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.Diagnostics.CodeAnalysis;
using System.Text;
using Microsoft.CodeAnalysis.CSharp.Symbols;
using Microsoft.CodeAnalysis.Text;
 
namespace Microsoft.CodeAnalysis.CSharp;
 
internal sealed class FileIdentifier
{
    private class FileIdentifierData(string? encoderFallbackErrorMessage, string displayFilePath, ImmutableArray<byte> filePathChecksumOpt)
    {
        public readonly string? EncoderFallbackErrorMessage = encoderFallbackErrorMessage;
        public readonly string DisplayFilePath = displayFilePath;
        public readonly ImmutableArray<byte> FilePathChecksumOpt = filePathChecksumOpt;
    }
 
    private static readonly Encoding s_encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
 
    private readonly string _filePath;
    private FileIdentifierData? _data;
 
    private FileIdentifier(string filePath)
    {
        _filePath = filePath;
    }
 
    private FileIdentifier(ImmutableArray<byte> filePathChecksumOpt, string displayFilePath)
    {
        _data = new FileIdentifierData(encoderFallbackErrorMessage: null, displayFilePath, filePathChecksumOpt);
        _filePath = string.Empty;
    }
 
    [MemberNotNull(nameof(_data))]
    private void EnsureInitialized()
    {
        if (_data is null)
        {
            string? encoderFallbackErrorMessage = null;
            ImmutableArray<byte> hash = default;
            try
            {
                var encodedFilePath = s_encoding.GetBytes(_filePath);
                using var hashAlgorithm = SourceHashAlgorithms.CreateDefaultInstance();
                hash = hashAlgorithm.ComputeHash(encodedFilePath).ToImmutableArray();
            }
            catch (EncoderFallbackException ex)
            {
                encoderFallbackErrorMessage = ex.Message;
            }
 
            var displayFilePath = GeneratedNames.GetDisplayFilePath(_filePath);
 
            _data = new FileIdentifierData(encoderFallbackErrorMessage, displayFilePath, hash);
        }
    }
 
    public string DisplayFilePath
    {
        get
        {
            EnsureInitialized();
 
            return _data.DisplayFilePath;
        }
    }
 
    public string? EncoderFallbackErrorMessage
    {
        get
        {
            EnsureInitialized();
 
            return _data.EncoderFallbackErrorMessage;
        }
    }
 
    public ImmutableArray<byte> FilePathChecksumOpt
    {
        get
        {
            EnsureInitialized();
 
            return _data.FilePathChecksumOpt;
        }
    }
 
    public static FileIdentifier Create(SyntaxTree syntaxTree, SourceReferenceResolver? resolver)
        => new FileIdentifier(syntaxTree.GetNormalizedPath(resolver));
 
    public static FileIdentifier Create(string normalizedFilePath)
        => new FileIdentifier(normalizedFilePath);
 
    public static FileIdentifier Create(ImmutableArray<byte> filePathChecksumOpt, string displayFilePath)
        => new FileIdentifier(filePathChecksumOpt, displayFilePath);
}