aswi2021tri-musketyri-gitlab/Server/ServerApp/Parser/Parsers/LogInParser.cs @ 4a417b8b

using ServerApp.Parser.InputData;
using ServerApp.Parser.OutputInfo;
using System;
using System.Collections.Generic;
using System.IO;

namespace ServerApp.Parser.Parsers
{
    /// <summary>
    /// Class parsing login files into instances of ActivityInfo divided by given time interval
    /// Data parsed from 7am (included) to 18pm (included)
    /// </summary>
    /// <author>Alex Konig</author>
    class LogInParser
    {
        /// <summary> Datafile loader  </summary>
        DataLoader loader;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="loader">Datafile loader</param>
        public LogInParser(DataLoader loader)
        {
            this.loader = loader;
        }

        /// <summary>
        /// Parses login data to ActivityInfo instances
        /// Data parsed from 7am (included) to 18pm (included)
        /// </summary>
        /// <param name="folder">Folder with login data files</param>
        /// <param name="wholeDay">Should data be parsed as one instance per day (if true parameter interval will be ignored)</param>
        /// <param name="interval">Time interval to divide days by, minimum is 1h</param>
        /// <returns></returns>
        public List<ActivityInfo> ParseLogInData(string folder, bool wholeDay = true, int interval = 1)
        {
            if (!Directory.Exists(folder))
                return null;
            
            List<ActivityInfo> list = new List<ActivityInfo>();

            // get all files in folder
            string[] fileEntries = Directory.GetFiles(folder);
            foreach (string fileName in fileEntries)
            {
                List<ActivityInfo> loadedData = null;
                
                // parse as one instance per day
                if (wholeDay)
                    loadedData = ProcessOneLogInFileAsDays(fileName);
                // parse by interval length
                else
                    loadedData = ProcessOneLoginFileAsIntervals(fileName, interval);

                list.AddRange(loadedData);
            }

            return list;
        }

        /// <summary>
        /// Parses data from one data file as one instance per day
        /// </summary>
        /// <param name="path">Path ti file</param>
        /// <returns>List with ActivityInfo instances</returns>
        private List<ActivityInfo> ProcessOneLogInFileAsDays(string path)
        {
            if (!File.Exists(path))
                return null;

            List<ActivityInfo> loginInfo = new List<ActivityInfo>();
            List<LogInInstance> list = loader.LoadLoginFile(path);

            // data for each faculty
            int[] recordedAmount = new int[TagInfo.faculties.Length];
            // min/max hour taken into account
            int[] minmaxHour = new int[] { 7, 18 };
            // interval length
            int range = minmaxHour[1] - minmaxHour[0];

            // first day
            DateTime lastStartDay = new DateTime(list[0].date.Year, list[0].date.Month, list[0].date.Day, minmaxHour[0], 0, 0);
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].lessonStart.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of the day -> make an instance
                string place = list[i].building;
                DateTime date = new DateTime(list[i].date.Year, list[i].date.Month, list[i].date.Day, minmaxHour[0], 0, 0);
                if (!date.Equals(lastStartDay))
                {
                    // data for each faculty separate
                    for (int k = 0; k < TagInfo.faculties.Length; k++)
                    {
                        ActivityInfo dayInfo = new ActivityInfo(TagInfo.faculties[k], recordedAmount[k], lastStartDay, range); 
                        loginInfo.Add(dayInfo);
                    }

                    recordedAmount = new int[TagInfo.faculties.Length];
                    lastStartDay = date;
                }

                // aggregate data
                if (TagInfo.buildingTags.ContainsKey(place))
                {
                    int index = TagInfo.buildingTags[place];
                    // to all
                    if (index == -1)
                        for (int l = 0; l < TagInfo.faculties.Length; l++)
                            recordedAmount[l] += list[i].amount;
                    // to first two
                    else if (index == -2)
                    {
                        recordedAmount[0] += list[i].amount;
                        recordedAmount[1] += list[i].amount;
                    }
                    else
                        recordedAmount[index] += list[i].amount;

                }
                else
                {
                    // TODO uknown code handling
                    Console.WriteLine("Unknown code " + list[i].building);
                }

            }

