aswi2021tri-musketyri-gitlab/Server/ServerApp/WeatherPredictionParser/JsonParser.cs @ 08c521ba

//
// Author: A. Konig
//

using log4net;
using ServerApp.DataDownload;
using ServerApp.Parser.InputData;
using ServerApp.Parser.OutputInfo;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Text.Json;
using static System.Text.Json.JsonElement;

namespace ServerApp.WeatherPredictionParser
{
    /// <summary>
    /// Class representing a parser for json prediction data
    /// </summary>
    /// <author>A. Konig</author>
    public class JsonParser : IJsonParser
    {
        /// <summary> Logger </summary>
        private static readonly ILog _log = LogManager.GetLogger(typeof(JsonParser));

        /// <summary> Data downloader </summary>
        IDataDownloader downloader;
        /// <summary> Data loader </summary>
        IDataLoader loader;
        /// <summary> Currently parsed day </summary>
        DateTime currParsedDay;
        /// <summary> Sunrise time of currently parsed day </summary>
        List<DateTime> sunriseTime;
        /// <summary> Sunset time of currently parsed day </summary>
        List<DateTime> sunsetTime;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="downloader"></param>
        public JsonParser(IDataDownloader downloader, IDataLoader loader)
        {
            this.downloader = downloader;
            this.loader = loader;
        }

        /// <summary>
        /// Get predictions from Predictions that are within specified time span
        /// From-to including
        /// If from == DateTime.Min then all until to
        /// If to  == DateTime.Max then all starting from from
        /// </summary>
        /// <param name="from">DateTime from</param>
        /// <param name="to">DateTime to</param>
        /// <returns>List of predictions that fit specified criteria or null if incorrect input</returns>
        public override List<WeatherInfo> GetPredictionForTime(DateTime from, DateTime to)
        {
            if (Predictions == null)
                return null;

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

            if (from == DateTime.MinValue)
                from = Predictions[0].startTime;

            if (to == DateTime.MaxValue) {
                DateTime dt = Predictions[Predictions.Count - 1].startTime;
                int hour = dt.Hour + Predictions[Predictions.Count - 1].intervalLength;
                bool addDay = false;
                if (hour >= 24)
                {
                    hour -= 24;
                    addDay = true;
                }
                to = new DateTime(dt.Year, dt.Month, dt.Day, hour, dt.Minute, dt.Second);
                if (addDay)
                    to = to.AddDays(1);
            }

            if (from > to)
                return null;

            // for all parsed weather info
            foreach (WeatherInfo pred in Predictions)
            {
                int hour = pred.startTime.Hour + pred.intervalLength;
                bool addDay = false;
                if (hour >= 24)
                {
                    hour -= 24;
                    addDay = true;
                }
                DateTime endTime = new DateTime(pred.startTime.Year, pred.startTime.Month, pred.startTime.Day, hour, pred.startTime.Minute, pred.startTime.Second);
                if (addDay)
                    endTime = endTime.AddDays(1);

                // if both end and start not outside of interval
                if (!((pred.startTime < from && endTime <= from) || (pred.startTime > to && endTime > to)))
                    res.Add(pred);
            }

            return res;
        }


