using System;
using System.Collections.Generic;
using System.Linq;

namespace Ariadne.Vellum
{
    /// <summary>
    /// Remembers the key and type of each field and local an arc class listed, in the order it listed them, and the
    /// same for each call it listed the locals of.
    /// </summary>
    public class ArcPartList : IArcPartLister
    {
        public readonly List<string> Keys = new List<string>();
        public readonly List<Type> Types = new List<Type>();
        public readonly List<bool> IsLocal = new List<bool>();

        /// <summary>
        /// Holds the name of each call the arc class listed locals for.
        /// </summary>
        public readonly List<string> ScopeNames = new List<string>();

        /// <summary>
        /// Holds what each of <see cref="ScopeNames"/> listed, in the same order.  A call that repeats one above it
        /// holds that one's list, so the lists can form a cycle.
        /// </summary>
        public readonly List<ArcPartList> Scopes = new List<ArcPartList>();

        /// <summary>
        /// Holds the name of each call that runs a frame whose type arguments only a save says.
        /// </summary>
        public readonly List<string> PolymorphicNames = new List<string>();

        /// <summary>
        /// Holds the open generic frame class of each of <see cref="PolymorphicNames"/>, in the same order.
        /// </summary>
        public readonly List<Type> PolymorphicDefinitions = new List<Type>();

        private readonly ArcPartList parent;
        private readonly Type[] frames;

        public ArcPartList()
        {
        }

        private ArcPartList(ArcPartList parent, Type[] frames)
        {
            this.parent = parent;
            this.frames = frames;
        }

        public int Count
        {
            get
            {
                return Keys.Count;
            }
        }

        public void Field<T>(string key)
        {
            Keys.Add(key);
            Types.Add(typeof(T));
            IsLocal.Add(false);
        }

        public void Local<T>(string key)
        {
            Keys.Add(key);
            Types.Add(typeof(T));
            IsLocal.Add(true);
        }

        public void Polymorphic(string name, Type frameDefinition)
        {
            PolymorphicNames.Add(name);
            PolymorphicDefinitions.Add(frameDefinition);
        }

        /// <summary>
        /// Returns the list for the call <paramref name="name"/>, which is the same one each time it's named, or null
        /// if a call above this one runs <paramref name="frames"/> already.
        /// </summary>
        public IArcPartLister Scope(string name, params Type[] frames)
        {
            int index = ScopeNames.IndexOf(name);
            if (index >= 0)
            {
                // A repeat of a call above has nothing more to list.
                return Scopes[index].parent == this ? Scopes[index] : null;
            }

            for (ArcPartList above = this; above != null && frames.Length > 0; above = above.parent)
            {
                if (above.frames != null && above.frames.SequenceEqual(frames))
                {
                    ScopeNames.Add(name);
                    Scopes.Add(above);
                    return null;
                }
            }

            var returnMe = new ArcPartList(this, frames);
            ScopeNames.Add(name);
            Scopes.Add(returnMe);
            return returnMe;
        }
    }
}