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

namespace Ariadne.Generator
{
    /// <summary>
    /// A call in a passage to a passage that runs with a frame of its own, and what the caller holds while it's paused
    /// inside it.  That is a passage of another arc, or a passage that owns a frame, whose locals can't live in the
    /// arc's frame.
    /// </summary>
    public class ForeignSite
    {
        public const string ReceiverSuffix = "receiver";

        /// <summary>
        /// Holds the passage called, as its own class declares it.
        /// </summary>
        public readonly IMethodSymbol Passage;

        /// <summary>
        /// Holds the script class that declares the passage.
        /// </summary>
        public readonly ScriptClass Owner;

        /// <summary>
        /// Holds the expression for the arc the passage runs on, which is worked out once when the call begins.  It's
        /// null for a call on the calling arc, which only a passage that owns a frame needs a site for.
        /// </summary>
        public readonly ExpressionSyntax Receiver;

        /// <summary>
        /// Holds the type of that expression.
        /// </summary>
        public readonly ITypeSymbol ReceiverType;

        /// <summary>
        /// Holds the type arguments the call gives a generic passage, as <c>&lt;int, string&gt;</c>, or "" for any
        /// other.
        /// </summary>
        public readonly string TypeArguments;

        /// <summary>
        /// Holds the name of the table the callee's locals are saved in, among the calling arc's.  It ends with a
        /// slash, which tells it from a local.
        /// </summary>
        public readonly string ScopeName;

        /// <summary>
        /// Holds the name of the field in the calling arc's frame that keeps the receiver.
        /// </summary>
        public readonly string ReceiverField;

        /// <summary>
        /// Holds the name of the field in the calling arc's frame that keeps the callee's frame.
        /// </summary>
        public readonly string FrameField;

        /// <summary>
        /// Holds the type of the callee's frame.  For a passage on this arc that owns a frame that is its own frame,
        /// and for one on another arc it is the frame of that arc, which the owned frame is lent beside.
        /// </summary>
        public readonly string FrameType;

        /// <summary>
        /// Holds the name of the field in the calling arc's frame that keeps the owned frame of a passage called on
        /// another arc, or null for any other call.
        /// </summary>
        public readonly string OwnedFrameField;

        /// <summary>
        /// Holds the type of that owned frame, or null.
        /// </summary>
        public readonly string OwnedFrameType;

        /// <summary>
        /// Holds the call, which a save library's analyzer reports a problem with the receiver's type on.
        /// </summary>
        public readonly Location Where;

        /// <summary>
        /// Holds the open generic frame class a polymorphic call builds its callee's frame from when it loads, as
        /// <c>Wrap__Frame&lt;,&gt;</c>, or null for any other call.
        /// </summary>
        public readonly string FrameDefinition;

        /// <summary>
        /// Holds the call's type arguments as <c>typeof</c> expressions, to save beside the callee's locals.  It is
        /// null for any call that isn't polymorphic.
        /// </summary>
        public readonly string TypeArgumentTypes;

        /// <summary>
        /// Whether the call is through base, eg: <c>base.Run</c>.  The base class's passage keeps its locals in a frame
        /// of the base class's type, made for the call, so that they stay apart from the locals of the one that calls
        /// it.
        /// </summary>
        public readonly bool IsBaseCall;

        private ForeignSite(IMethodSymbol passage, ScriptClass owner, ExpressionSyntax receiver,
            ITypeSymbol receiverType, string typeArguments, string frameType, string ownedFrameType, string scopeName,
            string fieldStem, Location where, string frameDefinition = null, string typeArgumentTypes = null,
            bool isBaseCall = false)
        {
            IsBaseCall = isBaseCall;
            FrameDefinition = frameDefinition;
            TypeArgumentTypes = typeArgumentTypes;
            Passage = passage;
            Owner = owner;
            Receiver = receiver;
            ReceiverType = receiverType;
            TypeArguments = typeArguments;
            ScopeName = scopeName;
            ReceiverField = fieldStem + "_" + ReceiverSuffix;
            FrameField = fieldStem + "_frame";
            FrameType = frameType;
            OwnedFrameType = ownedFrameType;
            if (ownedFrameType != null)
            {
                OwnedFrameField = fieldStem + "_ownedFrame";
            }

            Where = where;
        }

        /// <summary>
        /// Gets whether the call is to a passage on the calling arc.
        /// </summary>
        public bool OnThisArc
        {
            get
            {
                return Receiver == null;
            }
        }

        /// <summary>
        /// Gets whether the call is to a passage that owns a frame on another arc, which runs with that frame beside
        /// the frame of that arc.
        /// </summary>
        public bool HasOwnedFrame
        {
            get
            {
                return OwnedFrameType != null;
            }
        }

        /// <summary>
        /// Gets whether the call is to a passage in the caller's own cycle with a type argument built from the
        /// caller's type parameters, so each lap's frame is a type no earlier lap made.
        /// </summary>
        public bool Polymorphic => FrameDefinition != null;

        /// <summary>
        /// Gets the type the field that keeps the callee's frame is declared as.  A polymorphic call uses the base
        /// frame type, since every lap's frame is a type the last didn't have.
        /// </summary>
        public string FrameFieldType => Polymorphic ? "global::Ariadne.Frame" : FrameType;

        /// <summary>
        /// Gets the expression a passage copy reads the callee's frame through, as the callee's frame type.
        /// </summary>
        public string TypedFrameAccess => Polymorphic ? "((" + FrameType + ")" + FrameAccess + ")" : FrameAccess;

