aswi2021tri-musketyri-gitlab/Server/ServerApp/Parser/Parsers/WeatherParser.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 weather files into instances of WeatherInfo divided by given time interval
    /// Data parsed from 7am (included) to 18pm (included)
    /// </summary>
    /// <author>Alex Konig</author>
    class WeatherParser
    {

        /// <summary> Datafile loader  </summary>
        DataLoader loader;

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

        /// <summary>
        /// Parses weather data to WeatherInfo instances
        /// Data parsed from 7am (included) to 18pm (included)
        /// </summary>
        /// <param name="folder">Folder with weather 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<WeatherInfo> ParseWeatherData(string folder, bool wholeDay = true, int interval = 1)
        {
            if (!Directory.Exists(folder))
                return null;

            List<WeatherInfo> list = new List<WeatherInfo>();

            // get all files in folder
            string[] fileEntries = Directory.GetFiles(folder);
            foreach (string fileName in fileEntries)
            {
                List<WeatherInfo> loadedData = null;
                
                // parse as one instance per day
                if (wholeDay)
                    loadedData = ProcessOneWeatherFileAsDays(fileName);
                // parse according to interval
                else
                {
                    loadedData = ProcessOneWeatherFileAsIntervals(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 WeatherInfo instances</returns>
        private List<WeatherInfo> ProcessOneWeatherFileAsDays(string path)
        {
            if (!File.Exists(path))
                return null;

            List<WeatherInfo> weatherInfo = new List<WeatherInfo>();
            List<WeatherInstance> list = loader.LoadWeatherFile(path);

            // array with data [temp, rain, wind, lum]
            double[] recordedAmount = new double[4];
            // 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].dateTime.Year, list[0].dateTime.Month, list[0].dateTime.Day, minmaxHour[0], 0, 0);
            // number of values in day
            int values = 0, weatherValues = 0;
            for (int i = 0; i < list.Count; i++)
            {
                int currHour = list[i].dateTime.Hour;
                if (currHour < minmaxHour[0] || currHour > minmaxHour[1])
                    continue;

                // start of new day -> make a new instance
                DateTime date = new DateTime(list[i].dateTime.Year, list[i].dateTime.Month, list[i].dateTime.Day, minmaxHour[0], 0, 0);
                if (!date.Equals(lastStartDay))
                {
                    WeatherInfo dayInfo = new WeatherInfo(lastStartDay, recordedAmount[0] / values, (int)(recordedAmount[1] / values * 100), recordedAmount[2] / values, recordedAmount[3] / weatherValues, range); 
                    weatherInfo.Add(dayInfo);

                    recordedAmount = new double[4];
                    lastStartDay = date;
                    values = 0;
                    weatherValues = 0;
                }

                // aggregate data
                recordedAmount[0] += list[i].temp;
                recordedAmount[1] += list[i].rain;
                recordedAmount[2] += list[i].wind;

                if (LuxToConditions.TransferLuxToConditions(list[i].lum * 1000) != WeatherConditions.Dark)
                    recordedAmount[3] += list[i].lum * 1000; weatherValues++;

                values++;
            }

            // data from last day
            WeatherInfo dayInfo2 = new WeatherInfo(lastStartDay, recordedAmount[0] / values, (int)(recordedAmount[1] / values * 100), recordedAmount[2] / values, recordedAmount[3] / values, range); 
            weatherInfo.Add(dayInfo2);

            return weatherInfo;
        }

        /// <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<WeatherInfo> ProcessOneWeatherFileAsIntervals(string path, int interval)
        {
            if (!File.Exists(path))
                return null;

            List<WeatherInfo> loignInfo = new List<WeatherInfo>();
            List<WeatherInstance> list = loader.LoadWeatherFile(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];
            double[][] data = new double[indices][];
            int[] count = new int[indices];
            for (int i = 0; i < to.Length; i++)
            {
                to[i] = minmaxHour[0] + interval * (i + 1);
                data[i] = new double[4];
            }

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

                // start of the day -> make an instance
                DateTime date = new DateTime(list[i].dateTime.Year, list[i].dateTime.Month, list[i].dateTime.Day, list[i].dateTime.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++)
                    {
                        int raincount = 0;
                        double rainval = 0;;
                        for (int l = 0; l <= k; l++)
                        {
                            raincount += count[l];
                            rainval += data[l][1];
                        }

                        DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, to[k] - interval, 0, 0);

                        WeatherInfo intervalInfo = new WeatherInfo(stTime, data[k][0] / count[k], (int)((rainval / raincount) * 100), data[k][2] / count[k], data[k][3] / count[k], interval);
                        if (count[k] != 0)
                            loignInfo.Add(intervalInfo);

                    }

                    lastStartTime = date;
                    count = new int[indices];
                    for (int l = 0; l < data.Length; l++)
                        data[l] = new double[4];
                }

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

                // aggregate data
                data[index][0] += list[i].temp;
                data[index][1] += list[i].rain;
                data[index][2] += list[i].wind;
                data[index][3] += list[i].lum * 1000;
                count[index]++;

            }

            for (int k = 0; k < to.Length; k++)
            {
                int raincount = 0;
                double rainval = 0; ;
                for (int l = 0; l <= k; l++)
                {
                    raincount += count[l];
                    rainval += data[l][1];
                }

                DateTime stTime = new DateTime(lastStartTime.Year, lastStartTime.Month, lastStartTime.Day, to[k] - interval, 0, 0);

                WeatherInfo intervalInfo = new WeatherInfo(stTime, data[k][0] / count[k], (int)((rainval / raincount) * 100), data[k][2] / count[k], data[k][3] / count[k], interval);
                if (count[k] != 0)
                    loignInfo.Add(intervalInfo);
            }

            return loignInfo;
        }
    }

}