using System;
using System.Collections.Generic;
using System.Text;

using LoaderColl = System.Collections.Generic.IList<SubSonic.LoaderCallbackPair>;

namespace SubSonic
{
    /// <summary>
    /// A delegate to handle loading of single objects, generally for use when loading a foreign key relationship
    /// from a parent object.
    /// </summary>
    /// <param name="type">Expected type of the object to load</param>
    /// <param name="id">The object's primary key value</param>
    /// <returns>An object, or null if none available</returns>
    public delegate IActiveRecord SingleObjectLoader(Loaders.SingleObjectData data);

    /// <summary>
    /// A delegate to use for callback purposes when an item is loaded later in the "chain"
    /// </summary>
    /// <param name="value">The found value</param>
    /// <param name="id">The ID used to find the value</param>
    public delegate void SingleObjectLoadedCallback(IActiveRecord value, object id);

    /// <summary>
    /// A generic delegate that roughly matches up to the various FetchById functions
    /// </summary>
    /// <typeparam name="ItemType">The Item type to fetch</typeparam>
    /// <typeparam name="KeyType">The key type to fetch with</typeparam>
    /// <param name="id">The primary key value to fetch</param>
    /// <returns>An object, or null if none available</returns>
    public delegate ItemType FetchByDelegate<ItemType, KeyType>(KeyType id) where ItemType : IActiveRecord;

    /// <summary>
    /// A utility class to use when loading object relationships
    /// </summary>
    public static class Loaders
    {
        public class SingleObjectData
        {
            private readonly Type type;

            public Type Type
            {
                get { return type; }
            }

            private readonly object id;

            public object ID
            {
                get { return id; }
            }

            private readonly IActiveRecord parent;

            public IActiveRecord Parent
            {
                get { return parent; }
            }

            public SingleObjectData(Type type, object id, IActiveRecord parent)
            {
                this.type = type;
                this.id = id;
                this.parent = parent;
            }
        }
        /// <summary>
        /// Converts a FetchByDelegate to a SingleObjectLoader delegate
        /// </summary>
        /// <typeparam name="ItemType">The Item type to fetch</typeparam>
        /// <typeparam name="KeyType">The key type to fetch with</typeparam>
        /// <param name="fetchBy">The FetchByDelegate to convert</param>
        /// <returns>A SingleObjectLoader</returns>
        public static SingleObjectLoader ConvertToSingleObjectLoader<ItemType, KeyType>(FetchByDelegate<ItemType, KeyType> fetchBy)
            where ItemType : IActiveRecord
        {
            return delegate(SingleObjectData data)
                       {
                           return fetchBy((KeyType)data.ID);
                       };
        }

        /// <summary>
        /// Loads a single object using the specified ID, a ranked collection of object loaders, and a fallback loader
        /// </summary>
        /// <typeparam name="T">The type of object to load</typeparam>
        /// <param name="id">Primary key to load with</param>
        /// <param name="loaders">A set of loaders to check</param>
        /// <param name="fallbackLoader">A fallback loader to use if no other loaders yielded results</param>
        /// <returns>The specified object, or null if not found</returns>
        public static T LoadSingleObject<T>(object id, LoaderColl loaders, SingleObjectLoader fallbackLoader, IActiveRecord parent)
            where T : class, IActiveRecord
        {
            T v = null;
            Loaders.SingleObjectData data = new SingleObjectData(typeof(T), id, parent);
            if (loaders != null)
            {
                int foundIndex = -1;
                // Checks the list of loaders for a matching object

                for(int i = 0; i < loaders.Count; i++)
                {
                    SingleObjectLoader loader = loaders[i].Loader;
                    if(loader != null && (v = loader(data) as T) != null)
                    {
                        foundIndex = i;
                        break;
                    }
                }

                // If not found, uses the fallback loader.  Sets the index to the collection count
                // so all callbacks will be referenced
                if(v == null)
                {
                    v = fallbackLoader(data) as T;
                    foundIndex = loaders.Count;
                }

                // Runs through relevant callbacks
                for(int i = 0; i < foundIndex; i++)
                {
                    SingleObjectLoadedCallback callback = loaders[i].Callback;
                    if (callback != null)
                    {
                        callback(v, id);
                    }
                }
            }
            return v ?? fallbackLoader(data) as T;
        }
    }

    public class LoaderCallbackPair
    {
        private readonly SingleObjectLoader loader;

        public SingleObjectLoader Loader
        {
            get { return loader; }
        }

        private readonly SingleObjectLoadedCallback callback;

        public SingleObjectLoadedCallback Callback
        {
            get { return callback; }
        }


        public LoaderCallbackPair(SingleObjectLoader loader, SingleObjectLoadedCallback callback)
        {
            this.loader = loader;
            this.callback = callback;
        }
    }
}