public MainWindow()
        {
            // Set working directory to path of executable
            Directory.SetCurrentDirectory(AppDomain.CurrentDomain.BaseDirectory);

            InitializeComponent();

            Trace.Listeners.Add(new TextBoxTraceListener(Options.TextBoxLog));

            EnableMenuItems(false);

            try
            {
                if (File.Exists("Updater_new.exe"))
                {
                    if (File.Exists("Updater.exe"))
                    {
                        File.Delete("Updater.exe");
                    }
                    File.Move("Updater_new.exe", "Updater.exe");
                }
            }
            catch
            {
                Logger.WriteLine("Error updating updater");
            }

            Helper.MainWindow = this;
            /*_configPath =*/
            Config.Load();
            HsLogReader.Create();

            var configVersion = string.IsNullOrEmpty(Config.Instance.CreatedByVersion)
                                    ? null
                                    : new Version(Config.Instance.CreatedByVersion);

            Version currentVersion;

            if (Config.Instance.CheckForUpdates)
            {
                currentVersion   = Helper.CheckForUpdates(out NewVersion);
                _lastUpdateCheck = DateTime.Now;
            }
            else
            {
                currentVersion = Helper.GetCurrentVersion();
            }

            var versionString = string.Empty;

            if (currentVersion != null)
            {
                versionString             = string.Format("{0}.{1}.{2}", currentVersion.Major, currentVersion.Minor, currentVersion.Build);
                Help.TxtblockVersion.Text = "Version: " + versionString;

                // Assign current version to the config instance so that it will be saved when the config
                // is rewritten to disk, thereby telling us what version of the application created it
                Config.Instance.CreatedByVersion = currentVersion.ToString();
            }

            ConvertLegacyConfig(currentVersion, configVersion);

            if (Config.Instance.SelectedTags.Count == 0)
            {
                Config.Instance.SelectedTags.Add("All");
            }

            _foundHsDirectory = FindHearthstoneDir();

            if (_foundHsDirectory)
            {
                _updatedLogConfig = UpdateLogConfigFile();
            }

            //hearthstone, loads db etc - needs to be loaded before playerdecks, since cards are only saved as ids now
            Game.Reset();

            _decksPath = Config.Instance.DataDir + "PlayerDecks.xml";
            SetupDeckListFile();
            try
            {
                DeckList = XmlManager <Decks> .Load(_decksPath);
            }
            catch (Exception e)
            {
                MessageBox.Show(
                    e.Message + "\n\n" + e.InnerException +
                    "\n\n If you don't know how to fix this, please delete " + _decksPath +
                    " (this will cause you to lose your decks).",
                    "Error loading PlayerDecks.xml");
                Application.Current.Shutdown();
            }

            foreach (var deck in DeckList.DecksList)
            {
                DeckPickerList.AddDeck(deck);
            }

            SetupDefaultDeckStatsFile();
            DefaultDeckStats.Load();


            SetupDeckStatsFile();
            DeckStatsList.Load();

            _notifyIcon = new NotifyIcon {
                Icon = new Icon(@"Images/HearthstoneDeckTracker16.ico"), Visible = true, ContextMenu = new ContextMenu(), Text = "Hearthstone Deck Tracker v" + versionString
            };
            _notifyIcon.ContextMenu.MenuItems.Add("Use no deck", (sender, args) => DeselectDeck());
            _notifyIcon.ContextMenu.MenuItems.Add(new MenuItem("Autoselect deck")
            {
                MenuItems =
                {
                    new MenuItem("On",
                                 (sender, args) =>
                                 AutoDeckDetection(true)),
                    new MenuItem("Off",
                                 (sender, args) =>
                                 AutoDeckDetection(false))
                }
            }); _notifyIcon.ContextMenu.MenuItems.Add(new MenuItem("Class cards first")
            {
                MenuItems =
                {
                    new MenuItem("Yes",
                                 (sender, args) =>
                                 SortClassCardsFirst(true)),
                    new MenuItem("No",
                                 (sender, args) =>
                                 SortClassCardsFirst(false))
                }
            });
            _notifyIcon.ContextMenu.MenuItems.Add("Show", (sender, args) => ActivateWindow());
            _notifyIcon.ContextMenu.MenuItems.Add("Exit", (sender, args) => Close());
            _notifyIcon.MouseClick += (sender, args) => { if (args.Button == MouseButtons.Left)
                                                          {
                                                              ActivateWindow();
                                                          }
            };

            //create overlay
            Overlay = new OverlayWindow {
                Topmost = true
            };

            PlayerWindow   = new PlayerWindow(Config.Instance, Game.IsUsingPremade ? Game.PlayerDeck : Game.PlayerDrawn);
            OpponentWindow = new OpponentWindow(Config.Instance, Game.OpponentCards);
            TimerWindow    = new TimerWindow(Config.Instance);
            StatsWindow    = new StatsWindow();

            if (Config.Instance.PlayerWindowOnStart)
            {
                PlayerWindow.Show();
            }
            if (Config.Instance.OpponentWindowOnStart)
            {
                OpponentWindow.Show();
            }
            if (Config.Instance.TimerWindowOnStartup)
            {
                TimerWindow.Show();
            }
            if (!DeckList.AllTags.Contains("All"))
            {
                DeckList.AllTags.Add("All");
                WriteDecks();
            }
            if (!DeckList.AllTags.Contains("Favorite"))
            {
                if (DeckList.AllTags.Count > 1)
                {
                    DeckList.AllTags.Insert(1, "Favorite");
                }
                else
                {
                    DeckList.AllTags.Add("Favorite");
                }
                WriteDecks();
            }
            if (!DeckList.AllTags.Contains("Arena"))
            {
                DeckList.AllTags.Add("Arena");
                WriteDecks();
            }
            if (!DeckList.AllTags.Contains("Constructed"))
            {
                DeckList.AllTags.Add("Constructed");
                WriteDecks();
            }
            if (!DeckList.AllTags.Contains("None"))
            {
                DeckList.AllTags.Add("None");
                WriteDecks();
            }

            Options.ComboboxAccent.ItemsSource    = ThemeManager.Accents;
            Options.ComboboxTheme.ItemsSource     = ThemeManager.AppThemes;
            Options.ComboboxLanguages.ItemsSource = Helper.LanguageDict.Keys;

            Options.ComboboxKeyPressGameStart.ItemsSource = EventKeys;
            Options.ComboboxKeyPressGameEnd.ItemsSource   = EventKeys;

            LoadConfig();

            FillElementSorters();

            //this has to happen before reader starts
            var lastDeck = DeckList.DecksList.FirstOrDefault(d => d.Name == Config.Instance.LastDeck);

            DeckPickerList.SelectDeck(lastDeck);

            TurnTimer.Create(90);

            SortFilterDecksFlyout.HideStuffToCreateNewTag();
            TagControlEdit.OperationSwitch.Visibility = Visibility.Collapsed;
            TagControlEdit.PnlSortDecks.Visibility    = Visibility.Collapsed;


            UpdateDbListView();

            _doUpdate = _foundHsDirectory;
            UpdateOverlayAsync();

            _initialized = true;
            Options.MainWindowInitialized();

            DeckPickerList.UpdateList();
            if (lastDeck != null)
            {
                DeckPickerList.SelectDeck(lastDeck);
                UpdateDeckList(lastDeck);
                UseDeck(lastDeck);
            }

            if (_foundHsDirectory)
            {
                HsLogReader.Instance.Start();
            }

            Helper.SortCardCollection(ListViewDeck.Items, Config.Instance.CardSortingClassFirst);
            DeckPickerList.SortDecks();

            // Set Language
            var culture = Config.Instance.SelectedLanguage.Insert(2, "-");

            WPFLocalizeExtension.Engine.LocalizeDictionary.Instance.Culture = System.Globalization.CultureInfo.GetCultureInfo(culture);
            if (!Directory.Exists(culture))
            {
                var langPath = Path.Combine("Lang", culture);
                if (Directory.Exists(langPath))
                {
                    Helper.CopyFolder(langPath, culture);
                    _showRestartMessage = true;
                }
            }
        }