aswi2021tri-musketyri-gitlab/Server/ServerApp/WeatherPredictionParser/JsonParser.cs @ 60a60164

//
// Author: A. Konig
//

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.WeatherPredictionParser
{
    /// <summary>
    /// Class representing a parser for json prediction data
    /// </summary>
    /// <author>A. Konig</author>
    class JsonParser : IJsonParser
    {
        /// <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>
        /// Get predictions from Predictions that are within specified time span
        /// From-to including
        /// If from == null then all until to
        /// If to  == null 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 == null)
                from = Predictions[0].startTime;

            if (to == null)
                from = Predictions[Predictions.Count].startTime;

            if (from > to)
                return null;

            foreach (WeatherInfo pred in Predictions)
            {
                int hour = pred.startTime.Hour + pred.intervalLength;
                Console.WriteLine(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()
        {
            // 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));

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

            if (!File.Exists(file))
                return;

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

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

            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();
        }

        /// <summary>
        /// Test console output
        /// </summary>
        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++)
            {
                WeatherInfo w = Predictions[i];
                WeatherInfo wNext = Predictions[i + 1];

                // 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;
                if (wNext.startTime.Hour < w.startTime.Hour)
                    timespan = (wNext.startTime.Hour+24) - 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 = 24 - 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;
        }

      
    }
}