            // last day
            for (int k = 0; k < TagInfo.faculties.Length; k++)
            {
                ActivityInfo dayInfo = new ActivityInfo(TagInfo.faculties[k], recordedAmount[k], lastStartDay, range);
                loginInfo.Add(dayInfo);
            }

            return loginInfo;
        }

        /// <summary>
        /// Parses data from one data file as one instance per interval length
        /// </summary>
        /// <param name="path">Path to file</param>
        /// <param name="interval">Interval length</param>
        /// <returns>List with ActivityInfo instances</returns>
        private List<ActivityInfo> ProcessOneLoginFileAsIntervals(string path, int interval)
        {
            if (!File.Exists(path))
                return null;

            List<ActivityInfo> loignInfo = new List<ActivityInfo>();
            List<LogInInstance> list = loader.LoadLoginFile(path);

            // min/max hour taken into account
            int[] minmaxHour = new int[] { 7, 18 };
            int range = minmaxHour[1] - minmaxHour[0];

            if (interval > range)
                return null;

            int indices = (int)Math.Ceiling(range / (double)interval);
            int[] to = new int[indices];
            int[][] data = new int[indices][];
            for (int i = 0; i < to.Length; i++)
            {
                to[i] = minmaxHour[0] + interval * (i + 1);
                data[i] = new int[TagInfo.faculties.Length];
            }
            
            // first day
            DateTime lastStartTime = new DateTime(list[0].date.Year, list[0].date.Month, list[0].date.Day, minmaxHour[0], 0, 0);
            int index = 0;
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].lessonStart.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of the day -> make an instance
                string place = list[i].building;
                DateTime date = new DateTime(list[i].date.Year, list[i].date.Month, list[i].date.Day, list[i].lessonStart.Hour, 0, 0);

                // end of the day
                if (!(date.Year == lastStartTime.Year && date.Month == lastStartTime.Month && date.Day == lastStartTime.Day))
                {
                    // note down all aggregated data
                    for (int k = 0; k < to.Length; k++)
                    {
                        DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, to[k] - interval, 0, 0);

                        // data for each faculty separate
                        for (int l = 0; l < TagInfo.faculties.Length; l++)
                        {
                            ActivityInfo dayInfo = new ActivityInfo(TagInfo.faculties[l], data[k][l], stTime, interval);
                            loignInfo.Add(dayInfo);
                        }

                        data[k] = new int[TagInfo.faculties.Length];
                    }
                    lastStartTime = date;
                }

                // find index for current instance
                index = 0;
                for (int k = 1; k < to.Length; k++)
                {
                    if (to[k] > list[i].lessonStart.Hour && to[k - 1] <= list[i].lessonStart.Hour)
                    {
                        index = k;
                        break;
                    }
                }

                // aggregate data
                if (TagInfo.buildingTags.ContainsKey(place))
                {
                    int faculty = TagInfo.buildingTags[place];
                    // to all
                    if (faculty == -1)
                        for (int l = 0; l < TagInfo.faculties.Length; l++)
                            data[index][l] += list[i].amount;
                    // to first two
                    else if (faculty == -2)
                    {
                        data[index][0] += list[i].amount;
                        data[index][1] += list[i].amount;
                    }
                    else
                        data[index][faculty] += list[i].amount;

                }
                else
                {
                    // TODO uknown code handling
                    Console.WriteLine("Unknown code " + list[i].building);
                }

            }

            for (int k = 0; k < to.Length; k++)
            {
                DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, to[k] - interval, 0, 0);

                // data for each faculty separate
                for (int l = 0; l < TagInfo.faculties.Length; l++)
                {
                    ActivityInfo dayInfo = new ActivityInfo(TagInfo.faculties[l], data[k][l], stTime, interval);
                    loignInfo.Add(dayInfo);
                }
            }

            return loignInfo;
        }

    }
}