Program.cs

using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Primitives;
using MongoDB.Driver;
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml;
using System.Linq;

namespace CompetitiveRatingsUpdater
{
    class Program
    {
        private static MongoClientSettings settings = new MongoClientSettings();
        private const string MongoConnectionString = "databasestringconnect";
        private const string DatabaseName = "haha";
        private const string CollectionName = "xd";
        private const string XmlFileName = "RankData.xml";
        private static XmlDocument XmlFile = new XmlDocument();
        private static MongoClient client = new MongoClient();
        private static IMongoDatabase database;
        private static IMongoCollection<BsonDocument> _playerCollection;
        private static PhysicalFileProvider provider;
        private static IChangeToken changeToken;

        static void Main(string[] args)
        {
            provider = new PhysicalFileProvider(AppDomain.CurrentDomain.BaseDirectory)
            {
                UsePollingFileWatcher = true,
                UseActivePolling = true
            };

            //Connect with mongo
            MongoSetup();

            if (File.Exists(Directory.GetCurrentDirectory() + $@"/{XmlFileName}"))
            {
                //Load the thing dumbass!!!!
                XmlFile.Load(Directory.GetCurrentDirectory() + $@"/{XmlFileName}");

                //Make sure the XML is synced with the database!
                SyncXMLToDatabase();

                //Attempt to add new players into the thing or update information as needed
                InsertPlayers();

                //Watch that file!!!! Watch it!!!
                StartWatchingFile();

                while (true)
                {
                    System.Threading.Thread.Sleep(100);
                }
                
            }
            else
            {
                Console.WriteLine($"{XmlFileName} does not exist!");
                Console.WriteLine("Attempting to make a new one...");

                XmlNode root = XmlFile.CreateElement("RankData");
                XmlNode player = XmlFile.CreateElement("Player");
                XmlFile.AppendChild(root);
                root.AppendChild(player);
                XmlFile.Save(Directory.GetCurrentDirectory() + $@"/{XmlFileName}");

                Console.WriteLine("File created!");
                Console.WriteLine("Attempting to add Player Rank Data to the XML from the database...");

                ExtractPlayers();
                Console.WriteLine();

                //WATCH FILE NOW!!! NOW!!!!!!!!!
                StartWatchingFile();

                while (true)
                {
                    System.Threading.Thread.Sleep(100);
                }
            }
        }

        private static void MongoSetup()
        {
            Console.WriteLine("Attempting to connect to MongoDB");
            settings = MongoClientSettings.FromConnectionString(MongoConnectionString);
            client = new MongoClient(settings);
            database = client.GetDatabase(DatabaseName);
            _playerCollection = database.GetCollection<BsonDocument>(CollectionName);
            Console.WriteLine("Connection established!");
        }

        public static void InsertPlayers()
        {
            Console.WriteLine("Generating Player Data....");
            List<PlayerObject> playerDocuments = GenerateDocuments();
            Console.WriteLine();


            if (playerDocuments.Count == 0)
            {
                Console.WriteLine("There's no player data in here lmao");
                //This should only occur when the RankData.xml is created by the Server rather than the database handler
                ExtractPlayers();
                return;
            }

            List<BsonDocument> bsonDocuments = new List<BsonDocument>();

            Console.WriteLine("Comparing Player Data with Mongo Database");
            foreach (PlayerObject player in playerDocuments)
            {
                FilterDefinitionBuilder<BsonDocument> builder = Builders<BsonDocument>.Filter;
                FilterDefinition<BsonDocument> filter = builder.And(builder.Eq("name", player.username), builder.Eq("id", player.id));
                List<BsonDocument> result = _playerCollection.Find(filter).ToList();

                if (result.Count >= 2)
                {
                    Console.WriteLine($"ALERT: Multiple {player.username} #{player.id} exist in in the database!");
                    Console.WriteLine("This should never happen! Please check the database because that's really weird!!");
                }
                else if (result.Count == 1)
                {
                    if (result[0].GetValue("rank").ToString() != player.rank)
                    {
                        Console.WriteLine($"Updating Player Information for {player.username} #{player.id}...");
                        UpdateDefinition<BsonDocument> update = Builders<BsonDocument>.Update.Set("rank", player.rank).Set("rankDeviation", player.rankDeviation).Set("volatility", player.volatility);
                        _playerCollection.UpdateOne(filter, update);
                        Console.WriteLine("Updated!");
                    }
                    else
                    {
                        Console.WriteLine($"{player.username} #{player.id} already exists in the database");
                    }
                }
                else
                {
                    Console.WriteLine($"Player {player.username} #{player.id} will be inserted into the database...");
                    bsonDocuments.Add(new BsonDocument
                    {
                        { "name", player.username },
                        { "id", player.id },
                        { "rank", player.rank },
                        { "rankDeviation", player.rankDeviation },
                        { "volatility", player.volatility },
                    });
                }
            }

            if (bsonDocuments.Count > 0)
            {
                Console.WriteLine("Attempting to Insert new players into the database...");
                _playerCollection.InsertMany(bsonDocuments);
                Console.WriteLine("Completed Insert Task!");
            }
            else
                Console.WriteLine("There are no new players to add to the database!");
        }

