// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using Microsoft.AspNetCore.Razor.Utilities;
using Microsoft.AspNetCore.Razor.Utilities.Shared.Resources;

namespace Microsoft.AspNetCore.Razor.Language;

public sealed class RazorDiagnostic : IEquatable<RazorDiagnostic>, IFormattable
{
    private readonly RazorDiagnosticDescriptor _descriptor;
    private readonly object[] _args;

    public string Id => _descriptor.Id;
    public RazorDiagnosticSeverity Severity => _descriptor.Severity;
    public int WarningLevel => _descriptor.WarningLevel;
    public SourceSpan Span { get; }

    private Checksum? _checksum;

    private RazorDiagnostic(RazorDiagnosticDescriptor descriptor, SourceSpan? span, object[]? args)
    {
        _descriptor = descriptor ?? throw new ArgumentNullException(nameof(descriptor));
        Span = span ?? SourceSpan.Undefined;
        _args = args ?? [];
    }

    public static RazorDiagnostic Create(RazorDiagnosticDescriptor descriptor)
        => new(descriptor, span: null, args: null);

    public static RazorDiagnostic Create(RazorDiagnosticDescriptor descriptor, SourceSpan? span)
        => new(descriptor, span, args: null);

    public static RazorDiagnostic Create(RazorDiagnosticDescriptor descriptor, params object[] args)
        => new(descriptor, span: null, args);

    public static RazorDiagnostic Create(RazorDiagnosticDescriptor descriptor, SourceSpan? span, params object[] args)
        => new(descriptor, span, args);

    internal Checksum Checksum
        => _checksum ??= ComputeChecksum();

    private Checksum ComputeChecksum()
    {
        var builder = new Checksum.Builder();

        builder.Append(_descriptor.Id);
        builder.Append((int)_descriptor.Severity);
        builder.Append(_descriptor.MessageFormat);

        foreach (var arg in _args)
        {
            builder.Append(ConvertEnumIfNeeded(arg));
        }

        var span = Span;
        builder.Append(span.FilePath);
        builder.Append(span.AbsoluteIndex);
        builder.Append(span.LineIndex);
        builder.Append(span.CharacterIndex);
        builder.Append(span.Length);
        builder.Append(span.LineCount);
        builder.Append(span.EndCharacterIndex);

        return builder.FreeAndGetChecksum();

        static object ConvertEnumIfNeeded(object value)
        {
            if (value.GetType() is { IsEnum: true } enumType)
            {
                var underlyingType = Enum.GetUnderlyingType(enumType);

                // Currently, only enums with an underlying type of Int32 are supported,
                // but more can be added if needed.
                if (underlyingType != typeof(int))
                {
                    throw new NotSupportedException(SR.FormatUnsupported_type_0(enumType.FullName));
                }

                return Convert.ToInt32(value);
            }

            return value;
        }
    }

    public string GetMessage()
        => GetMessage(formatProvider: null);

    public string GetMessage(IFormatProvider? formatProvider)
        => string.Format(formatProvider, _descriptor.MessageFormat, _args);

    public override bool Equals(object? obj)
        => obj is RazorDiagnostic diagnostic &&
           Equals(diagnostic);

    public bool Equals(RazorDiagnostic? other)
        => other is not null &&
           Checksum.Equals(other.Checksum);

    public override int GetHashCode()
        => Checksum.GetHashCode();

    public override string ToString()
    {
        return Format(this, formatProvider: null);
    }

    string IFormattable.ToString(string? format, IFormatProvider? formatProvider)
        => Format(this, formatProvider);

    private static string Format(RazorDiagnostic diagnostic, IFormatProvider? formatProvider)
    {
        var span = diagnostic.Span;
        var severity = diagnostic.Severity;
        var id = diagnostic.Id;
        var message = diagnostic.GetMessage(formatProvider);

        // Our indices are 0-based, but we we want to print them as 1-based.
        return $"{span.FilePath}({span.LineIndex + 1},{span.CharacterIndex + 1}): {severity} {id}: {message}";
    }
}