aswi2021tri-musketyri-gitlab/Server/ServerApp/Parser/Parsers/JsonParser.cs @ 1407c8ba

using ServerApp.DataDownload;
using ServerApp.Parser.OutputInfo;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text.Json;
using static System.Text.Json.JsonElement;

namespace ServerApp.Parser.Parsers
{
    /// <summary>
    /// Class representing a parser for json prediction data
    /// </summary>
    /// <author>A. Konig</author>
    class JsonParser
    {
        /// <summary> Current weather </summary>
        public WeatherInfo current;
        /// <summary> Prediction for today, tommorrow and day after tommorrow </summary>
        public List<WeatherInfo> predictions;
        
        /// <summary> Data loader </summary>
        DataDownloader loader;
        /// <summary> Currently parsed day </summary>
        DateTime currParsedDay;
        /// <summary> Sunrise time of currently parsed day </summary>
        DateTime sunriseTime;
        /// <summary> Sunset time of currently parsed day </summary>
        DateTime sunsetTime;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="loader"></param>
        public JsonParser(DataDownloader loader)
        {
            this.loader = loader;
        }

        /// <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>
        public void ParsePrediction()
        {
            // TODO ask DataDownloader for download said file and return path to it
            
            // get file
            string file = DownloadWeatherPrediction();
            DateTime now = DateTime.Now;
            Console.WriteLine(File.Exists(file));

            // parse file
            string data = File.ReadAllText(file);

            JsonDocument doc = JsonDocument.Parse(data);
            JsonElement root = doc.RootElement;
            var weatherP = root.EnumerateObject();
            predictions = new List<WeatherInfo>();

            while (weatherP.MoveNext())
            {
                string name = weatherP.Current.Name;
                Console.WriteLine(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();

            TestConsoleOutput();
        }

        private void TestConsoleOutput()
        {
            Console.WriteLine(current);
            foreach (WeatherInfo w in predictions)
                Console.WriteLine(w);
        }

        // TODO move to data loader
        /// <summary>
        /// Downloads json file
        /// </summary>
        /// <returns> Path to file </returns>
        private string DownloadWeatherPrediction()
        {
            DateTime now = DateTime.Now;
            WebClient webClient = new WebClient();
            webClient.DownloadFile("http://wttr.in/Plzen,czechia?format=j1", $"data/{now.Year}{now.Month}{now.Day}.json");

            return $"data/{now.Year}{now.Month}{now.Day}.json";
        }

        /// <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()
        {
            // change current weather
            if ((current.startTime.TimeOfDay > sunsetTime.TimeOfDay) || (current.startTime.TimeOfDay < sunriseTime.TimeOfDay))
                current.condition = WeatherConditions.Dark;

            // change prediction
            for (int i = 0; i < predictions.Count - 1; i++)
            {
                // TODO what about when days change -> detect end / start of day and do differently ?

                WeatherInfo w = predictions[i];
                WeatherInfo wNext = predictions[i + 1];

                int timespan = wNext.startTime.Hour - w.startTime.Hour;
                w.intervalLength = timespan;

                // if start under sunset
                if (w.startTime.TimeOfDay > sunsetTime.TimeOfDay)
                    w.condition = WeatherConditions.Dark;

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

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

                // if start under sunrise
                TimeSpan endTime = new TimeSpan(w.startTime.TimeOfDay.Hours + timespan, w.startTime.TimeOfDay.Minutes, 0);
                if (endTime > sunsetTime.TimeOfDay)
                {
                    double howMuch = ((endTime.Hours * 60 + endTime.Minutes) - (sunsetTime.Hour * 60 + sunsetTime.Minute)) / 60.0;

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

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

            // if start under sunset
            if (wLast.startTime.TimeOfDay > sunsetTime.TimeOfDay)
                wLast.condition = WeatherConditions.Dark;

            // if start under sunrise
            if (wLast.startTime.TimeOfDay < sunriseTime.TimeOfDay)
            {
                double howMuch = ((sunriseTime.Hour * 60 + sunriseTime.Minute) - (wLast.startTime.Hour * 60 + wLast.startTime.Minute)) / 60.0;

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

            // if start under sunrise
            if (endTimeW > sunsetTime.TimeOfDay)
            {
                double howMuch = ((endTimeW.Hours * 60 + endTimeW.Minutes) - (sunsetTime.Hour * 60 + sunsetTime.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.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out sunriseTime);
                                Console.WriteLine("\t sunrise time : " + sunriseTime + " " + astrInfo.Current.Value.GetString());
                                break;
                            }
                        case "sunset":
                            {
                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out sunsetTime);
                                Console.WriteLine("\t sunset time : " + sunsetTime + " " + astrInfo.Current.Value.GetString());
                                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);
                                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 "WindGustKmph":
                            {
                                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;
                            }
                    }
                }

                // Console.WriteLine(weather.ToString());
                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.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;
                            }
                    }
                }

            }

            return res;
        }

    }
}