        private static void ExtractPlayers()
        {
            Console.WriteLine("Retrieving Player Data...");
            List<BsonDocument> bsonDocuments = _playerCollection.Find(FilterDefinition<BsonDocument>.Empty).ToList();

            if (bsonDocuments.Count > 0)
            {
                foreach (BsonDocument bson in bsonDocuments)
                {

                    XmlNode root = XmlFile.SelectSingleNode("RankData");
                    XmlNode playerNode = XmlFile.CreateElement("Player");
                    XmlAttribute name = XmlFile.CreateAttribute("name");
                    name.Value = bson.GetValue("name").ToString();
                    XmlAttribute id = XmlFile.CreateAttribute("id");
                    id.Value = bson.GetValue("id").ToString();
                    XmlElement rank = XmlFile.CreateElement("Rank");
                    XmlElement rankDeviation = XmlFile.CreateElement("RankDeviation");
                    XmlElement volatility = XmlFile.CreateElement("Volatility");
                    root.AppendChild(playerNode);
                    playerNode.Attributes.Append(name);
                    playerNode.Attributes.Append(id);
                    playerNode.AppendChild(rank);
                    rank.InnerText = bson.GetValue("rank").ToString();
                    playerNode.AppendChild(rankDeviation);
                    rankDeviation.InnerText = bson.GetValue("rankDeviation").ToString();
                    playerNode.AppendChild(volatility);
                    volatility.InnerText = bson.GetValue("volatility").ToString();
                    XmlFile.Save(Directory.GetCurrentDirectory() + $@"/{XmlFileName}");
                    ClearConsoleLine();
                    Console.Write($"Player {bson.GetValue("name")} loaded... ");
                }
                ClearConsoleLine();
                Console.WriteLine("All players from database loaded!");
            }
            else
            {
                Console.WriteLine("Oh there's nothing in the database.");
                Console.WriteLine("lmao");
            }
        }

        private static void SyncXMLToDatabase()
        {
            Console.WriteLine("Syncing player data...");
            List<BsonDocument> bsonDocuments = _playerCollection.Find(FilterDefinition<BsonDocument>.Empty).ToList();

            if(bsonDocuments.Count > 0)
            {
                foreach(BsonDocument bson in bsonDocuments)
                {
                    XmlNode nodeToCheck = XmlFile.SelectSingleNode("RankData/Player[@name='" + bson.GetValue("name") + "'][@id='" + bson.GetValue("id") + "']/Rank");

                    if(nodeToCheck != null)
                    {
                        if (nodeToCheck.InnerText != bson.GetValue("rank").ToString())
                        {
                            nodeToCheck.InnerText = bson.GetValue("rank").ToString();
                            nodeToCheck = XmlFile.SelectSingleNode("RankData/Player[@name='" + bson.GetValue("name") + "'][@id='" + bson.GetValue("id") + "']/RankDeviation");
                            nodeToCheck.InnerText = bson.GetValue("rankDeviation").ToString();
                            nodeToCheck = XmlFile.SelectSingleNode("RankData/Player[@name='" + bson.GetValue("name") + "'][@id='" + bson.GetValue("id") + "']/Volatility");
                            nodeToCheck.InnerText = bson.GetValue("volatility").ToString();
                            XmlFile.Save(Directory.GetCurrentDirectory() + $@"/{XmlFileName}");
                            ClearConsoleLine();
                            Console.WriteLine($"Player {bson.GetValue("name")} synced...");
                        }
                        else
                        {
                            ClearConsoleLine();
                            Console.Write($"Player {bson.GetValue("name")} verified...");
                        }
                    }
                    else
                    {
                        XmlNode root = XmlFile.SelectSingleNode("RankData");
                        XmlNode playerNode = XmlFile.CreateElement("Player");
                        XmlAttribute name = XmlFile.CreateAttribute("name");
                        name.Value = bson.GetValue("name").ToString();
                        XmlAttribute id = XmlFile.CreateAttribute("id");
                        id.Value = bson.GetValue("id").ToString();
                        XmlElement rank = XmlFile.CreateElement("Rank");
                        XmlElement rankDeviation = XmlFile.CreateElement("RankDeviation");
                        XmlElement volatility = XmlFile.CreateElement("Volatility");
                        root.AppendChild(playerNode);
                        playerNode.Attributes.Append(name);
                        playerNode.Attributes.Append(id);
                        playerNode.AppendChild(rank);
                        rank.InnerText = bson.GetValue("rank").ToString();
                        playerNode.AppendChild(rankDeviation);
                        rankDeviation.InnerText = bson.GetValue("rankDeviation").ToString();
                        playerNode.AppendChild(volatility);
                        volatility.InnerText = bson.GetValue("volatility").ToString();
                        XmlFile.Save(Directory.GetCurrentDirectory() + $@"/{XmlFileName}");
                        ClearConsoleLine();
                        Console.WriteLine($"Player {bson.GetValue("name")} added to XML...");
                    }
                }
                ClearConsoleLine();
                Console.WriteLine("Database synced!");
            }
            else
            {
                Console.WriteLine("There's nothing to sync!");
                Console.WriteLine("How????");
            }
        }

