using System;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.Text;

namespace Ariadne.Generator
{
    /// <summary>
    /// Describes where something is declared as plain data, which an incremental generator step can compare between
    /// runs. A Location can't be compared that way, since each edit makes new ones.
    /// </summary>
    public sealed class SourcePlace : IEquatable<SourcePlace>
    {
        /// <summary>
        /// Holds the file the declaration is in, or null if it isn't in source.
        /// </summary>
        public readonly string FilePath;

        public readonly TextSpan Span;
        public readonly LinePositionSpan LineSpan;

        public SourcePlace(string filePath, TextSpan span, LinePositionSpan lineSpan)
        {
            FilePath = filePath;
            Span = span;
            LineSpan = lineSpan;
        }

        /// <summary>
        /// Returns where <paramref name="location"/> is, or a place with no file if it isn't in source.
        /// </summary>
        public static SourcePlace Of(Location location)
        {
            if (location == null || !location.IsInSource)
            {
                return new SourcePlace(null, default, default);
            }

            return new SourcePlace(location.SourceTree.FilePath, location.SourceSpan,
                location.GetLineSpan().Span);
        }

        /// <summary>
        /// Returns this place in <paramref name="compilation"/>'s own syntax tree.
        /// </summary>
        public Location LocationIn(Compilation compilation)
        {
            if (FilePath == null)
            {
                return Location.None;
            }

            // A location in a syntax tree is the only kind #pragma can suppress a diagnostic at.
            foreach (SyntaxTree tree in compilation.SyntaxTrees)
            {
                if (tree.FilePath == FilePath)
                {
                    return Location.Create(tree, Span);
                }
            }

            return Location.Create(FilePath, Span, LineSpan);
        }

        public bool Equals(SourcePlace other)
        {
            return other != null && FilePath == other.FilePath && Span == other.Span && LineSpan == other.LineSpan;
        }

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

        public override int GetHashCode()
        {
            return Span.GetHashCode();
        }
    }
}