        /// <summary>
        /// Parse weather prediction
        /// Results is in attributes current for current weather and pred for weather prediction for today, tommorrow and day after tommorrow
        /// </summary>
        override public void ParsePrediction()
        {
            sunriseTime = new List<DateTime>();
            sunsetTime = new List<DateTime>();

            // get file
            //string file = downloader.DownloadWeatherPrediction();
            //string data = loader.LoadPredictionFile(file);

            // get data
            string data = downloader.DownloadWeatherPrediction();

            DateTime now = DateTime.Now;

            Current = new WeatherInfo();
            Predictions = new List<WeatherInfo>();

            if (data == null || data.Length == 0)
                return;

            // parse
            try
            {
                JsonDocument doc = JsonDocument.Parse(data);
                JsonElement root = doc.RootElement;
                var weatherP = root.EnumerateObject();

                while (weatherP.MoveNext())
                {
                    string name = weatherP.Current.Name;

                    switch (name)
                    {
                        // current weather
                        case "current_condition":
                            {
                                ArrayEnumerator currentWeather = weatherP.Current.Value.EnumerateArray();
                                Current = ParseCurrentWeather(currentWeather);

                                break;
                            }
                        // weather prediction
                        case "weather":
                            {
                                ArrayEnumerator weather = weatherP.Current.Value.EnumerateArray();
                                ParseWeatherPredict(weather);

                                break;
                            }
                    }
                }

                // sunrise + sunset into data
                EncompassSunRiseSetTimes();
            } catch
            {
                _log.Error("Weather prediction file in incorrect format");
                Current = new WeatherInfo();
                Predictions = new List<WeatherInfo>();
            }

            //TestConsoleOutput();
        }

        /// <summary>
        /// Test console output
        /// </summary>
        private void TestConsoleOutput()
        {
            Console.WriteLine(Current);
            foreach (WeatherInfo w in Predictions)
                Console.WriteLine(w);
        }

        /// <summary>
        /// Change data in a way that they now reflect sunrise and sunset times
        /// If current time under sunrise or over sunset -> WeatherConditions is Dark
        /// If prediction time is under sunrise or over sunset and more than half of the interval is under/over said time -> WeatherCondition is Dark
        /// </summary>
        private void EncompassSunRiseSetTimes()
        {
            if (sunsetTime.Count < 1 || sunriseTime.Count < 0)
                return;

            // change current weather
            if ((Current.startTime.TimeOfDay > sunsetTime[0].TimeOfDay) || (Current.startTime.TimeOfDay < sunriseTime[0].TimeOfDay))
                Current.condition = WeatherConditions.Dark;

            // change prediction
            int index = 0;
            for (int i = 0; i < Predictions.Count - 1; i++)
            {
                WeatherInfo w = Predictions[i];
                WeatherInfo wNext = Predictions[i + 1];
                DateTime sunrise = sunriseTime[index];
                DateTime sunset = sunsetTime[index];


                // if wNext time < than w time then it is prediction from the next day -> add 24 to correctly calculate timespan
                int timespan = wNext.startTime.Hour - w.startTime.Hour;
                bool intoTwo = false;
                if (wNext.startTime.Hour < w.startTime.Hour)
                {
                    intoTwo = true;
                    timespan = (wNext.startTime.Hour + 24) - w.startTime.Hour;
                }
                
                w.intervalLength = timespan;
                TimeSpan endTime = new TimeSpan(w.startTime.TimeOfDay.Hours + timespan, w.startTime.TimeOfDay.Minutes, 0);

                // if start under sunset
                if (w.startTime.TimeOfDay > sunsetTime[index].TimeOfDay)
                {
                    // when is end - if end after next sunrise need to compute the extent of dark
                    if (intoTwo && endTime > sunriseTime[index+1].TimeOfDay)
                    {
                        double howMuch = ((endTime.Hours * 60 + endTime.Minutes) - (sunriseTime[index + 1].Hour * 60 + sunriseTime[index + 1].Minute)) / 60.0;
                        howMuch = w.intervalLength - howMuch;

                        if (howMuch >= timespan / 2.0)
                            w.condition = WeatherConditions.Dark;
                    }
                    else
                        w.condition = WeatherConditions.Dark;
                }

                // if start under sunrise
                if (w.startTime.TimeOfDay < sunriseTime[index].TimeOfDay)
                {
                    double howMuch = ((sunriseTime[index].Hour * 60 + sunriseTime[index].Minute) - (w.startTime.Hour * 60 + w.startTime.Minute)) / 60.0;
                    if (endTime > sunset.TimeOfDay)
                        howMuch += ((w.startTime.Hour * 60 + w.startTime.Minute) - (sunset.Hour * 60 + sunset.Minute)) / 60.0;

                    if (howMuch >= timespan / 2.0)
                        w.condition = WeatherConditions.Dark;
                }

                // if end over sunset
                else if (endTime > sunsetTime[index].TimeOfDay)
                {
                    double howMuch = ((endTime.Hours * 60 + endTime.Minutes) - (sunsetTime[index].Hour * 60 + sunsetTime[index].Minute)) / 60.0;

                    if (howMuch >= timespan / 2.0)
                        w.condition = WeatherConditions.Dark;
                }

                if (Predictions[i].startTime.Date !=  Predictions[i + 1].startTime.Date)
                    index++;
            }

            // last prediction
            WeatherInfo wLast = Predictions[Predictions.Count - 1];
            TimeSpan endTimeW = new TimeSpan(23, 59, 59);
            int timespanLast = 24 - wLast.startTime.Hour;
            wLast.intervalLength = timespanLast;

            // if start under sunset
            if (wLast.startTime.TimeOfDay > sunsetTime[sunsetTime.Count-1].TimeOfDay)
                wLast.condition = WeatherConditions.Dark;

            // if start under sunrise
            if (wLast.startTime.TimeOfDay < sunriseTime[sunriseTime.Count - 1].TimeOfDay)
            {
                double howMuch = ((sunriseTime[sunriseTime.Count - 1].Hour * 60 + sunriseTime[sunriseTime.Count - 1].Minute) - (wLast.startTime.Hour * 60 + wLast.startTime.Minute)) / 60.0;
                if (endTimeW > sunsetTime[sunriseTime.Count - 1].TimeOfDay)
                    howMuch += ((wLast.startTime.Hour * 60 + wLast.startTime.Minute) - (sunsetTime[sunriseTime.Count - 1].Hour * 60 + sunsetTime[sunriseTime.Count - 1].Minute)) / 60.0;

                if (howMuch >= timespanLast / 2.0)
                    wLast.condition = WeatherConditions.Dark;
            }

            // if start under sunrise
            if (endTimeW > sunsetTime[sunsetTime.Count - 1].TimeOfDay)
            {
                double howMuch = ((endTimeW.Hours * 60 + endTimeW.Minutes) - (sunsetTime[sunsetTime.Count - 1].Hour * 60 + sunsetTime[sunsetTime.Count - 1].Minute)) / 60.0;

                if (howMuch >= timespanLast / 2.0)
                    wLast.condition = WeatherConditions.Dark;
            }
        }

