aswi2021tri-musketyri-gitlab/Server/ServerApp/Program.cs @ 127a92b1

using log4net;
using log4net.Config;
using ServerApp.Connection;
using ServerApp.Connection.XMLProtocolHandler;
using ServerApp.DataDownload;
using ServerApp.Parser.InputData;
using ServerApp.Parser.OutputInfo;
using ServerApp.Parser.Parsers;
using ServerApp.Predictor;
using ServerApp.User;
using ServerApp.WeatherPredictionParser;
using System;
using System.Collections.Generic;
using System.IO;
using System.Threading;

namespace ServerApp
{

	class Config
	{
		public string DataWebsite { get; set; }
		public string DownloadedFilesNaming { get; set; }
		public string DataRootDir { get; set; }
		public string WeatherSite { get; set; }
		public string Port { get; set; } 
	}

    public class Program
    {
		// logger class instance
		private static readonly ILog logger = LogManager.GetLogger(typeof(Program));

		static void Main(string[] args)
        {
			Console.WriteLine("Server start.");

            // setup logging service
            XmlConfigurator.Configure();

			// SETUP FOLDERS
			Config config = FillConfigInfo(args);
			if (config == null)
			{
				Console.WriteLine("Configuration file parsing failed. Abort.");
				Console.ReadLine();
				return;
			}
			Console.WriteLine("Config parsing successful.");


			// data download init
			Console.WriteLine("Downloading open data...");
			DataDownloader dd = DataDownloaderInit(config);
			Console.WriteLine("Data downloaded and saved.");


			// model init
			Console.WriteLine("Training the predictor...");
			IPredictionController controller = PredictionControllerInit(dd);
			Console.WriteLine("Predictor training finished.");


			// commands accepting
			// create a thread for commands accepting:
			CommandsAcceptor ca = new CommandsAcceptor(dd, controller);
			Thread inputThread = new Thread(ca.AcceptCommand);
			inputThread.Start();


			// connection init
			ConnectionInit(controller, config);

        }

		/// <summary>
		/// Initializes DataDownloader. Downloads default span of data and saves the files.
		/// </summary>
		/// <param name="config">The Config instance</param>
		/// <returns>New instance of DataDownloader</returns>
		private static DataDownloader DataDownloaderInit(Config config)
		{
			
			DataDownloader dd = new DataDownloader(config.DataRootDir, config.DataWebsite, config.DownloadedFilesNaming, config.WeatherSite);
			dd.OverwriteExisting = false;
			List<string> savedFiles = new List<string>();

			// -> 12-2019 to exclude corona period which could mess with the predictor
			savedFiles.AddRange(dd.DownloadData(DataType.JIS, DataFormat.CSV, new DataDownload.Date(1, 2017), new DataDownload.Date(12, 2019)));
			savedFiles.AddRange(dd.DownloadData(DataType.STROJE, DataFormat.CSV, new DataDownload.Date(1, 2017), new DataDownload.Date(12, 2019)));
			savedFiles.AddRange(dd.DownloadData(DataType.POCASI, DataFormat.CSV, new DataDownload.Date(1, 2017), new DataDownload.Date(12, 2019)));



			//Console.WriteLine("Saved files: ");
			//foreach (string s in savedFiles)
			//{
			//	Console.WriteLine(s);
			//}

			//Console.WriteLine("subdirectories: ");
			//foreach (KeyValuePair<DataType, string> kvp in dd.DataSubDirectories)
			//{
			//	Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
			//}

			//List<string> retrievedData = dd.GetData(dd.DataSubDirectories[DataType.JIS], new DataDownload.Date(10, 2019), new DataDownload.Date(12, 2020));
			//Console.WriteLine("Retrieved data: ");
			//foreach (string s in retrievedData)
			//{
			//	Console.WriteLine(s);
			//}
			//Console.WriteLine("all from directory:");
			//retrievedData = dd.GetData(dd.DataSubDirectories[DataType.JIS], null, null);
			//foreach (string s in retrievedData)
			//{
			//	Console.WriteLine(s);
			//}


			return dd;
		}