        private static void StartWatchingFile()
        {
            /*FileSystemWatcher watcher = new FileSystemWatcher(AppDomain.CurrentDomain.BaseDirectory);
            watcher.NotifyFilter = NotifyFilters.LastWrite
                                | NotifyFilters.LastAccess
                                | NotifyFilters.FileName;
            watcher.Filter = XmlFileName;
            watcher.Changed += OnChanged;
            watcher.Error += OnError;

            watcher.EnableRaisingEvents = true;*/

            changeToken = provider.Watch(XmlFileName);
            changeToken.RegisterChangeCallback(Notify, default);

        }

        private static void Notify(object state)
        {
            if(changeToken.HasChanged)
            {
                Console.WriteLine();
                Console.WriteLine("File changed!");
                //If the file changed it must have something different in it! Run the function!
                InsertPlayers();
            }
            StartWatchingFile();
        }


        // DIS ONLY WORKS ON WINDOWS LMAOO!!!
        /*private static void OnChanged(object sender, FileSystemEventArgs e)
        {
        
            if (e.ChangeType != WatcherChangeTypes.Changed)
            {
                return;
            }
            Console.WriteLine();
            Console.WriteLine("File changed!");
            //If the file changed it must have something different in it! Run the function!
            InsertPlayers();
        }

        private static void OnError(object sender, ErrorEventArgs e)
        {
            PrintException(e.GetException());
        }

        private static void PrintException(Exception ex)
        {
            if (ex != null)
            {
                Console.WriteLine($"Message: {ex.Message}");
                Console.WriteLine("Stacktrace");
                Console.WriteLine(ex.StackTrace);
                Console.WriteLine();
                PrintException(ex.InnerException);
            }
        }*/

        private static void ClearConsoleLine()
        {
            //Console.SetCursorPosition(0, Console.CursorTop - 1);
            int currentLineCursor = Console.CursorTop;
            Console.SetCursorPosition(0, Console.CursorTop);
            Console.Write(new string(' ', Console.WindowWidth));
            Console.SetCursorPosition(0, currentLineCursor);
        }

        private static List<PlayerObject> GenerateDocuments()
        {
            //Generate documents based on XML document
            List<PlayerObject> playerDatas = new List<PlayerObject>();

            Console.WriteLine("Attempting to read XML...");
            //Read XML doc here, this will be used to add to the playerDatas List
            using (StreamReader reader = new StreamReader(XmlFileName))
            {
                string body = reader.ReadToEnd();

                XmlDocument XmlDoc = new XmlDocument();
                XmlDoc.LoadXml(body);
                XmlNodeList nodes = XmlDoc.SelectNodes("//Player");

                Console.WriteLine("XML read! Attempting to load players...");
                foreach (XmlNode node in nodes)
                {
                    if (node.Attributes.Count > 1)
                    {
                        PlayerObject newPlayer = new PlayerObject()
                        {
                            username = node.Attributes[0].Value,
                            id = node.Attributes[1].Value,
                            rank = node.FirstChild.InnerText,
                            rankDeviation = node.ChildNodes[1].InnerText,
                            volatility = node.ChildNodes[2].InnerText,
                        };
                        ClearConsoleLine();
                        Console.Write($"Player {node.Attributes[0].Value} #{node.Attributes[1].Value} loaded...");
                        playerDatas.Add(newPlayer);
                    }
                }
            }
            ClearConsoleLine();
            Console.WriteLine("All players loaded!");
            Console.WriteLine("Generation complete!");
            return playerDatas;
        }
    }

    public class PlayerObject
    {
        public string username { get; set; }
        public string id { get; set; }
        public string rank { get; set; }
        public string rankDeviation { get; set; }
        public string volatility { get; set; }
    }
}