        /// <summary>
        /// Parse weather prediction
        /// </summary>
        /// <param name="weather"> ArrayEnumerator of weather predictions </param>
        private void ParseWeatherPredict(ArrayEnumerator weather)
        {
            while (weather.MoveNext())
            {
                // prediction for one day
                var obj = weather.Current.EnumerateObject();

                while (obj.MoveNext())
                {
                    switch (obj.Current.Name)
                    {
                        case "date":
                            {
                                DateTime.TryParseExact(obj.Current.Value.GetString(), "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out currParsedDay);
                                break;
                            }
                        // hourly predictions
                        case "hourly":
                            {
                                ParseHourly(obj.Current.Value.EnumerateArray());
                                break;
                            }
                        // sunset / sunrise hours
                        case "astronomy":
                            {
                                ParseAstronomy(obj.Current.Value.EnumerateArray());
                                break;
                            }
                    }
                }
            }
        }

        /// <summary>
        /// Parse sunrise and sunset times
        /// </summary>
        /// <param name="astronomy"> Astronomy array enumerator </param>
        private void ParseAstronomy(ArrayEnumerator astronomy)
        {
            while (astronomy.MoveNext())
            {
                var astrInfo = astronomy.Current.EnumerateObject();
                
                while (astrInfo.MoveNext())
                {
                    switch (astrInfo.Current.Name)
                    {
                        case "sunrise":
                            {
                                DateTime newSunrise = new DateTime();
                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out newSunrise);
                                sunriseTime.Add(newSunrise);
                                break;
                            }
                        case "sunset":
                            {
                                DateTime newSunset = new DateTime();
                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out newSunset);
                                sunsetTime.Add(newSunset);
                                break;
                            }
                    }
                }
            }
        }