		private static void JSONParserTest()
		{
            // FIXME pass the right references to the JsonParser constructor
			JsonParser jsonP = new JsonParser(null, null);
			jsonP.ParsePrediction();

			var res = jsonP.GetPredictionForTime(jsonP.Predictions[5].startTime, jsonP.Predictions[20].startTime);
			Console.WriteLine("from " + jsonP.Predictions[5].startTime);
			Console.WriteLine("end " + jsonP.Predictions[20].startTime);
			foreach (WeatherInfo w in res)
				Console.WriteLine(w.ToString());
		}

		private static void WeatherAsStringTest(DataDownloader dd)
		{
			Console.WriteLine(dd.DownloadWeatherPrediction());
		}

		/// <summary>
		/// Initializes and trains the predictor if need be.
		/// </summary>
		/// <param name="dd">The DataDownloader instance.</param>
		/// <returns>New instance of the predictor.</returns>
		private static IPredictionController PredictionControllerInit(DataDownloader dd)
		{
			IDataParser p = new DataParser(dd);
            // FIXME pass the right references to the JsonParser constructor
            IJsonParser jsonP = new JsonParser(dd, new CsvDataLoader());
            IPredictionController predictionController = new PredictionController(jsonP, p);
            //var results = predictionController.Predict()
			

			return predictionController;
		}

		/// <summary>
		/// Initializes waiting for the clients' requests.
		/// </summary>
		/// <param name="predictionController">The initialized and trained instance of the predictor.</param>
		/// <param name="config">The Config class instance.</param>
		private static void ConnectionInit(IPredictionController predictionController, Config config)
		{
			ConnectionListenerAsync cl = new ConnectionListenerAsync(int.Parse(config.Port), predictionController);
			cl.StartListening();

		}

		/// <summary>
		/// Parses the configuration file and extracts valuable information from it.
		/// </summary>
		/// <param name="args">The arguments passed to the program.</param>
		/// <returns>Filled instance of the Config class, null if there was a problem.</returns>
		private static Config FillConfigInfo(string[] args)
		{

			Config extractedConfigInfo = new Config();

			Console.WriteLine("Parsing configuration file...");
			
			if (args.Length != 1)
				Console.WriteLine("Wrong usage of parameters, pass only the path to a config file.");

			string fullPathConfig = Path.GetFullPath(args[0]);
			string[] lines = null;
			try {
				lines = File.ReadAllLines(fullPathConfig);
			}
			catch(Exception ex)
			{
				Console.WriteLine("Could not open " + fullPathConfig);
				Console.WriteLine(ex.Message);
				return null;
			}
			
			for (var i = 0; i < lines.Length; i += 1)
			{
				string line = lines[i];
				//Console.WriteLine(line);
				if (line.Length == 0 || line == null || line.StartsWith("#"))
					continue;

				switch (line)
				{
					case "!site!":
						extractedConfigInfo.DataWebsite = lines[++i].Trim();
						break;
					case "!naming_convention!":
						extractedConfigInfo.DownloadedFilesNaming = lines[++i].Trim();
						break;
					case "!data_root_dir!":
						//string rootDir = lines[++i];
						//rootDir = rootDir.Replace('\\', Path.DirectorySeparatorChar);
						string dirWithConfig = Path.GetDirectoryName(fullPathConfig);
						string rootPath = dirWithConfig + Path.DirectorySeparatorChar + lines[++i].Trim();
						rootPath = Path.GetFullPath(rootPath);
						extractedConfigInfo.DataRootDir = rootPath;
						break;
					case "!weather_site!":
						extractedConfigInfo.WeatherSite = lines[++i].Trim();
						break;
					case "!port!":
						extractedConfigInfo.Port = lines[++i].Trim();
						break;
					default: break;
				}
			}

			int parsedPort;

			bool success = int.TryParse(extractedConfigInfo.Port, out parsedPort);
			if (!success)
			{
				Console.WriteLine("Configured port " + extractedConfigInfo.Port + " is not an integer! Abort.");
				return null;
			}
				

			return extractedConfigInfo;
		}
    }
}