using System.Collections.Generic;
using System.Linq;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

namespace Ariadne.Generator
{
    /// <summary>
    /// A field or auto-property an arc saves.
    /// </summary>
    public class SavedMember
    {
        /// <summary>
        /// This field holds the field or autoproperty's name.
        /// </summary>
        public readonly string Key;

        public readonly ITypeSymbol Type;

        /// <summary>
        /// This field holds the field or auto-property, as the script declares it.
        /// </summary>
        public readonly ISymbol Declared;

        public SavedMember(string key, ITypeSymbol type, ISymbol declared)
        {
            Key = key;
            Type = type;
            Declared = declared;
        }

        /// <summary>
        /// Gets whether the script gives the member a value where it declares it, which a load from a save that lacks
        /// the member can fall back on.
        /// </summary>
        public bool HasInitializer
        {
            get
            {
                foreach (SyntaxReference reference in Declared.DeclaringSyntaxReferences)
                {
                    SyntaxNode syntax = reference.GetSyntax();
                    if (syntax is VariableDeclaratorSyntax variable && variable.Initializer != null)
                    {
                        return true;
                    }

                    if (syntax is PropertyDeclarationSyntax property && property.Initializer != null)
                    {
                        return true;
                    }
                }

                return false;
            }
        }

        /// <summary>
        /// Gets the expression generated code reads and assigns the member through.
        /// </summary>
        public string Access
        {
            get
            {
                return "this." + SavedFields.Identifier(Key);
            }
        }
    }

    /// <summary>
    /// Finds the fields and auto-properties an arc class saves: every instance one, readonly included, not marked
    /// [Scratch].
    /// </summary>
    public static class SavedFields
    {
        public const string ScratchAttributeName = "Ariadne.ScratchAttribute";

        /// <summary>
        /// Returns <paramref name="name"/> as C# can write it, with an @ if it's a keyword.
        /// </summary>
        public static string Identifier(string name)
        {
            if (SyntaxFacts.GetKeywordKind(name) != SyntaxKind.None)
            {
                return "@" + name;
            }

            return name;
        }

        private static bool IsScratch(ISymbol symbol)
        {
            return symbol.GetAttributes().Any(attribute =>
                attribute.AttributeClass?.ToDisplayString() == ScratchAttributeName);
        }

        private static int DeclarationOrder(SavedMember member)
        {
            Location location = member.Declared.Locations.FirstOrDefault();
            if (location == null || !location.IsInSource)
            {
                return 0;
            }

            return location.SourceSpan.Start;
        }

        private static string DeclarationFile(SavedMember member)
        {
            return member.Declared.Locations.FirstOrDefault()?.SourceTree?.FilePath ?? "";
        }

        /// <summary>
        /// Returns the members <paramref name="type"/> itself declares that it saves, in declaration order.
        /// </summary>
        public static List<SavedMember> Of(INamedTypeSymbol type)
        {
            var returnMe = new List<SavedMember>();
            foreach (IFieldSymbol field in type.GetMembers().OfType<IFieldSymbol>())
            {
                ISymbol declared = field.AssociatedSymbol ?? field;
                if (field.IsStatic || field.IsConst || IsScratch(field) || IsScratch(declared))
                {
                    continue;
                }

                // Only an auto-property's backing field is named for something a script declared.
                if (field.IsImplicitlyDeclared && !(declared is IPropertySymbol))
                {
                    continue;
                }

                returnMe.Add(new SavedMember(declared.Name, field.Type, declared));
            }

            return returnMe.OrderBy(DeclarationFile, System.StringComparer.Ordinal).ThenBy(DeclarationOrder).ToList();
        }

        /// <summary>
        /// Reports each field-like event <paramref name="type"/> itself declares that isn't marked [Scratch].
        /// </summary>
        public static void ReportUnsavableEvents(INamedTypeSymbol type, List<Diagnostic> diagnostics)
        {
            foreach (IEventSymbol declared in type.GetMembers().OfType<IEventSymbol>())
            {
                // Roslyn doesn't list a field-like event's backing field among the members, so go by the syntax. An
                // event with its own accessors keeps its subscribers in a field the script declared.
                bool isFieldLike = declared.DeclaringSyntaxReferences.Any(
                    reference => reference.GetSyntax() is VariableDeclaratorSyntax);
                if (isFieldLike && !declared.IsStatic && !IsScratch(declared))
                {
                    diagnostics.Add(Diagnostic.Create(ScriptDiagnostics.UnsavableEvent,
                        declared.Locations.FirstOrDefault(), declared.Name));
                }
            }
        }

        /// <summary>
        /// Reports each of <paramref name="members"/> whose key a base class of <paramref name="type"/> already saves.
        /// </summary>
        /// <remarks>A base compiled elsewhere shows only its public and protected members.</remarks>
        public static void ReportDuplicateKeys(INamedTypeSymbol type, INamedTypeSymbol arcDefinition,
            List<SavedMember> members, List<Diagnostic> diagnostics)
        {
            var baseKeys = new HashSet<string>(System.StringComparer.Ordinal);
            for (INamedTypeSymbol baseType = type.BaseType;
                baseType != null && !SymbolEqualityComparer.Default.Equals(baseType.OriginalDefinition, arcDefinition);
                baseType = baseType.BaseType)
            {
                baseKeys.UnionWith(Of(baseType).Select(member => member.Key));
            }

            foreach (SavedMember member in members)
            {
                if (baseKeys.Contains(member.Key))
                {
                    diagnostics.Add(Diagnostic.Create(ScriptDiagnostics.DuplicateSaveKey,
                        member.Declared.Locations.FirstOrDefault(), member.Key, type.Name));
                }
            }
        }
    }
}