//-----------------------------------------------------------------------
// <copyright file="DataRequester.cs" company="bedug.com">
//     Copyright © 2012 Nils Hammar. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
/*
 * Software to access vehicle information via the OBD-II connector.
 * 
 * Copyright © 2012 Nils Hammar
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Alternative licensing is possible, see the licensing document.
 * 
 * The above text may not be removed or modified.
 */

namespace Protocol.OBD
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.IO.Ports;
    using System.Linq;
    using System.Threading;
    using System.Windows.Forms;
    using global::DataLogging;
    using global::SharedObjects;
    using global::SharedObjects.DataLogging;
    using global::SharedObjects.DataLogging.Objects;
    using global::SharedObjects.DataMgmt;
    using global::SharedObjects.GUI.OBD;
    using global::SharedObjects.Misc;
    using global::SharedObjects.Misc.Objects;
    using global::SharedObjects.Protocol;

    /// <summary>
    /// Class for managing data requests initiated by the GUI.
    /// </summary>
    public class DataRequester
    {
        /// <summary>
        /// Number of items per SSM request.
        /// <para>
        /// Can be up to 75 (given by trial&amp;error), but 64 seems to be a good value.
        /// </para>
        /// </summary>
        private const int ITEMS_PER_SSM_REQUEST = 64;

        /// <summary>
        /// Gets or sets interval between plotting/logging polls.
        /// </summary>
        public int pollInterval { get; set; }

        /// <summary>
        /// Messaging interface instance.
        /// </summary>
        private IMessaging iMessaging;

        /// <summary>
        /// Gets data log interface instance.
        /// </summary>
        public IDataLogInstance iDataLog { get; private set; }

        /// <summary>
        /// Gets a value indicating whether logging status is active.
        /// </summary>
        public bool logging { get; private set; }

        /// <summary>
        /// Gets a value indicating whether plotting status is active.
        /// </summary>
        public bool plotting { get; private set; }

        /// <summary>
        /// List of requests to perform.
        /// </summary>
        private List<IRequestData> requests = new List<IRequestData>();

        /// <summary>
        /// List of requests to perform.
        /// </summary>
        private Dictionary<uint, List<SsmItemWrapper>> ssmReadAddresses = new Dictionary<uint, List<SsmItemWrapper>>();

        /// <summary>
        /// Current Mode parser.
        /// </summary>
        private ModeParser modeParser = null;

        /// <summary>
        /// Thread for regular polling of data.
        /// </summary>
        private Thread pollThread = null;

        /// <summary>
        /// Thread for reception of NMEA GPS data.
        /// </summary>
        private Thread gpsThread = null;

        /// <summary>
        /// Dictionary of value names when plotting.
        /// </summary>
        private StackedDictionary<uint, string> nodeValueDictionary = new StackedDictionary<uint, string>();

        /// <summary>
        /// Logging instance.
        /// </summary>
        private ILogging iLogging;

        /// <summary>
        /// Preferences interface instance.
        /// </summary>
        private IPreferences iPreferences;

        /// <summary>
        /// Data source instance.
        /// </summary>
        private IDataSource iDataSource;

        /// <summary>
        /// Progress feedback instance.
        /// </summary>
        private IProgressFeedback iProgressFeedback;

        /// <summary>
        /// Number of items per SSM request, protocol dependent value.
        /// </summary>
        private int itemsPerSsmRequest = 1;

        /// <summary>
        /// Initializes a new instance of the <see cref="DataRequester" /> class.
        /// </summary>
        /// <param name="iLogging">Logging instance</param>
        /// <param name="iPreferences">Preferences interface instance</param>
        /// <param name="iMessaging">Messaging instance.</param>
        /// <param name="modeParser">Mode parser instance.</param>
        /// <param name="iDataSource">Data source interface instance.</param>
        /// <param name="protocolHandler">Current protocol handler instance.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "5", Justification = "Reviewed, intentional.")]
        public DataRequester(
            ILogging iLogging,
            IPreferences iPreferences,
            IMessaging iMessaging,
            ModeParser modeParser,
            IDataSource iDataSource,
            IProtocolHandler protocolHandler)
        {
            this.iLogging = iLogging;
            this.iPreferences = iPreferences;
            this.iMessaging = iMessaging;
            this.modeParser = modeParser;
            this.iDataSource = iDataSource;
            this.itemsPerSsmRequest = 1;

            if (protocolHandler != null && protocolHandler.protocol != null)
            {
                // Only a J2534 interface with ISO15765 can do some good stuff.
                switch (protocolHandler.protocol.id)
                {
                    case Protocols.ISO15765:
                        this.itemsPerSsmRequest = ITEMS_PER_SSM_REQUEST;
                        break;

                    default:
                        this.itemsPerSsmRequest = 1;
                        break;
                }
            }

            this.iDataLog = new DataLogInstance(this.iLogging);

            this.pollInterval = 1000;
            this.plotting = false;
            this.logging = false;
        }

        /// <summary>
        /// Get the destination address from the source address.
        /// </summary>
        /// <param name="protocolHandler">Current protocol handler instance.</param>
        /// <param name="sourceAddress">Source address to use.</param>
        /// <returns>Prepared destination address.</returns>
        public static uint? getDestinationAddress(IProtocolHandler protocolHandler, uint sourceAddress)
        {
            uint? destinationAddress = null;

            if (protocolHandler != null && protocolHandler.protocol != null)
            {
                switch (protocolHandler.protocol.id)
                {
                    case Protocols.SERIAL_AT_AGV:
                    case Protocols.SERIAL_AT_ELM:
                        destinationAddress = getSerialAtDestAddress(protocolHandler, sourceAddress);
                        break;

                    case Protocols.ISO15765:
                        destinationAddress = getIso15765DestAddress(sourceAddress);
                        break;

                    default:
                        // No action.
                        break;
                }
            }

            return destinationAddress;
        }

        /// <summary>
        /// Start the Plot thread.
        /// </summary>
        /// <param name="iProgressFeedback">Progress feedback interface.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", MessageId = "iProgressFeedback", Justification = "Reviewed, intentional.")]
        public void startPlotThread(IProgressFeedback iProgressFeedback)
        {
            this.iProgressFeedback = iProgressFeedback;
            this.pollThread = new Thread(new ThreadStart(this.pollThreadImplementation));
            this.pollThread.Name = "DRQ Poll";
            this.pollThread.Start();
        }

        /// <summary>
        /// Start the GPS thread.
        /// </summary>
        public void startGpsThread()
        {
            this.gpsThread = new Thread(this.gpsThreadImplementation);
            this.gpsThread.Name = "GPS Poll";
            this.gpsThread.Start();
        }

        /// <summary>
        /// Prepare for plotting and/or logging of data.
        /// </summary>
        /// <param name="plotting">'true' if plotting.</param>
        /// <param name="logging">'true' if logging.</param>
        public void preparePlotting(bool plotting, bool logging)
        {
            this.plotting = plotting;
            this.logging = logging;
        }

        /// <summary>
        /// Stop plotting/logging.
        /// </summary>
        public void stopPlotting()
        {
            this.plotting = false;
            this.logging = false;
            if (this.pollThread != null)
            {
                this.iLogging.appendText("Poll Thread stopping.\r\n");
                this.pollThread.Abort();
                this.pollThread.Interrupt();
                this.pollThread.Join(4000);
                this.pollThread = null;
                this.iLogging.appendText("Poll Thread stopped.\r\n");
            }
        }

        /// <summary>
        /// Prepare for data request by initializing the data stores.
        /// </summary>
        public void prepareRequestData()
        {
            this.requests = new List<IRequestData>();
            this.nodeValueDictionary = new StackedDictionary<uint, string>();
        }

        /// <summary>
        /// Finalize the data request.
        /// </summary>
        public void finishPrepareDataRequest()
        {
            foreach (uint destinationAddress in this.ssmReadAddresses.Keys)
            {
                this.nextSsmChunk(destinationAddress);
            }

            if (this.logging && this.iDataLog.isLogOpen())
            {
                this.iDataLog.initLog(this.nodeValueDictionary, this.gpsThread != null ? this.gpsThread.IsAlive : false);
            }
        }

        /// <summary>
        /// Handle one PID when building a request.
        /// <para>
        /// Notice that Mode 0x02 uses same PID list as 0x01, which means that there
        /// are some tweaks built in for that.
        /// </para>
        /// </summary>
        /// <param name="destinationAddresses">Destination addresses to send to.</param>
        /// <param name="actualMode">Mode byte.</param>
        /// <param name="frameNumber">Freeze Frame number (Mode 0x02), ignored when current data.</param>
        /// <param name="pidGroupMode">Mode by Pid Group.</param>
        /// <param name="pid">PID item.</param>
        /// <param name="actualPid">Actual PID id.</param>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "3", Justification = "Reviewed, intentional.")]
        public void handlePid(
            IList<uint> destinationAddresses,
            byte actualMode,
            byte frameNumber,
            uint pidGroupMode,
            XmlClass.pidgroup.pidlist pid,
            uint actualPid)
        {
            if (destinationAddresses != null)
            {
                foreach (uint destinationAddress in destinationAddresses)
                {
                    this.addValueNames(destinationAddress, pidGroupMode, pid, actualPid);

                    switch (actualMode)
                    {
                        case 0x01:
                            byte[] normalPidBa = new byte[] { actualMode, (byte)(actualPid & 0xff) };
                            this.requests.Add(new RequestData(destinationAddress, actualMode, pid, new TxMsg(normalPidBa)));
                            break;
                        case 0x02:
                            byte[] freezeFrameBa = new byte[] { actualMode, (byte)(actualPid & 0xff), frameNumber };
                            this.requests.Add(new RequestData(destinationAddress, actualMode, pid, new TxMsg(freezeFrameBa)));
                            break;
                        case 0xA0:
                            this.requests.Add(getSsmEntry(destinationAddress, actualMode, pid));
                            break;
                        case 0xA8:
                            // Do nothing here, see below.
                            break;
                        case 0x22:
                            byte[] extendedPidBa = new byte[] { actualMode, (byte)((actualPid >> 8) & 0xff), (byte)(actualPid & 0xff) };
                            this.requests.Add(new RequestData(destinationAddress, actualMode, pid, new TxMsg(extendedPidBa)));
                            break;
                        default:
                            byte[] defaultActionBa = new byte[] { actualMode, (byte)(actualPid & 0xff) };
                            this.requests.Add(new RequestData(destinationAddress, actualMode, pid, new TxMsg(defaultActionBa)));
                            break;
                    }
                }

                switch (actualMode)
                {
                    case 0xA8:
                        this.addSsmEntry(destinationAddresses, pid);
                        break;
                }
            }
        }

        /// <summary>
        /// Perform a request for data.
        /// </summary>
        public void requestSelectedPids()
        {
            this.requestSelectedPids(this.requests);
        }

        /// <summary>
        /// If it's a serial AT device we can still figure out protocol at a second step.
        /// </summary>
        /// <param name="protocolHandler">Current protocol handler instance.</param>
        /// <param name="sourceAddress">Source address to use.</param>
        /// <returns>Created destination address or 'null' if not supported.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "Reviewed.")]
        private static uint? getSerialAtDestAddress(IProtocolHandler protocolHandler, uint sourceAddress)
        {
            uint? destinationAddress = null;

            if (protocolHandler is Protocol_Serial_AT)
            {
                Protocol_Serial_AT psa = (Protocol_Serial_AT)protocolHandler;
                switch (psa.detectedProtocol)
                {
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                        destinationAddress = getIso15765DestAddress(sourceAddress);
                        break;

                    default:
                        destinationAddress = 0x00;
                        break;
                }
            }

            return destinationAddress;
        }

        /// <summary>
        /// Get the destination address from the source address for ISO 15765.
        /// </summary>
        /// <param name="sourceAddress">Source address to use.</param>
        /// <returns>Created destination address or 'null' if not supported.</returns>
        private static uint? getIso15765DestAddress(uint sourceAddress)
        {
            uint? destinationAddress = null;

            if (sourceAddress > 0x800)
            {
                destinationAddress = (sourceAddress & 0x18FF0000) | ((sourceAddress & 0xff) << 8) | ((sourceAddress & 0xff00) >> 8);
            }
            else
            {
                destinationAddress = (sourceAddress & 0x7F7);
            }

            return destinationAddress;
        }

        /// <summary>
        /// Build a request entry with SSM request data.
        /// </summary>
        /// <param name="destinationAddress">Destination address to send to.</param>
        /// <param name="mode">Mode byte value.</param>
        /// <param name="ssmPid">PID item for the entry.</param>
        /// <returns>Request data instance.</returns>
        private static IRequestData getSsmEntry(uint? destinationAddress, uint mode, XmlClass.pidgroup.pidlist ssmPid)
        {
            uint addr = ssmPid.pid_int;
            int n1 = 0;
            byte[] ba;

            if (mode == 0xA8)
            {
                ba = new byte[(2 + (3 * ssmPid.pid_bytes))];
                ba[n1++] = 0xA8; // SSM Read
                ba[n1++] = 0x00; // Pad
                int k = 0;
                while (ssmPid.pid_bytes > k)
                {
                    ba[n1++] = (byte)((addr >> 16) & 0xff);
                    ba[n1++] = (byte)((addr >> 8) & 0xff);
                    ba[n1++] = (byte)(addr & 0xff);

                    addr++;
                    k++;
                }

                return new RequestData(destinationAddress, 0xA8, ssmPid, new TxMsg(ba));
            }

            ba = new byte[6];
            ba[n1++] = 0xA0; // SSM Read
            ba[n1++] = 0x00; // Pad
            ba[n1++] = (byte)((addr >> 16) & 0xff);
            ba[n1++] = (byte)((addr >> 8) & 0xff);
            ba[n1++] = (byte)(addr & 0xff);
            ba[n1++] = (byte)ssmPid.pid_bytes;

            return new RequestData(destinationAddress, 0xA0, ssmPid, new TxMsg(ba));
        }

        /// <summary>
        /// Build a request entry with SSM request data.
        /// </summary>
        /// <param name="destinationAddresses">Destination addresses to send to.</param>
        /// <param name="ssmPid">PID item for the entry.</param>
        private void addSsmEntry(IList<uint> destinationAddresses, XmlClass.pidgroup.pidlist ssmPid)
        {
            // List<SsmItemWrapper>
            foreach (uint destinationAddress in destinationAddresses)
            {
                List<SsmItemWrapper> itemList;
                if (this.ssmReadAddresses.ContainsKey(destinationAddress))
                {
                    itemList = this.ssmReadAddresses[destinationAddress];
                }
                else
                {
                    itemList = new List<SsmItemWrapper>();
                    this.ssmReadAddresses.Add(destinationAddress, itemList);
                }

                uint addr = ssmPid.pid_int;

                if ((itemList.Count + ssmPid.pid_bytes) > this.itemsPerSsmRequest)
                {
                    this.nextSsmChunk(destinationAddress);
                }

                for (int i = 0; i < ssmPid.pid_bytes; i++)
                {
                    byte[] ba = new byte[3];
                    int n1 = 0;
                    ba[n1++] = (byte)((addr >> 16) & 0xff);
                    ba[n1++] = (byte)((addr >> 8) & 0xff);
                    ba[n1++] = (byte)(addr & 0xff);

                    itemList.Add(new SsmItemWrapper(ba));

                    addr++;
                }
            }
        }

        /// <summary>
        /// Add next SSM chunk to the list of requests.
        /// </summary>
        /// <param name="destinationAddress">Destination ECU.</param>
        private void nextSsmChunk(uint destinationAddress)
        {
            if (this.ssmReadAddresses.ContainsKey(destinationAddress))
            {
                List<SsmItemWrapper> itemList = this.ssmReadAddresses[destinationAddress];

                if (itemList.Count > 0)
                {
                    byte[] ba = new byte[(2 + (itemList.Count * 3))];

                    int n1 = 0;
                    ba[n1++] = 0xA8; // SSM Read
                    ba[n1++] = 0x00; // Pad

                    foreach (SsmItemWrapper ssmItemWrapper in itemList)
                    {
                        Array.Copy(ssmItemWrapper.data, 0, ba, n1, 3);
                        n1 += 3;
                    }

                    this.requests.Add(new RequestData(destinationAddress, 0xA8, null, new TxMsg(ba)));

                    itemList.Clear();
                }
            }
        }

        /// <summary>
        /// Add names of values to a dictionary using the mode, PID and sensor number.
        /// <para>
        /// Notice that this is only working for 16 bit PIDs, if they are longer - like some SSM PIDs
        /// there is a risk of some quirky behavior and failure to map correctly.
        /// </para>
        /// </summary>
        /// <param name="destinationAddress">Destination address to send to.</param>
        /// <param name="pidGroupMode">Mode byte.</param>
        /// <param name="pid">PID information instance, used to get name of PID.</param>
        /// <param name="actualPid">Actual PID ID. Only the 16 lower bits are considered.</param>
        private void addValueNames(uint? destinationAddress, uint pidGroupMode, XmlClass.pidgroup.pidlist pid, uint actualPid)
        {
            uint k = 0;
            foreach (XmlClass.pidgroup.pidlist.sensordata sensor in pid.sensors)
            {
                XmlClass.unititem thisunit = null;
                foreach (XmlClass.unititem unit in this.iDataSource.units)
                {
                    if (sensor != null && unit != null && sensor.unit != null && sensor.unit.Equals(unit.name))
                    {
                        thisunit = unit;
                        break;
                    }
                }

                if (this.iPreferences.selectedUnitCategory == 0 || (thisunit != null
                    && (thisunit.category == 0
                        || (thisunit.category > 0 && thisunit.category == this.iPreferences.selectedUnitCategory))))
                {
                    uint da = (destinationAddress != null) ? (uint)destinationAddress : 0;
                    uint[] keys = { da, pidGroupMode, actualPid, k };
                    this.nodeValueDictionary.Add(keys, "0x" + da.ToString("X2") + ": " + pid.name + " " + sensor.name + " " + sensor.unit);
                }

                k++;
            }
        }

        /// <summary>
        /// Perform a request for data.
        /// </summary>
        /// <param name="requestItems">List of request items.</param>
        private void requestSelectedPids(IList<IRequestData> requestItems)
        {
            try
            {
                this.performRequest(requestItems);
            }
            catch (ThreadAbortException)
            {
                throw;
            }
            catch (Exception ex)
            {
                MessageBox.Show(
                    ex.Message + "\r\n\r\n" + ex.StackTrace,
                    "Error",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Stop);
                throw;
            }
        }

        /// <summary>
        /// Perform a request for data.
        /// </summary>
        /// <param name="requestItems">List of request items.</param>
        private void performRequest(IList<IRequestData> requestItems)
        {
            IList<IRequestData> pendingModeRequests = new List<IRequestData>();

            IRequestData[] rda = requestItems.ToArray<IRequestData>();

            foreach (IRequestData request in rda)
            {
                pendingModeRequests.Add(request);
            }

            if (this.modeParser != null)
            {
                this.modeParser.setPendingRequests(pendingModeRequests);
            }

            // Tell the message handler to send one message.
            this.iMessaging.sendMsg();
        }

        /// <summary>
        /// Implementation of the GPS listen thread.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "Reviewed.")]
        private void gpsThreadImplementation()
        {
            SerialPort sp = null;
            try
            {
                this.iLogging.appendText("Open GPS port: '" + this.iPreferences.gpsSerialPortName + "'\r\n");
                sp = new SerialPort(this.iPreferences.gpsSerialPortName, 4800, Parity.None, 8, StopBits.One);
                sp.Handshake = Handshake.None;
                sp.Open();

                GpsData gpsData = null;

                bool valid = false;

                while (this.plotting || this.logging)
                {
                    try
                    {
                        string line = sp.ReadLine();
#if TRACE
                        this.iLogging.appendText("line=" + line + "\r\n");
#endif

                        if (line.StartsWith("$GPRMC"))
                        {
                            string[] sa = line.Split(new char[] { ',' });
                            valid = (sa[2] == "A");
                            if (valid)
                            {
                                gpsData = new GpsData(sa[1], sa[9], sa[3], sa[4], sa[5], sa[6], sa[7], sa[8]);
                            }
                        }

                        if (valid && gpsData != null && line.StartsWith("$GPGGA"))
                        {
                            string[] sa = line.Split(new char[] { ',' });
                            gpsData.addGGA(sa[8], sa[9], sa[10]);

                            this.iDataLog.logGps(gpsData, DateTime.Now.Ticks);
                        }
                    }
                    catch
                    {
                        // Garbage on the line, try again.
                    }
                }
            }
            catch (IOException ex)
            {
                this.iLogging.appendText("gpsThreadImplementation(): " + ex.GetType().ToString() + ", " + ex.Message + "\r\n" + ex.StackTrace + "\r\n");
                Exception sub = ex.InnerException;
                while (sub != null)
                {
                    this.iLogging.appendText("gpsThreadImplementation(sub): " + sub.GetType().ToString() + ", " + sub.Message + "\r\n" + sub.StackTrace + "\r\n");
                    sub = sub.InnerException;
                }
            }
            finally
            {
                if (sp != null)
                {
                    try
                    {
                        sp.Close();
                    }
                    catch
                    {
                    }

                    try
                    {
                        sp.Dispose();
                    }
                    catch
                    {
                    }
                }
            }
        }

        /// <summary>
        /// Implementation of the poll thread.
        /// </summary>
        private void pollThreadImplementation()
        {
            IList<IRequestData>[] rqArr = this.buildRequestData();

            this.pollLoop(rqArr);

            this.iLogging.appendText("Poll Thread ended.\r\n");
        }

        /// <summary>
        /// Loop for polling for data and logging it.
        /// </summary>
        /// <param name="rqArr">Array of requests to loop through.</param>
        private void pollLoop(IList<IRequestData>[] rqArr)
        {
            int nextBeforeMaxDivisor = rqArr.Length;
            uint ix = 0;
            long t2 = (DateTime.Now.Ticks / Utils.TICKS_PER_MILLISECOND);
            int delay = 0;

            while (this.plotting || this.logging)
            {
                this.iProgressFeedback.tickProgress(ix);
                long t3 = DateTime.Now.Ticks / Utils.TICKS_PER_MILLISECOND;

                // Adjust the time interval between each poll to cover for lost time in processing.
                delay = this.pollInterval - (int)(t3 - t2 - delay);
                t2 = t3;

                // Make sure that we at least have a reasonable delay in case the load is too large.
                /*
                if (delay < 50)
                {
                    delay = 100;
                }
                 */

                if (delay < 0)
                {
                    delay = 0;
                }

                Thread.Sleep(delay);

                if (this.logging)
                {
                    this.iDataLog.performLog();
                }

                // Build the request for the selected data slot.
                // This means we consider the configured poll interval
                // for each item and spread them over time to
                // get an easy load on vehicle and system.
                IList<IRequestData> rqd = new List<IRequestData>();
                int ix1 = (int)(ix % nextBeforeMaxDivisor);

                foreach (IRequestData rd in rqArr[ix1])
                {
                    if (((ix - ix1) % rd.divisor) == 0)
                    {
                        rqd.Add(rd);
                    }
                }

                this.requestSelectedPids(rqd);
                ix++;
            }
        }

        /// <summary>
        /// Build the request data to use when communicating with the vehicle.
        /// </summary>
        /// <returns>Array of requests to loop through.</returns>
        private IList<IRequestData>[] buildRequestData()
        {
            SortedDictionary<int, IList<IRequestData>> intervalGroups = new SortedDictionary<int, IList<IRequestData>>();
            SortedDictionary<int, int> divisors = new SortedDictionary<int, int>();

            foreach (IRequestData rd in this.requests)
            {
#if TRACE
                this.iLogging.appendText("rd.divisor=" + rd.divisor + "\r\n");
#endif

                int divisor = rd.divisor;
                if (!divisors.ContainsKey(divisor))
                {
                    divisors.Add(divisor, divisor);
                }

                IList<IRequestData> partList;
                if (intervalGroups.ContainsKey(divisor))
                {
                    partList = intervalGroups[divisor];
                }
                else
                {
                    partList = new List<IRequestData>();
                    intervalGroups.Add(divisor, partList);
                }

                partList.Add(rd);
            }

            int nextBeforeMaxDivisor = 1;
            int maxDivisor = 1;
            foreach (KeyValuePair<int, int> kvp in divisors)
            {
                if (kvp.Key > maxDivisor)
                {
                    nextBeforeMaxDivisor = maxDivisor;
                    maxDivisor = kvp.Key;
                }
            }

            IList<IRequestData>[] rqArr = new IList<IRequestData>[nextBeforeMaxDivisor];
            for (int i = 0; i < nextBeforeMaxDivisor; i++)
            {
                rqArr[i] = new List<IRequestData>();
            }

            foreach (KeyValuePair<int, IList<IRequestData>> kvp in intervalGroups)
            {
                int n = 999; // Arbitrary large value.
                int i1 = 0; // Index of first list with lowest count.
                for (int i = 0; i < nextBeforeMaxDivisor; i++)
                {
                    if (n > rqArr[i].Count)
                    {
                        n = rqArr[i].Count;
                        i1 = i;
                    }
                }

                int sz = kvp.Key;
                IList<IRequestData> rql = kvp.Value;

                for (int i = 0; i < nextBeforeMaxDivisor; i++)
                {
                    if (((i - i1) % sz) == 0)
                    {
                        foreach (IRequestData rd in rql)
                        {
                            rqArr[i].Add(rd);
                        }
                    }
                }
            }

            return rqArr;
        }
    }
}