        /// <summary>
        /// Gets the expression a passage copy reads the receiver through.
        /// </summary>
        public string ReceiverAccess
        {
            get
            {
                return PassageWriter.FrameName + "." + ReceiverField;
            }
        }

        /// <summary>
        /// Gets the expression a passage copy reads the callee's frame through.
        /// </summary>
        public string FrameAccess
        {
            get
            {
                return PassageWriter.FrameName + "." + FrameField;
            }
        }

        /// <summary>
        /// Gets the expression a passage copy reads the owned frame through.
        /// </summary>
        public string OwnedFrameAccess
        {
            get
            {
                return PassageWriter.FrameName + "." + OwnedFrameField;
            }
        }

        /// <summary>
        /// Gets the key the receiver is told apart by in the calling arc's frame, which saves it as
        /// <see cref="ReceiverSuffix"/> in the callee's table.
        /// </summary>
        public string ReceiverKey
        {
            get
            {
                return ScopeName + ReceiverSuffix;
            }
        }

        /// <summary>
        /// Returns the site of <paramref name="call"/>, made in the passage named <paramref name="callerName"/> at the
        /// pause keyed <paramref name="key"/>.
        /// </summary>
        public static ForeignSite Of(ScriptClass script, string callerName, InvocationExpressionSyntax call,
            string key, IMethodSymbol passage)
        {
            ExpressionSyntax receiver = ((MemberAccessExpressionSyntax)call.Expression).Expression;
            ITypeSymbol receiverType = script.ModelFor(receiver).GetTypeInfo(receiver).Type;
            ScriptClass owner = script.OwnerOf(passage);

            // The callee's frame is typed as the owner is constructed at the call, eg: Plant<int>.__Frame.
            var target = (IMethodSymbol)script.ModelFor(call).GetSymbolInfo(call).Symbol;
            string ownerType = target.ContainingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
            string frameType = ownerType + "." + PassageWriter.FrameTypeName;
            string typeArguments = "";
            string ownedFrameType = null;
            if (script.OwnsFrame(passage))
            {
                typeArguments = TypeArgumentsOf(target);
                ownedFrameType = ownerType + "." + PassageWriter.OwnedFrameName(passage) + typeArguments;
            }

            return new ForeignSite(passage, owner, receiver, receiverType ?? owner.Type, typeArguments, frameType,
                ownedFrameType, callerName + "." + key + "/", FieldStemOf(callerName, key), call.GetLocation());
        }

        // A key is a label or a passage name, with #1, #2 after it for a second pause under the same label.  The #
        // can't be in an identifier.
        private static string FieldStemOf(string callerName, string key)
        {
            return callerName + "____call_" + key.Replace("#", "__n");
        }

        private static string TypeArgumentsOf(IMethodSymbol target)
        {
            if (target.TypeArguments.Length == 0)
            {
                return "";
            }

            return "<" + string.Join(", ", target.TypeArguments.Select(argument =>
                argument.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat))) + ">";
        }

        /// <summary>
        /// Returns the site of a call to <c>base.Run</c>, made in the passage named <paramref name="callerName"/> at
        /// the pause keyed <paramref name="key"/>.
        /// </summary>
        public static ForeignSite OfBase(ScriptClass script, string callerName, InvocationExpressionSyntax call,
            string key, IMethodSymbol passage)
        {
            // Both Runs would otherwise save their locals under the same keys, and the arc's frame holds only one set.
            var target = (IMethodSymbol)script.ModelFor(call).GetSymbolInfo(call).Symbol;
            string frameType = target.ContainingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) + "." +
                PassageWriter.FrameTypeName;
            return new ForeignSite(passage, script.OwnerOf(passage), null, null, "", frameType, null,
                callerName + "." + key + "/", FieldStemOf(callerName, key), call.GetLocation(), isBaseCall: true);
        }

        /// <summary>
        /// Returns the site of <paramref name="call"/> to a passage on this arc that owns a frame, made in the passage
        /// named <paramref name="callerName"/> at the pause keyed <paramref name="key"/>.
        /// </summary>
        public static ForeignSite OfOwnedFrame(ScriptClass script, string callerName,
            InvocationExpressionSyntax call, string key, IMethodSymbol passage)
        {
            var target = (IMethodSymbol)script.ModelFor(call).GetSymbolInfo(call).Symbol;
            string typeArguments = TypeArgumentsOf(target);

            // The frame is a class of the arc that declares the passage, constructed with the call's type arguments.
            string frameClass = target.ContainingType.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) + "." +
                PassageWriter.OwnedFrameName(passage);
            string frameDefinition = null;
            string typeArgumentTypes = null;
            IMethodSymbol caller = script.Passages.FirstOrDefault(each => each.Name == callerName);
            if (caller != null && script.InSameCycle(caller, passage)
                && target.TypeArguments.Any(argument => ScriptChecks.BuiltFrom(argument, caller.TypeParameters)))
            {
                frameDefinition = frameClass + "<" + new string(',', target.TypeArguments.Length - 1) + ">";
                typeArgumentTypes = string.Join(", ", target.TypeArguments.Select(argument =>
                    "typeof(" + argument.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) + ")"));
            }

            return new ForeignSite(passage, script.OwnerOf(passage), null, null, typeArguments,
                frameClass + typeArguments, null, callerName + "." + key + "/", FieldStemOf(callerName, key),
                call.GetLocation(), frameDefinition, typeArgumentTypes);
        }
    }
}