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

namespace Ariadne.UnitTests
{
    /// <summary>
    /// Saves an arc as plain objects, for testing arcs without a save library.
    /// </summary>
    public class ArcRecord : IArcWriter, IArcReader
    {
        public readonly Dictionary<string, object> Fields = new Dictionary<string, object>(StringComparer.Ordinal);

        /// <summary>
        /// This field holds the locals written at this level, which leave out those of the calls it holds.
        /// </summary>
        public readonly Dictionary<string, object> Locals = new Dictionary<string, object>(StringComparer.Ordinal);

        /// <summary>
        /// This field holds what each call written at this level saved, by the name the call was given.
        /// </summary>
        public readonly Dictionary<string, ArcRecord> Scopes =
            new Dictionary<string, ArcRecord>(StringComparer.Ordinal);

        /// <summary>
        /// This field holds the type each field and local was written as, by key.
        /// </summary>
        public readonly Dictionary<string, Type> Types = new Dictionary<string, Type>(StringComparer.Ordinal);

        /// <summary>
        /// This field holds each arc handed to Publish, in order.
        /// </summary>
        public readonly List<object> Published = new List<object>();

        // The record of the whole arc, which is this one unless this holds the locals of a call.
        private readonly ArcRecord root;

        public ArcRecord()
        {
            root = this;
        }

        private ArcRecord(ArcRecord root)
        {
            this.root = root;
        }

        public List<string> Cursor { get; } = new List<string>();

        IReadOnlyList<string> IArcReader.Cursor
        {
            get
            {
                return root.Cursor;
            }
        }

        public bool Finished { get; set; }

        bool IArcReader.Finished
        {
            get
            {
                return root.Finished;
            }
        }

        public IEnumerable<string> LocalKeys
        {
            get
            {
                return Locals.Keys;
            }
        }

        public IEnumerable<string> ScopeNames
        {
            get
            {
                return Scopes.Keys;
            }
        }

        /// <summary>
        /// Returns every local written, by the path of calls it was written under and its key, eg:
        /// <c>Run.first/Step.gate</c>.
        /// </summary>
        public Dictionary<string, object> AllLocals()
        {
            var returnMe = new Dictionary<string, object>(StringComparer.Ordinal);
            var pending = new Stack<KeyValuePair<string, ArcRecord>>();
            pending.Push(new KeyValuePair<string, ArcRecord>("", this));
            while (pending.Count > 0)
            {
                KeyValuePair<string, ArcRecord> level = pending.Pop();
                foreach (KeyValuePair<string, object> local in level.Value.Locals)
                {
                    returnMe.Add(level.Key + local.Key, local.Value);
                }

                foreach (KeyValuePair<string, ArcRecord> scope in level.Value.Scopes)
                {
                    pending.Push(new KeyValuePair<string, ArcRecord>(level.Key + scope.Key, scope.Value));
                }
            }

            return returnMe;
        }

        public static ArcRecord Of<ContextType>(Arc<ContextType> arc)
        {
            var returnMe = new ArcRecord();
            arc.Save(returnMe);
            return returnMe;
        }

        void IArcWriter.Cursor(IReadOnlyList<string> cursor)
        {
            root.Cursor.Clear();
            root.Cursor.AddRange(cursor);
        }

        void IArcWriter.Finished(bool finished)
        {
            root.Finished = finished;
        }

        /// <exception cref="ArgumentException">The arc already wrote a field with this key.</exception>
        public void Field<T>(string key, T value)
        {
            root.Fields.Add(key, value);
            root.Types.Add(key, typeof(T));
        }

        /// <exception cref="ArgumentException">The arc already wrote a local with this key.</exception>
        public void Local<T>(string key, T value)
        {
            Locals.Add(key, value);
            Types.Add(key, typeof(T));
        }

        /// <exception cref="ArgumentException">The arc already wrote a call with this name.</exception>
        public IArcWriter Scope(string name)
        {
            var returnMe = new ArcRecord(root);
            Scopes.Add(name, returnMe);
            return returnMe;
        }

        private static bool TryGet<T>(Dictionary<string, object> values, string key, out T value)
        {
            object found;
            if (!values.TryGetValue(key, out found))
            {
                value = default(T);
                return false;
            }

            value = (T)found;
            return true;
        }

        /// <summary>
        /// This field holds the type arguments written at this level, or null if none were.
        /// </summary>
        public Type[] SavedTypeArguments;

        public void TypeArguments(params Type[] types)
        {
            SavedTypeArguments = types;
        }

        public bool TryTypeArguments(out Type[] types)
        {
            types = SavedTypeArguments;
            return types != null;
        }

        public bool TryField<T>(string key, out T value)
        {
            return TryGet(root.Fields, key, out value);
        }

        public bool HasField(string key)
        {
            return root.Fields.ContainsKey(key);
        }

        public bool TryLocal<T>(string key, out T value)
        {
            return TryGet(Locals, key, out value);
        }

        public bool TryScope(string name, out IArcReader scope)
        {
            ArcRecord found;
            bool returnMe = Scopes.TryGetValue(name, out found);
            scope = found;
            return returnMe;
        }

        public void Publish(object built)
        {
            root.Published.Add(built);
        }
    }
}