The Time Machine

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

using CategoryTheory;
using DiagramUI;
using DiagramUI.Labels;
using DiagramUI.Interfaces;


using DataPerformer.Interfaces;

namespace DataPerformer
{
    /// <summary>
    /// This class performs most common operations
    /// </summary>
    public class DataPerformerOperations
    {
        /// <summary>
        /// Data consumer
        /// </summary>
        protected IDataConsumer consumer;

        /// <summary>
        /// List of measurements
        /// </summary>
        protected List<string> measurements = new List<string>();

        /// <summary>
        /// List of alias names
        /// </summary>
        protected List<string> aliasNames = new List<string>();

        /// <summary>
        /// List of aliases
        /// </summary>
        protected List<object[]> aliases = new List<object[]>();


        /// <summary>
        /// List of measures
        /// </summary>
        protected List<IMeasure> measures = new List<IMeasure>();
        


        #region Specific Members

        /// <summary>
        /// Trasformation
        /// </summary>
        /// <param name="input">Input</param>
        /// <param name="output">Output</param>
        public void Transform(object[] input, object[] output)
        {
            for (int i = 0; i < input.Length; i++)
            {
                object[] al = aliases[i];
                IAlias a = al[0] as IAlias;
                string s = al[1] as string;
                a[s] = input[i];
            }
            consumer.ResetAll();
            consumer.UpdateChildrenData();
            for (int i = 0; i < output.Length; i++)
            {
                IMeasure m = measures[i];
                output[i] = m.Parameter();
            }
        }

 
        /// <summary>
        /// Sets data to consumer
        /// </summary>
        /// <param name="consumer">The consumer</param>
        /// <param name="measurements">Names of measurements</param>
        /// <param name="aliasNames">Names of aliases</param>
        public void Set(IDataConsumer consumer, List<string> measurements, List<string> aliasNames)
        {
            aliases.Clear();
            measures.Clear();
            this.measurements = measurements;
            this.aliasNames = aliasNames;
            this.consumer = consumer;
            Set();
        }

        /// <summary>
        /// Sets all own settings
        /// </summary>
        public void Set()
        {
            SetMeasurements(consumer, measurements, measures);
            SetAliases(consumer, aliasNames, aliases);
        }

        /// <summary>
        /// Finds alias
        /// </summary>
        /// <param name="consumer">Data consumer</param>
        /// <param name="alias">Alias</param>
        /// <returns>Pair object[] {alias, name}</returns>
        public static object[] FindAlias(IDataConsumer consumer, string alias)
        {
            return findAlias(consumer, consumer, alias);
        }

 
        /// <summary>
        /// Sets measures to consumer
        /// </summary>
        /// <param name="consumer">The consumer</param>
        /// <param name="measures">Names of measures</param>
        /// <param name="measuresData">Measures</param>
        public static void SetMeasurements(IDataConsumer consumer, List<string> measures, List<IMeasure> measuresData)
        {
            measuresData.Clear();
            IAssociatedObject ac = consumer as IAssociatedObject;
            foreach (string ms in measures)
            {
                for (int i = 0; i < consumer.Count; i++)
                {
                    IMeasurements m = consumer[i];
                    IAssociatedObject ao = m as IAssociatedObject;
                    string on = ac.GetRelativeName(ao) + ".";

                    for (int j = 0; j < m.Count; j++)
                    {
                        IMeasure mea = m[j];
                        string s = on + mea.Name;
                        if (s.Equals(ms))
                        {
                            measuresData.Add(mea);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Gets all aliases of consumer and all its children
        /// </summary>
        /// <param name="consumer">The consumer</param>
        /// <param name="list">List of aliases</param>
        /// <param name="type">Type of aliases</param>
        public static void GetAliases(IDataConsumer consumer, List<string> list, object type)
        {
            getAliases(consumer, consumer, list, type);
        }

        /// <summary>
        /// Gets all aliases of consumer and all its children
        /// </summary>
        /// <param name="consumer">The consumer</param>
        /// <param name="type">Type of aliases</param>
        public static List<string> GetAliases(IDataConsumer consumer, object type)
        {
            List<string> list = new List<string>();
            GetAliases(consumer, list, type);
            return list;
        }

        /// <summary>
        /// Sets aliases to consumer
        /// </summary>
        /// <param name="consumer">The consumer</param>
        /// <param name="aliasNames">Names of aliases</param>
        /// <param name="aliases">Aliases</param>
        public static void SetAliases(IDataConsumer consumer, List<string> aliasNames, List<object[]> aliases)
        {
            List<string> al = new List<string>();
            GetAliases(consumer, al);
            for (int i = 0; i < aliasNames.Count; i++)
            {
                string an = aliasNames[i];
                object[] o = FindAlias(consumer, an);
                aliases.Add(o);
            }
        }


        private static void getAliases(IDataConsumer baseObject, IDataConsumer consumer, List<string> list, object type)
        {
            IAssociatedObject ao = consumer as IAssociatedObject;
            PureObjectLabel.GetObjectAliases(ao, consumer, list, type);
            for (int i = 0; i < consumer.Count; i++)
            {
                object o = consumer[i];
                if (o is IDataConsumer)
                {
                    IDataConsumer c = o as IDataConsumer;
                    getAliases(consumer, c, list, type);
                }
                else
                {
                    PureObjectLabel.GetObjectAliases(ao, o, list, type);
                }
            }
        }



        /// <summary>
        /// Finds alias
        /// </summary>
        /// <param name="baseObject">Base object</param>
        /// <param name="consumer">Consumer</param>
        /// <param name="alias">Alias</param>
        /// <returns>Pair object[] {alias, name}</returns>
        public static object[] findAlias(IDataConsumer baseObject, IDataConsumer consumer, string alias)
        {
            IAssociatedObject ao = baseObject as IAssociatedObject;
            INamedComponent nc = PureObjectLabel.PrefixComponent(ao, consumer, alias);
            if ((nc != null) & (consumer is IAlias))
            {
                return new object[] { consumer, PureObjectLabel.Suffix(alias) };
            }
            for (int i = 0; i < consumer.Count; i++)
            {
                object o = consumer[i];
                if (o is IDataConsumer)
                {
                    IDataConsumer c = o as IDataConsumer;
                    object[] r = findAlias(baseObject, c, alias);
                    if (r != null)
                    {
                        return r;
                    }
                }
                else
                {
                    INamedComponent comp = PureObjectLabel.PrefixComponent(ao, o, alias);
                    if ((comp != null) & (o is IAlias))
                    {
                        return new object[] { o, PureObjectLabel.Suffix(alias) };
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// Gets all measurements names of consumer
        /// </summary>
        /// <param name="consumer">The consumer</param>
        /// <param name="type">Measure type</param>
        /// <returns>List of names of measurements</returns>
        static public List<string> GetAllMeasurements(IDataConsumer consumer, object type)
        {
            List<string> list = new List<string>();
            for (int i = 0; i < consumer.Count; i++)
            {
                IMeasurements m = consumer[i];
                IAssociatedObject ao = m as IAssociatedObject;
                IAssociatedObject th = consumer as IAssociatedObject;
                string on = th.GetRelativeName(ao) + ".";
                for (int j = 0; j < m.Count; j++)
                {
                    IMeasure mea = m[j];
                    string s = on + mea.Name;
                    if (type == null)
                    {
                        list.Add(s);
                        continue;
                    }
                    if (mea.Type.Equals(type))
                    {
                        list.Add(s);
                    }
                }
            }
            return list;
        }


        #endregion

    }
}