        /// <summary>
        /// Parse hourly predictions
        /// </summary>
        /// <param name="hourly">Enumerated array of hourly predictions</param>
        private void ParseHourly(ArrayEnumerator hourly)
        {
            while (hourly.MoveNext())
            {
                // one hourly prediction
                var oneH = hourly.Current.EnumerateObject();
                WeatherInfo weather = new WeatherInfo();

                while (oneH.MoveNext())
                {
                    switch (oneH.Current.Name)
                    {
                        case "FeelsLikeC":
                            {
                                Double.TryParse(oneH.Current.Value.GetString(), out weather.temp);
                                break;
                            }
                        case "cloudcover":
                            {
                                int cloudCover;
                                Int32.TryParse(oneH.Current.Value.GetString(), out cloudCover);
                                weather.condition = ValueToConditions.CloudCoverToConditions(cloudCover);
                                weather.lum = ValueToConditions.TransferConditionsToLux(weather.condition);
                                break;
                            }
                        // take into account highest value from "chanceofrain" and "chaceofsnow"
                        case "chanceofrain":
                            {
                                int rain;
                                Int32.TryParse(oneH.Current.Value.GetString(), out rain);
                                weather.rain = rain > weather.rain ? rain : weather.rain;
                                break;
                            }
                        case "chanceofsnow":
                            {
                                int snow;
                                Int32.TryParse(oneH.Current.Value.GetString(), out snow);
                                weather.rain = snow > weather.rain ? snow : weather.rain;
                                break;
                            }
                        // wind kmph has to be translated to mps
                        case "windspeedKmph":
                            {
                                double windkmh;
                                Double.TryParse(oneH.Current.Value.GetString(), out windkmh);
                                weather.wind= windkmh * 1000 / (60.0*60.0);
                                break;
                            }
                        case "time":
                            {
                                int h;
                                Int32.TryParse(oneH.Current.Value.GetString(), out h);
                                h /= 100;
                                DateTime time = new DateTime(currParsedDay.Year, currParsedDay.Month, currParsedDay.Day, h, 0, 0);
                                weather.startTime = time;
                                break;
                            }
                    }
                }

                Predictions.Add(weather);
            }

        }

        /// <summary>
        /// Parse current weather
        /// </summary>
        /// <param name="currentWeather">Enumerated hour of weather data</param>
        /// <returns>WeatherInfo with current weather</returns>
        private WeatherInfo ParseCurrentWeather(ArrayEnumerator currentWeather)
        {
            WeatherInfo res = new WeatherInfo();
            res.intervalLength = 0;
            //res.current = true;

            while (currentWeather.MoveNext())
            {
                var obj = currentWeather.Current.EnumerateObject();

                while (obj.MoveNext())
                {
                    switch (obj.Current.Name)
                    {
                        case "localObsDateTime":
                            {
                                DateTime.TryParse(obj.Current.Value.GetString(), out res.startTime);
                                break;
                            }
                        case "FeelsLikeC":
                            {
                                Double.TryParse(obj.Current.Value.GetString(), out res.temp);
                                break;
                            }
                        case "cloudcover":
                            {
                                int cloudCover;
                                Int32.TryParse(obj.Current.Value.GetString(), out cloudCover);
                                res.condition = ValueToConditions.CloudCoverToConditions(cloudCover);
                                break;
                            }
                        case "precipMM":
                            {
                                double rainMM;
                                Double.TryParse(obj.Current.Value.GetString(), out rainMM);
                                res.rain = rainMM > 0 ? 100 : 0;
                                break;
                            }
                        case "windspeedKmph":
                            {
                                double wind;
                                Double.TryParse(obj.Current.Value.GetString(), out wind);
                                res.wind = wind * 1000 / (60.0 * 60.0);
                                break;
                            }
                    }
                }

            }

            res.lum = ValueToConditions.TransferConditionsToLux(res.condition);
            return res;
        }

      
    }
}