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

#nullable disable

using System;
using Microsoft.AspNetCore.Razor.Language.Syntax;
using Microsoft.Extensions.Internal;

namespace Microsoft.AspNetCore.Razor.Language;

public sealed class SourceChange : IEquatable<SourceChange>
{
    public SourceChange(int absoluteIndex, int length, string newText)
    {
        if (absoluteIndex < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(absoluteIndex));
        }

        if (length < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(length));
        }

        if (newText == null)
        {
            throw new ArgumentNullException(nameof(newText));
        }

        Span = new SourceSpan(absoluteIndex, length);
        NewText = newText;
    }

    public SourceChange(SourceSpan span, string newText)
    {
        if (newText == null)
        {
            throw new ArgumentNullException(nameof(newText));
        }

        Span = span;
        NewText = newText;
    }

    public bool IsDelete => Span.Length > 0 && NewText.Length == 0;

    public bool IsInsert => Span.Length == 0 && NewText.Length > 0;

    public bool IsReplace => Span.Length > 0 && NewText.Length > 0;

    public SourceSpan Span { get; }

    public string NewText { get; }

    internal string GetEditedContent(SyntaxNode node)
    {
        if (node == null)
        {
            throw new ArgumentNullException(nameof(node));
        }

        var offset = GetOffset(node);
        return GetEditedContent(node.GetContent(), offset);
    }

    internal string GetEditedContent(string text, int offset)
    {
        if (text == null)
        {
            throw new ArgumentNullException(nameof(text));
        }

        return text.Remove(offset, Span.Length).Insert(offset, NewText);
    }

    internal int GetOffset(SyntaxNode node)
    {
        if (node == null)
        {
            throw new ArgumentNullException(nameof(node));
        }

        var start = Span.AbsoluteIndex;
        var end = Span.AbsoluteIndex + Span.Length;

        if (start < node.Position ||
            start > node.EndPosition ||
            end < node.Position ||
            end > node.EndPosition)
        {
            throw new InvalidOperationException(Resources.FormatInvalidOperation_SpanIsNotChangeOwner(node, this));
        }

        return start - node.Position;
    }

    internal string GetOriginalText(SyntaxNode node)
    {
        if (node == null)
        {
            throw new ArgumentNullException(nameof(node));
        }

        if (node.Width == 0)
        {
            return string.Empty;
        }

        var offset = GetOffset(node);
        return node.GetContent().Substring(offset, Span.Length);
    }

    public bool Equals(SourceChange other)
    {
        return
            other != null &&
            Span.Equals(other.Span) &&
            string.Equals(NewText, other.NewText, StringComparison.Ordinal);
    }

    public override bool Equals(object obj)
    {
        return Equals(obj as SourceChange);
    }

    public override int GetHashCode()
    {
        var hash = HashCodeCombiner.Start();
        hash.Add(Span);
        hash.Add(NewText, StringComparer.Ordinal);
        return hash;
    }

    public override string ToString()
    {
        return Span.ToString() + " : " + NewText;
    }
}