FrmMainApp.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using System.Windows.Forms;
using AutoUpdaterDotNET;
using geoTagNinja;
using GeoTagNinja.Helpers;
using GeoTagNinja.Model;
using GeoTagNinja.Properties;
using GeoTagNinja.View.DialogAndMessageBoxes;
using GeoTagNinja.View.EditFileForm;
using GeoTagNinja.View.ListView;
using Microsoft.Web.WebView2.Core;
using Microsoft.WindowsAPICodePack.Taskbar;
using NLog;
using NLog.Config;
using NLog.Targets;
using TimeZoneConverter;
using static GeoTagNinja.Helpers.HelperControlAndMessageBoxHandling;
using static GeoTagNinja.Model.SourcesAndAttributes;

#pragma warning disable CS8632 // The annotation for nullable reference types should only be used in code within a '#nullable' annotations context.

namespace GeoTagNinja;

public partial class FrmMainApp : Form
{
#region Constants / Fields / Variables

#region Constants

    internal const string DoubleQuote = "\"";

    internal const string ParentFolder = "..";
    internal const string NullStringEquivalentGeneric = "-";
    internal const string NullStringEquivalentBlank = ""; // fml.
    internal const string NullStringEquivalentZero = "0"; // fml.
    internal const int NullIntEquivalent = 0;
    internal const double NullDoubleEquivalent = 0.0;

    internal static readonly DateTime NullDateTimeEquivalent =
        new(year: 1, month: 1, day: 1, hour: 0, minute: 0, second: 0);

#endregion

#region Fields

    /// <summary>
    ///     The EXIFTool used in this application.
    ///     Note that it must be disposed of (done by Form_Closing)!
    /// </summary>
    private readonly ExifTool _ExifTool = new();

    /// <summary>
    ///     The server that receives messages from clients via our named pipe.
    /// </summary>
    private readonly SingleInstance_PipeServer NamedPipeServer;

    /// <summary>
    ///     These two make the elements of the main listview accessible to other classes.
    /// </summary>
    public ListView.ListViewItemCollection ListViewItems => lvw_FileList.Items;

    public ListView.ColumnHeaderCollection ListViewColumnHeaders => lvw_FileList.Columns;

    /// <summary>
    ///     Returns the currently set application language for localization.
    /// </summary>
    private static string AppLanguage => _AppLanguage;

    /// <summary>
    ///     Returns the list of elements in the currently opened directory.
    /// </summary>
    public static DirectoryElementCollection DirectoryElements { get; } = new();

#endregion

#region Variables

    internal static DataTable DtLanguageLabels;
    internal static DataTable DtFavourites;

    // CustomCityLogic

    internal static string FolderName;
    internal static string _AppLanguage = "English"; // default to english
    internal static List<string> LstFavourites = new();

    private static bool _showLocToMapDialogChoice = true;
    private static bool _rememberLocToMapDialogChoice;

    // ReSharper disable once InconsistentNaming
    private FrmSettings FrmSettings;

    // ReSharper disable once InconsistentNaming
    internal FrmEditFileData FrmEditFileData;

    // ReSharper disable once InconsistentNaming
    private FrmImportExportGpx FrmImportExportGpx;

    private string _mapHtmlTemplateCode = "";

    internal static bool RemoveGeoDataIsRunning;
    private static bool _StopProcessingRows;

    // this is for copy-paste
    // the elements are: EA, Value, Changed?
    internal static Dictionary<ElementAttribute, Tuple<string, bool>> CopyPoolDict = new();

    // this is for checking if files need to be re-parsed.
    internal static DataTable DtToponomySessionData;

    internal static List<string> filesToEditGUIDStringList = new();

    internal static readonly TaskbarManager TaskbarManagerInstance =
        TaskbarManager.Instance;

#endregion

#endregion

#region Form/App Related

    internal static readonly Logger Logger = LogManager.GetCurrentClassLogger();

    /// <summary>
    ///     This is the main Form for the app. This particular section handles the initialisation of the form and loading
    ///     various defaults.
    /// </summary>
    public FrmMainApp()
    {
        _ = InitialiseApplication();

    #region Define Logging Config

        // Set up logging
        LoggingConfiguration config = new();

        string logFileLocation =
            Path.Combine(path1: HelperVariables.UserDataFolderPath, path2: "logfile.txt");
        if (File.Exists(path: logFileLocation))
        {
            File.Delete(path: logFileLocation);
        }

        FileTarget logfile = new(name: "logfile") { FileName = logFileLocation };
    #if (DEBUG)
        config.AddRule(minLevel: LogLevel.Trace, maxLevel: LogLevel.Fatal,
            target: logfile);
    #else
        config.AddRule(minLevel: LogLevel.Info, maxLevel: LogLevel.Fatal, target: logfile);
    #endif

        logfile.Layout =
            @"${longdate}|${level:uppercase=true}|${callsite:includeNamespace=false:includeSourcePath=false:methodName=true}|${message:withexception=true}";
        ConsoleTarget logconsole = new(name: "logconsole");

        config.AddRule(minLevel: LogLevel.Info, maxLevel: LogLevel.Fatal,
            target: logconsole);

        // Apply config           
        LogManager.Configuration = config;

    #endregion

        int procID = Process.GetCurrentProcess()
                            .Id;
        Logger.Info(message: "Constructor: Starting GTN with process ID " + procID);
        Logger.Info(message: "Collection mode: " + Program.collectionModeEnabled);
        if (Program.collectionModeEnabled)
        {
            Logger.Info(message: "Collection source: " + Program.collectionFileLocation);
        }

        if (Program.singleInstance_Highlander)
        {
            NamedPipeServer =
                new SingleInstance_PipeServer(messageCallback: PipeCmd_ShowMessage);
        }

        DirectoryElements.ExifTool = _ExifTool;


        Logger.Info(message: "Constructor: Done");
    }

    /// <summary>
    ///     Async method to force all startup elements into one group, which are then awaited.
    ///     The idea is that user shouldn't see stuff like "tmi_help" changing its shape into Help while waiting for the app to
    ///     boot up.
    /// </summary>
    /// <returns></returns>
    private async Task<Task> InitialiseApplication()
    {
        Visible = false;
        SuspendLayout();
        Task[] tasks =
        [
            HelperDataOtherDataRelated.GenericCreateDataTables(),
            HelperGenericAppStartup.AppStartupCreateDatabaseFile(),
            HelperGenericAppStartup.AppStartupWriteDefaultSettings(),
            HelperGenericAppStartup.AppStartupReadSQLiteTables(),
            HelperGenericAppStartup.AppStartupReadAppLanguage(),
            HelperGenericAppStartup.AppStartupReadCustomCityLogic(),
            HelperGenericAppStartup.AppStartupReadAPILanguage(),
            HelperGenericAppStartup.AppStartupApplyDefaults(),
            HelperDataLanguageTZ.DataReadLanguageDataFromCSV(),
            HelperDataLanguageTZ.DataReadCountryCodeDataFromCSV(),
            HelperGenericAppStartup.AppStartupCheckWebView2(),
            AppStartupInitializeComponentFrmMainApp(),
            AppStartupSetAppTheme(),
            AppStartupEnableDoubleBuffering()
        ];

        FormClosing += FrmMainApp_FormClosing;
        //AppStartupApplyVisualStyleDefaults();
        ResumeLayout();
        Visible = true;

        await Task.WhenAll(tasks: tasks);
        return Task.CompletedTask;
    }


    /// <summary>
    ///     Handles the initial loading - adds various elements and ensures the app functions.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void FrmMainApp_Load(object sender,
        EventArgs e)
    {
        Logger.Info(message: "OnLoad: Starting");
        // icon

        Logger.Trace(message: "Setting Icon");
        Icon = Resources.AppIcon;

        // clear both tables, just in case + generic cleanup
        try
        {
            Logger.Debug(message: "Remove Stage 1 AttributeValues");

            foreach (DirectoryElement dirElemFileToModify in DirectoryElements)
            {
                {
                    foreach (ElementAttribute attribute in (ElementAttribute[])
                             Enum.GetValues(enumType: typeof(ElementAttribute)))
                    {
                        dirElemFileToModify.RemoveAttributeValue(
                            attribute: attribute,
                            version: DirectoryElement.AttributeVersion
                                                     .Stage1EditFormIntraTabTransferQueue);
                    }
                }
            }

            Logger.Debug(message: "Clear DtFileDataToWriteStage3ReadyToWrite");
            foreach (DirectoryElement dirElemFileToModify in DirectoryElements)
            {
                {
                    foreach (ElementAttribute attribute in (ElementAttribute[])
                             Enum.GetValues(enumType: typeof(ElementAttribute)))
                    {
                        dirElemFileToModify.RemoveAttributeValue(
                            attribute: attribute,
                            version: DirectoryElement.AttributeVersion
                                                     .Stage3ReadyToWrite);
                    }
                }
            }
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName: "mbx_FrmMainApp_ErrorClearingFileDataQTables") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }

        try
        {
            HelperFileSystemOperators.FsoCleanUpUserFolder();
        }
        catch (Exception ex)
        {
            // not really fatal
            Logger.Error(message: "Error: " + ex.Message);
        }

        // Setup the List View
        try
        {
            lvw_FileList.ReadAndApplySetting(appLanguage: AppLanguage);
        }
        catch (Exception ex)
        {
            Logger.Error(message: "Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                    text: GenericGetMessageBoxText(
                              messageBoxName: "mbx_FrmMainApp_ErrorResizingColumns") +
                          ex.Message,
                    caption: GenericGetMessageBoxCaption(
                        captionType: MessageBoxCaption.Error.ToString()),
                    buttons: MessageBoxButtons.OK,
                    icon: MessageBoxIcon.Error)
                ;
            customMessageBox.ShowDialog();
        }

        // can't log inside.
        Logger.Debug(message: "Run CoreWebView2InitializationCompleted");
        wbv_MapArea.CoreWebView2InitializationCompleted +=
            webView_CoreWebView2InitializationCompleted;

        if (!Program.collectionModeEnabled)
        {
            HelperGenericAppStartup.AppSetupInitialiseStartupFolder(
                toolStripTextBox: tbx_FolderName);
        }

        // initialise webView2
        await InitialiseWebView();

        // assign labels to objects
        AppStartupAssignLabelsToObjects();

        // load lvwFileList
        lvw_FileList_LoadOrUpdate();

        splitContainerMain.Paint += splitContainerControl_Paint;
        splitContainerMain.Invalidate();

        Logger.Trace(message: "Assign 'Enter' Key behaviour to tbx_lng");
        nud_lng.KeyPress += (sndr,
            ev) =>
        {
            if (ev.KeyChar.Equals(obj: (char)13))
            {
                btn_NavigateMapGo.PerformClick();
                ev.Handled = true; // suppress default handling
            }
        };

        HelperGenericAppStartup.AppStartupLoadFavourites();
        HelperGenericAppStartup.AppStartupLoadCustomRules();
        AppStartupGetLastLatLngFromSettings();
        HelperGenericAppStartup.AppStartupGetOverwriteBlankToponomy();
        HelperGenericAppStartup.AppStartupGetToponomyRadiusAndMaxRows();
        Request_Map_NavigateGo();

        await HelperAPIVersionCheckers.CheckForNewVersions();
        LaunchAutoUpdater();
        Logger.Info(message: "OnLoad: Done.");
    }

    /// <summary>
    ///     This fires up the autoupdater
    /// </summary>
    private static void LaunchAutoUpdater()
    {
        HelperNonStatic updateHelper = new();
    #if DEBUG
        //AutoUpdater.InstalledVersion = new Version(version: "1.2"); // here for testing only.
    #endif
        AutoUpdater.Synchronous =
            true; // needs to be true otherwise the single pipe instance crashes. (well, I think _that_ crashes, something does.)
        AutoUpdater.ParseUpdateInfoEvent += updateHelper.AutoUpdaterOnParseUpdateInfoEvent;
        AutoUpdater.CheckForUpdateEvent += updateHelper.AutoUpdaterOnCheckForUpdateEvent;

        string updateJsonPath =
            Path.Combine(path1: HelperVariables.UserDataFolderPath,
                path2: "updateJsonData.json");
        AutoUpdater.Start(appCast: Path.Combine(updateJsonPath));
    }


    /// <summary>
    ///     When the app closes we want to make sure there's nothing in the write-queue.
    ///     ...once that's dealt with we write the details of the app layout (e.g. column widths) to sqlite.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void FrmMainApp_FormClosing(object sender,
        FormClosingEventArgs e)
    {
        Logger.Debug(message: "OnClose: Starting");

        NamedPipeServer.stopServing();

        // this will trigger a write-to-file question/process
        await HelperFileSystemOperators.FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: true);

        PerformAppClosingProcedure();
    }

    internal void PerformAppClosingProcedure(bool extractNewExifTool = true)
    {
        // Write column widths to db
        Logger.Trace(message: "Write column widths to db");
        lvw_FileList.PersistSettings();

        AppClosingPersistData();

        // Clean up
        Logger.Trace(message: "Set pbx_imagePreview.Image = null");
        pbx_imagePreview.Image = null; // unlocks files. theoretically.
        HelperDataApplicationSettings.DataDeleteSQLitesettingsCleanup();
        HelperDataApplicationSettings.DataVacuumDatabase();

        // Shut down ExifTool
        Logger.Debug(message: "OnClose: Dispose ExifTool");
        _ExifTool.Dispose();

        // Unzip new exiftool version if there is one
        if (File.Exists(path: HelperVariables.ExifToolExePathRoamingTemp) && extractNewExifTool)
        {
            try
            {
                // okay this is a bit silly now but given that the ET distrib is no longer a single-file there's a lot of fuckery to be dealt with
                // the zip file has a structure such as c:\Users\nemet\AppData\Roaming\GeoTagNinja\exiftool-12.89_64.zip\exiftool-12.89_64\exiftool(-k).exe 
                // i swear to all the f...king gods this has been the most useless move i've seen with ET development in the last decade.
                // so we do the following
                // 1: delete exiftool
                File.Delete(path: HelperVariables.ExifToolExePathRoamingPerm);

                // 2: delete the exiftool_files folder and anything in it.
                string exifToolFilesDir =
                    Path.Combine(path1: HelperVariables.UserDataFolderPath, path2: "exiftool_files");
                if (Directory.Exists(path: exifToolFilesDir))
                {
                    Directory.Delete(path: exifToolFilesDir, recursive: true);
                }

                // 2b: this shouldn't really happen but anyway:
                string tempExtractDir = Path.Combine(path1: HelperVariables.UserDataFolderPath,
                    path2: Path.GetFileNameWithoutExtension(path: HelperVariables.ExifToolExePathRoamingTemp));
                if (Directory.Exists(path: tempExtractDir))
                {
                    Directory.Delete(path: tempExtractDir, recursive: true);
                }

                // 3: unzip
                ZipFile.ExtractToDirectory(
                    sourceArchiveFileName: HelperVariables.ExifToolExePathRoamingTemp,
                    destinationDirectoryName: HelperVariables.UserDataFolderPath);

                // 4: move to parent
                Directory.Move(
                    sourceDirName: Path.Combine(path1: tempExtractDir, path2: "exiftool_files"),
                    destDirName: Path.Combine(path1: HelperVariables.UserDataFolderPath, path2: "exiftool_files"));

                File.Move(sourceFileName: Path.Combine(path1: tempExtractDir, path2: "exiftool(-k).exe"),
                    destFileName: HelperVariables.ExifToolExePathRoamingPerm);
            }
            catch
            {
                // nothing. basically if there's no exiftool.exe in this folder the app will temporarily revert to the prepackaged one.
            }
        }

        // Clean up Roaming folder
        HelperFileSystemOperators.FsoCleanUpUserFolder();
        Logger.Debug(message: "OnClose: Done.");
    }

    private void AppClosingPersistData()
    {
        // Write lat/long + visual settings for future reference to db
            Logger.Debug(message: "Write lat/long + visual settings for future reference to db");
            List<AppSettingContainer> settingsToWrite = new();
            List<KeyValuePair<string, string>> persistDataSettingsList = new()
            {
                new KeyValuePair<string, string>(key: "lastLat", value: nud_lat.Text),
                new KeyValuePair<string, string>(key: "lastLng", value: nud_lng.Text),
                new KeyValuePair<string, string>(key: "splitContainerMainSplitterDistance",
                    value: splitContainerMain.SplitterDistance.ToString(provider: CultureInfo.InvariantCulture)),
                new KeyValuePair<string, string>(key: "splitContainerLeftTopSplitterDistance",
                    value: splitContainerLeftTop.SplitterDistance.ToString(provider: CultureInfo.InvariantCulture))
            };
            settingsToWrite.AddRange(collection: persistDataSettingsList.Select(selector: persistDataSetting =>
                new AppSettingContainer
                {
                    TableName = "settings", SettingTabPage = "generic", SettingId = persistDataSetting.Key,
                    SettingValue = persistDataSetting.Value
                }));
            HelperDataApplicationSettings.DataWriteSQLiteSettings(settingsToWrite: settingsToWrite);

            // Log stuff
            foreach (KeyValuePair<string, string> keyValuePair in persistDataSettingsList)
            {
                Logger.Debug(
                    message:
                    $"Writing setting.settingId {keyValuePair.Key}, setting.settingValue {keyValuePair.Value}.");
            }
    }


    private void PipeCmd_ShowMessage(string text)
    {
        CustomMessageBox customMessageBox = new(
            text: $"Pipe Server has this message:\n{text}",
            caption: "Pipe Server",
            buttons: MessageBoxButtons.OK,
            icon: MessageBoxIcon.Information);
        customMessageBox.ShowDialog();
    }

#endregion

#region Map Stuff

    /// <summary>
    ///     Provides an interaction layer between the map and the app. The reason why we're using string instead of proper
    ///     numbers
    ///     ... is that the API only deals with English-formatted numbers whereas we can't force that necessarily on the user
    ///     if they have
    ///     ... other Culture setting.
    ///     ... Also if the user zooms out too much they can click on a map-area (coordinate) that's not "real" so we are
    ///     dealing with that in this code.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void wbv_MapArea_WebMessageReceived(object sender,
        CoreWebView2WebMessageReceivedEventArgs e)
    {
        string jsonString = e.WebMessageAsJson;

        MapWebMessage mapWebMessage =
            JsonSerializer.Deserialize<MapWebMessage>(json: jsonString);
        string strLat =
            mapWebMessage?.lat.ToString(provider: CultureInfo.InvariantCulture);
        string strLng =
            mapWebMessage?.lng.ToString(provider: CultureInfo.InvariantCulture);
        bool isDragged = mapWebMessage is
        {
            isDragged: true
        };
        double.TryParse(s: strLat, style: NumberStyles.Any,
            provider: CultureInfo.InvariantCulture,
            result: out
            double dblLat); // trust me i hate this f...king culture thing as much as possible...
        double.TryParse(s: strLng, style: NumberStyles.Any,
            provider: CultureInfo.InvariantCulture,
            result: out
            double dblLng); // trust me i hate this f...king culture thing as much as possible...
        // if the user zooms out too much they can encounter an "unreal" coordinate.

        double correctedDblLat =
            HelperExifDataPointInteractions.GenericCorrectInvalidCoordinate(
                coordHalfPair: dblLat);
        double correctedDblLng =
            HelperExifDataPointInteractions.GenericCorrectInvalidCoordinate(
                coordHalfPair: dblLng);
        nud_lat.Text = correctedDblLat.ToString(provider: CultureInfo.InvariantCulture);
        nud_lng.Text = correctedDblLng.ToString(provider: CultureInfo.InvariantCulture);

        nud_lat.Value = Convert.ToDecimal(value: correctedDblLat,
            provider: CultureInfo.InvariantCulture);
        nud_lng.Value = Convert.ToDecimal(value: correctedDblLng,
            provider: CultureInfo.InvariantCulture);

        if (isDragged && askIfUserWantsToSaveDraggedMapData())
        {
            btn_loctToFile.PerformClick();
        }
    }

    /// <summary>
    ///     Needed for the proper functioning of webview2
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void webView_CoreWebView2InitializationCompleted(object sender,
        CoreWebView2InitializationCompletedEventArgs e)
    {
    }

    /// <summary>
    ///     Checks if the user wants to have a "dragged datapoint" actioned to be sent onto selected files.
    /// </summary>
    /// <returns></returns>
    private bool askIfUserWantsToSaveDraggedMapData()
    {
        CustomMessageBox customMessageBox = new(
            text: GenericGetMessageBoxText(
                messageBoxName: "mbx_FrmMainApp_QuestionAddDraggedDataPointToFiles"),
            caption: GenericGetMessageBoxCaption(
                captionType: MessageBoxCaption.Question.ToString()),
            buttons: MessageBoxButtons.YesNo,
            icon: MessageBoxIcon.Question);
        DialogResult dialogResult = customMessageBox.ShowDialog();
        return dialogResult == DialogResult.Yes;
    }

    /// <summary>
    ///     Handles the clicking on Go button
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void btn_NavigateMapGo_Click(object sender,
        EventArgs e)
    {
        HelperVariables.LstTrackPath.Clear();
        HelperVariables.HsMapMarkers.Clear();
        HelperVariables.HsMapMarkers.Add(item: ParseLatLngTextBox());
        Request_Map_NavigateGo();
    }

    /// <summary>
    ///     Handles the clicking on "ToFile" button. See comments above re: why we're using strings (culture-related issue)
    ///     This now also handles "btn_loctToFileDestination" click as well.
    /// </summary>
    /// <param name="sender">Name of the button that has been clicked</param>
    /// <param name="e">Unused</param>
    private async void btn_loctToFile_Click(object sender,
        EventArgs e)
    {
        // convert selected lat/long to str
        string strGPSLatitudeOnTheMap = nud_lat.Text.Replace(oldChar: ',', newChar: '.');
        string strGPSLongitudeOnTheMap = nud_lng.Text.Replace(oldChar: ',', newChar: '.');
        _StopProcessingRows = false;
        GeoResponseToponomy readJsonToponomy = new();

        Button btn = (Button)sender;
        string senderName = btn.Name;

        // lat/long gets written regardless of update-toponomy-choice
        if (double.TryParse(s: strGPSLatitudeOnTheMap,
                style: NumberStyles.Any,
                provider: CultureInfo.InvariantCulture,
                result: out double _) &&
            double.TryParse(s: strGPSLongitudeOnTheMap,
                style: NumberStyles.Any,
                provider: CultureInfo.InvariantCulture,
                result: out double _))
        {
            if (lvw_FileList.SelectedItems.Count > 0)
            {
                HelperGenericFileLocking.FileListBeingUpdated = true;
                foreach (ListViewItem lvi in lvw_FileList.SelectedItems)
                {
                    DirectoryElement dirElemFileToModify =
                        lvi.Tag as DirectoryElement;
                    // don't do folders...
                    if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
                    {
                        string fileNameWithoutPath =
                            dirElemFileToModify.ItemNameWithoutPath;

                        // check it's not in the read-queue.
                        while (HelperGenericFileLocking.GenericLockCheckLockFile(
                                   fileNameWithoutPath: fileNameWithoutPath))
                        {
                            await Task.Delay(millisecondsDelay: 10);
                        }

                        if (senderName == "btn_loctToFile")
                        {
                            string tmpCoords =
                                strGPSLatitudeOnTheMap + ";" + strGPSLongitudeOnTheMap !=
                                ";"
                                    ? strGPSLatitudeOnTheMap +
                                      ";" +
                                      strGPSLongitudeOnTheMap
                                    : "";

                            List<(ElementAttribute attribute, string value)> attributes =
                                new()
                                {
                                    (ElementAttribute.GPSLatitude,
                                     strGPSLatitudeOnTheMap),
                                    (ElementAttribute.GPSLongitude,
                                     strGPSLongitudeOnTheMap),
                                    (ElementAttribute.Coordinates, tmpCoords)
                                };
                            foreach ((ElementAttribute attribute, string value) in
                                     attributes)
                            {
                                dirElemFileToModify.SetAttributeValueAnyType(
                                    attribute: attribute,
                                    value: value,
                                    version: DirectoryElement.AttributeVersion
                                                             .Stage3ReadyToWrite,
                                    isMarkedForDeletion: false);
                            }

                            if (!_rememberLocToMapDialogChoice)
                            {
                                ShowLocToMapDialog();
                            }

                            DataTable dtToponomy = new();
                            DataTable dtAltitude = new();
                            if (_showLocToMapDialogChoice)
                            {
                                lvw_FileList_UpdateTagsFromWeb(
                                    strGpsLatitude: strGPSLatitudeOnTheMap,
                                    strGpsLongitude: strGPSLongitudeOnTheMap, lvi: lvi);
                            }
                        }
                        else if (senderName == "btn_loctToFileDestination")
                        {
                            string tmpCoords =
                                strGPSLatitudeOnTheMap + ";" + strGPSLongitudeOnTheMap !=
                                ";"
                                    ? strGPSLatitudeOnTheMap +
                                      ";" +
                                      strGPSLongitudeOnTheMap
                                    : "";

                            List<(ElementAttribute attribute, string value)>
                                attributesAndValues = new()
                                {
                                    (ElementAttribute.GPSDestLatitude,
                                     strGPSLatitudeOnTheMap),
                                    (ElementAttribute.GPSDestLongitude,
                                     strGPSLongitudeOnTheMap),
                                    (ElementAttribute.DestCoordinates, tmpCoords)
                                };
                            foreach ((ElementAttribute attribute, string value) in
                                     attributesAndValues)
                            {
                                dirElemFileToModify.SetAttributeValueAnyType(
                                    attribute: attribute,
                                    value: value,
                                    version: DirectoryElement.AttributeVersion
                                                             .Stage3ReadyToWrite,
                                    isMarkedForDeletion: false);
                            }
                        }

                        await FileListViewReadWrite
                           .ListViewUpdateRowFromDEStage3ReadyToWrite(lvi: lvi);
                    }
                }

                HelperGenericFileLocking.FileListBeingUpdated = false;
            }
        }

        // Not logging this.
        FileListViewReadWrite.ListViewCountItemsWithGeoData();

        void ShowLocToMapDialog()
        {
            Dictionary<string, string> checkboxDictionary = new()
            {
                {
                    HelperDataLanguageTZ.DataReadDTObjectText(
                        objectType: ControlType.CheckBox,
                        objectName: "ckb_QuestionAddToponomyDontAskAgain"
                    ),
                    "_remember"
                }
            };
            Dictionary<string, string> buttonsDictionary = new()
            {
                {
                    HelperDataLanguageTZ.DataReadDTObjectText(
                        objectType: ControlType.Button,
                        objectName: "btn_Yes"
                    ),
                    "yes"
                },
                {
                    HelperDataLanguageTZ.DataReadDTObjectText(
                        objectType: ControlType.Button,
                        objectName: "btn_No"
                    ),
                    "no"
                }
            };

            // via https://stackoverflow.com/a/17385937/3968494
            List<string> getLocToMapDialogChoice =
                DialogWithOrWithoutCheckBox.DisplayAndReturnList(
                    labelText: HelperDataLanguageTZ.DataReadDTObjectText(
                        objectType: ControlType.Label,
                        objectName: "lbl_QuestionAddToponomy"
                    ),
                    caption: GenericGetMessageBoxCaption(
                        captionType: MessageBoxCaption.Question.ToString()),
                    buttonsDictionary: buttonsDictionary,
                    orientation: "Horizontal", checkboxesDictionary: checkboxDictionary);

            _showLocToMapDialogChoice = getLocToMapDialogChoice.Contains(item: "yes");
            _rememberLocToMapDialogChoice =
                getLocToMapDialogChoice.Contains(item: "_remember");
        }
    }


    /// <summary>
    ///     Parses the tbx_lat and tbx_lng text boxes.
    ///     If the contents is a valid double, returns touple (lat, lng)
    ///     with values as string and dec separator ".".
    ///     Otherwise default "0" is returned for both.
    /// </summary>
    private (string, string) ParseLatLngTextBox()
    {
        Logger.Trace(message: "Starting parseLatLngTextBox ...");

        // Default values if text field is empty
        string LatCoordinate = "0";
        string LngCoordinate = "0";

        // Get txtbox contents
        string strLatCoordinate = "";
        string strLngCoordinate = "";
        if (!string.IsNullOrEmpty(value: nud_lat.Text))
        {
            strLatCoordinate = nud_lat.Text.Replace(oldChar: ',', newChar: '.');
        }

        if (!string.IsNullOrEmpty(value: nud_lng.Text))
        {
            strLngCoordinate = nud_lng.Text.Replace(oldChar: ',', newChar: '.');
        }

        // Check if it's a valid double -> otherwise defaults above
        try
        {
            Logger.Trace(message: "parseLatLngTextBox");
            double parsedLat;
            double parsedLng;
            if (double.TryParse(s: strLatCoordinate, style: NumberStyles.Any,
                    provider: CultureInfo.InvariantCulture,
                    result: out parsedLat) &&
                double.TryParse(s: strLngCoordinate, style: NumberStyles.Any,
                    provider: CultureInfo.InvariantCulture,
                    result: out parsedLng))
            {
                LatCoordinate = strLatCoordinate;
                LngCoordinate = strLngCoordinate;
                Logger.Trace(message: "parseLatLngTextBox OK - LatCoordinate: " +
                                      strLatCoordinate +
                                      " - LngCoordinate: " +
                                      strLngCoordinate);
            }
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName: "mbx_FrmMainApp_ErrorNavigateMapGoHTMLCode") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }

        return (LatCoordinate, LngCoordinate);
    }


    private void UpdateWebView(IDictionary<string, string> replacements)
    {
        string htmlCode = _mapHtmlTemplateCode;

        // If set, replace arcgis key
        if (HelperVariables.UserSettingArcGisApiKey != null)
        {
            htmlCode = htmlCode.Replace(oldValue: "yourApiKey",
                newValue: HelperVariables
                   .UserSettingArcGisApiKey);
        }

        Logger.Trace(message: "HelperStatic.UserSettingArcGisApiKey == null: " +
                              (HelperVariables.UserSettingArcGisApiKey == null));

        foreach (KeyValuePair<string, string> replacement in replacements)
        {
            Logger.Trace(message: string.Format(format: "Replace: {0} -> {1}",
                arg0: replacement.Key,
                arg1: replacement.Value));
            htmlCode =
                htmlCode.Replace(oldValue: replacement.Key, newValue: replacement.Value);
        }

        // show the decoded location on the map
        try
        {
            Logger.Trace(message: "Calling wbv_MapArea.NavigateToString");
            wbv_MapArea.NavigateToString(htmlContent: htmlCode);
            Logger.Trace(message: "Calling wbv_MapArea.NavigateToString - OK");
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName:
                          "mbx_FrmMainApp_ErrorInitializeWebViewNavigateToStringInHTMLFile") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }
    }


    /// <summary>
    ///     Handles the navigation to a coordinate on the map. Replaces hard-coded values w/ user-provided ones
    ///     ... and executes the navigation action.
    /// </summary>
    [SuppressMessage(category: "ReSharper", checkId: "InconsistentNaming")]
    internal void Request_Map_NavigateGo()
    {
        Logger.Debug(message: "Starting");

        // Set up replacements
        IDictionary<string, string> htmlReplacements = new Dictionary<string, string>();

        HelperVariables.HTMLAddMarker = "";
        HelperVariables.HTMLCreatePoints = ""; // this is ok as-is, won't break the map if stays so.
        double dblLat = 0;
        double dblLng = 0;
        double dblMinLat = 180;
        double dblMinLng = 180;
        double dblMaxLat = -180;
        double dblMaxLng = -180;

        // Add markers on map for every marker-item and
        // find viewing rect. for map (min / max of all markers to enclose all of them)
        if (HelperVariables.HsMapMarkers.Count > 0 ||
            HelperVariables.LstTrackPath.Count > 0)
        {
            if (HelperVariables.HsMapMarkers.Count > 0)
            {
                foreach ((string strLat, string strLng) locationCoord in HelperVariables.HsMapMarkers)
                {
                    AssignViewingRectangle(locationCoord: locationCoord, addMarker: true);
                }
            }

            htmlReplacements.Add(key: "{ HTMLAddMarker }",
                value: HelperVariables.HTMLAddMarker);


            if (HelperVariables.LstTrackPath.Count > 0)
            {
                foreach ((string strLat, string strLng) locationCoord in HelperVariables.LstTrackPath)
                {
                    {
                        AssignViewingRectangle(locationCoord: locationCoord, addMarker: false);
                    }
                }
            }

            HelperVariables.LastLat = dblLat;
            HelperVariables.LastLng = dblLng;

            HelperVariables.MinLat = dblMinLat;
            HelperVariables.MinLng = dblMinLng;
            HelperVariables.MaxLat = dblMaxLat;
            HelperVariables.MaxLng = dblMaxLng;
        }
        else
        {
            // No markers added
            htmlReplacements.Add(key: "{ HTMLAddMarker }", value: "");
        }

        Logger.Trace(message: "Added " +
                              HelperVariables.HsMapMarkers.Count +
                              " map markers.");

        string createPointsStr = "";
        string showLinesStr = "";
        string showPointsStr = "";
        string showFOVStr = "";
        string showDestinationPolyLineStr = "";
        string multiCoordsDefaultStr = """
                                       var #multiCoordsNum# = [
                                           [#multiCoordsList#]
                                       ];
                                       var plArray = [];
                                       for(var i=0; i<#multiCoordsNum#.length; i++) {
                                           plArray.push(L.polyline(#multiCoordsNum#[i]).addTo(map));
                                       }
                                       try{
                                       
                                           L.polylineDecorator(#multiCoordsNum#, {
                                               patterns: [
                                                   {offset: 25, repeat: 50, symbol: L.Symbol.arrowHead({pixelSize: 15, pathOptions: {fillOpacity: 1, weight: 0}})}
                                               ]
                                           }).addTo(map);
                                       }catch(e){
                                        
                                       }
                                       """;
        string mapStyleFilter = HelperVariables.UserSettingMapColourMode switch
        {
            "DarkInverse" =>
                "filter: invert(100%) hue-rotate(180deg) brightness(95%) contrast(90%);",
            "DarkPale" => "filter: brightness(55%) contrast(90%);",
            _ => ""
        };

        string mapStyleCSS = """
                             #map {
                             	border: 3px !important;
                             	border-color: black;
                             	bottom: 0;
                             	height: 100% !important;
                             	left: 0;
                             	position: fixed;
                             	right: 0;
                             	top: 0;
                             	width: 100% !important;
                             	#replaceMe#
                             }
                             """.Replace(oldValue: "#replaceMe#",
            newValue: mapStyleFilter);

        // check there is one and only one DE selected and add ImgDirection if there's any
        // ... or that the gpx-import list has values
        ListView lvw = lvw_FileList;

        Dictionary<string, HashSet<string>>
            dictDestinations =
                new(); // we use a HashSet here because i want to avoid unnecessary duplication

        AddTrackPathDataToDictDestinations(dictDestinations: dictDestinations);

        if (lvw.SelectedItems.Count == 1)
        {
            DirectoryElement directoryElement =
                lvw.SelectedItems[index: 0].Tag as DirectoryElement;
            double? imgDirection = directoryElement.GetAttributeValue<double>(
                attribute: ElementAttribute.GPSImgDirection,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.GPSImgDirection),
                notFoundValue: null);

            // If the data is copy-pasted then the value itself could be 0 with a mark-for-delete
            // GetMaxAttributeVersion returns null if IsMarkedForDeletion
            if (directoryElement
                   .GetMaxAttributeVersion(
                        attribute: ElementAttribute.GPSImgDirection) ==
                null)
            {
                imgDirection = null;
            }

            double? GPSLatitude = directoryElement.GetAttributeValue<double>(
                attribute: ElementAttribute.GPSLatitude,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.GPSLatitude),
                notFoundValue: null);

            double? GPSLongitude = directoryElement.GetAttributeValue<double>(
                attribute: ElementAttribute.GPSLongitude,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.GPSLongitude),
                notFoundValue: null);

            string GPSLatitudeStr = directoryElement.GetAttributeValueString(
                attribute: ElementAttribute.GPSLatitude,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.GPSLatitude),
                notFoundValue: null, nowSavingExif: false);

            string? GPSLongitudeStr = directoryElement.GetAttributeValueString(
                attribute: ElementAttribute.GPSLongitude,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.GPSLongitude),
                notFoundValue: null, nowSavingExif: false);

            double? FocalLength = directoryElement.GetAttributeValue<double>(
                attribute: ElementAttribute.FocalLength,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.FocalLength),
                notFoundValue: 50);

            double? FocalLengthIn35mmFormat = directoryElement.GetAttributeValue<double>(
                attribute: ElementAttribute.FocalLengthIn35mmFormat,
                version: directoryElement.GetMaxAttributeVersion(
                    attribute: ElementAttribute.FocalLengthIn35mmFormat),
                notFoundValue: 50);

            if (imgDirection != null &&
                GPSLatitude != null &&
                GPSLongitude != null)
            {
                // this is for the line
                (double, double) targetCoordinates =
                        HelperGenericCalculations.CalculateTargetCoordinates(
                            startLatitude: (double)GPSLatitude,
                            startLongitude: (double)GPSLongitude,
                            gpsImgDirection: (double)imgDirection,
                            distance: 10)
                    ;

                // this is for the FOV cone
                createPointsStr = string.Format(format: """
                                                        /* Create points */
                                                        let points = [
                                                            {{
                                                                type: 'point',
                                                                coordinates: L.latLng({0}),
                                                                color: '#27ae60',
                                                                priority: 1,
                                                            }},
                                                            {{
                                                                type: 'point',
                                                                coordinates: L.latLng({1}),
                                                                color: '#f44334',
                                                                priority: 2,
                                                            }},
                                                        ];
                                                        """,
                    arg0: GPSLatitudeStr +
                          "," +
                          GPSLongitudeStr,
                    arg1: targetCoordinates.Item1
                                           .ToString(
                                                provider: CultureInfo
                                                   .InvariantCulture)
                                           .Replace(
                                                oldChar: ',',
                                                newChar: '.') +
                          "," +
                          targetCoordinates.Item2
                                           .ToString(
                                                provider: CultureInfo
                                                   .InvariantCulture)
                                           .Replace(
                                                oldChar: ',',
                                                newChar: '.'));

                showLinesStr = """
                               /* Show lines */
                               const line = points.map(point => point.coordinates);
                               L.polyline(line, {color: '#178a00'}).addTo(map);
                               """;

                showPointsStr = """
                                /* Show points */
                                points.sort((a, b) => a.priority - b.priority);

                                points.forEach(point => {
                                	switch (point.type) {
                                		case 'point':
                                			L.circleMarker(point.coordinates, {
                                				radius: 8,
                                				fillColor: point.color,
                                				fillOpacity: 1,
                                				color: '#fff',
                                				weight: 3,
                                			}).addTo(map);
                                			break;
                                
                                	}
                                });
                                """;

                if (FocalLength != null &&
                    FocalLengthIn35mmFormat != null)
                {
                    (List<(double, double)>, List<(double, double)>) FOVCoordinates =
                            HelperGenericCalculations
                               .CalculateFovCoordinatesFromSensorSize(
                                    startLatitude: (double)GPSLatitude,
                                    startLongitude: (double)GPSLongitude,
                                    gpsImgDirection: (double)imgDirection,
                                    sensorSize: HelperGenericCalculations
                                       .EstimateSensorSize(
                                            focalLength: (double)FocalLength,
                                            focalLengthIn35mmFilm:
                                            (double)FocalLengthIn35mmFormat),
                                    focalLength: (double)FocalLength,
                                    distance: 1)
                        ;
                    showFOVStr = string.Format(format: """
                                                       /* Show polygon/triangle */
                                                       var polygon = L.polygon([
                                                           [{0}],
                                                           [{1}],
                                                           [{2}]
                                                       ]).addTo(map);
                                                       """,
                        arg0: GPSLatitudeStr +
                              "," +
                              GPSLongitudeStr,
                        arg1: HelperGenericCalculations
                           .ConvertFOVCoordListsToString(
                                sourceList: FOVCoordinates.Item1),
                        arg2: HelperGenericCalculations
                           .ConvertFOVCoordListsToString(
                                sourceList: FOVCoordinates.Item2));
                }
            }
        }

        // if we have more than one, check if there are any w/ Destination coords
        else
        {
            foreach (ListViewItem lvi in lvw_FileList.SelectedItems)
            {
                DirectoryElement directoryElement = (DirectoryElement)lvi.Tag;
                // probably needs checking but de.Coordinates and de.DestCoordinates don't return anything here, so we're splitting it into four.
                string GPSLatitudeStr = directoryElement.GetAttributeValueString(
                    attribute: ElementAttribute.GPSLatitude,
                    version: directoryElement.GetMaxAttributeVersion(
                        attribute: ElementAttribute.GPSLatitude),
                    notFoundValue: null, nowSavingExif: false);

                string? GPSLongitudeStr = directoryElement.GetAttributeValueString(
                    attribute: ElementAttribute.GPSLongitude,
                    version: directoryElement.GetMaxAttributeVersion(
                        attribute: ElementAttribute.GPSLongitude),
                    notFoundValue: null, nowSavingExif: false);

                string GPSDestLatitudeStr = directoryElement.GetAttributeValueString(
                    attribute: ElementAttribute.GPSDestLatitude,
                    version: directoryElement.GetMaxAttributeVersion(
                        attribute: ElementAttribute.GPSDestLatitude),
                    notFoundValue: null, nowSavingExif: false);

                // If the data is copy-pasted then the value itself could be 0 with a mark-for-delete
                // GetMaxAttributeVersion returns null if IsMarkedForDeletion
                if (directoryElement
                       .GetMaxAttributeVersion(
                            attribute: ElementAttribute.GPSDestLatitude) ==
                    null)
                {
                    GPSDestLatitudeStr = null;
                }

                string? GPSDestLongitudeStr = directoryElement.GetAttributeValueString(
                    attribute: ElementAttribute.GPSDestLongitude,
                    version: directoryElement.GetMaxAttributeVersion(
                        attribute: ElementAttribute.GPSDestLongitude),
                    notFoundValue: null, nowSavingExif: false);

                // If the data is copy-pasted then the value itself could be 0 with a mark-for-delete
                // GetMaxAttributeVersion returns null if IsMarkedForDeletion
                if (directoryElement
                       .GetMaxAttributeVersion(
                            attribute: ElementAttribute.GPSDestLongitude) ==
                    null)
                {
                    GPSDestLongitudeStr = null;
                }

                if (!(string.IsNullOrWhiteSpace(value: GPSLatitudeStr) ||
                      string.IsNullOrWhiteSpace(value: GPSDestLatitudeStr) ||
                      string.IsNullOrWhiteSpace(value: GPSLongitudeStr) ||
                      string.IsNullOrWhiteSpace(value: GPSDestLongitudeStr)))
                {
                    string destCoords =
                        "[" + GPSDestLatitudeStr + "," + GPSDestLongitudeStr + "]";
                    string gpsCoords = "[" + GPSLatitudeStr + "," + GPSLongitudeStr + "]";
                    if (!dictDestinations.ContainsKey(key: destCoords))
                    {
                        dictDestinations[key: destCoords] = new HashSet<string>();
                    }

                    dictDestinations[key: destCoords]
                       .Add(item: gpsCoords);
                }
            }
        }

        if (dictDestinations.Count == 0 &&
            HelperVariables.LstTrackPath.Count == 0)
        {
            showDestinationPolyLineStr = ""; // reset if false alarm
        }
        else
        {
            // build a line of lines
            showDestinationPolyLineStr = BuildDestinationPolyLineStr(multiCoordsDefaultStr: multiCoordsDefaultStr);
        }


        List<(string key, string value)> replacements = new()
        {
            ("replaceLat", HelperVariables.LastLat.ToString()
                                          .Replace(oldChar: ',', newChar: '.')),
            ("replaceLng", HelperVariables.LastLng.ToString()
                                          .Replace(oldChar: ',', newChar: '.')),
            ("replaceMinLat", HelperVariables.MinLat.ToString()
                                             .Replace(oldChar: ',', newChar: '.')),
            ("replaceMinLng", HelperVariables.MinLng.ToString()
                                             .Replace(oldChar: ',', newChar: '.')),
            ("replaceMaxLat", HelperVariables.MaxLat.ToString()
                                             .Replace(oldChar: ',', newChar: '.')),
            ("replaceMaxLng", HelperVariables.MaxLng.ToString()
                                             .Replace(oldChar: ',', newChar: '.')),
            ("{ HTMLMapStyleCSS }", mapStyleCSS),
            ("{ HTMLCreatePoints }", createPointsStr),
            ("{ HTMLShowLines }", showLinesStr),
            ("{ HTMLShowPoints }", showPointsStr),
            ("{ HTMLShowFOVPolygon }", showFOVStr),
            ("{ HTMLShowPolyLine }", showDestinationPolyLineStr)
        };
        foreach ((string key, string value) in replacements)
        {
            htmlReplacements.Add(key: key, value: value);
        }

        UpdateWebView(replacements: htmlReplacements);

        void AddTrackPathDataToDictDestinations(Dictionary<string, HashSet<string>> dictDestinations)
        {
            if (HelperVariables.LstTrackPath.Count != 0)
            {
                // bit of a trick here and also to make coding easier. 
                // i'm faking HelperVariables.LstTrackPath into dictDestinations

                // dictDestinations:
                // key: "[51.493224,0.121858]"
                // value: "[[51.491087,0.119283], [51.491915,0.121091], [51.493224,0.121858]]"

                // logically then the last item in the list (which is formatted differently) is the key
                string destCoords =
                    "[" + HelperVariables.LstTrackPath.Last().strLat + "," +
                    HelperVariables.LstTrackPath.Last().strLng + "]";
                if (!dictDestinations.ContainsKey(key: destCoords))
                {
                    dictDestinations[key: destCoords] = new HashSet<string>();
                }

                for (int i = 0; i < HelperVariables.LstTrackPath.Count; i++)
                {
                    string gpsCoords = "[" + HelperVariables.LstTrackPath[index: i].strLat + "," +
                                       HelperVariables.LstTrackPath[index: i].strLng + "]";
                    dictDestinations[key: destCoords]
                       .Add(item: gpsCoords);
                }
            }
        }

        double GetMinLatitude(double dLat)
        {
            return Math.Min(val1: dblMinLat, val2: dLat);
        }

        double GetMaxLatitude(double dLat)
        {
            return Math.Max(val1: dblMaxLat, val2: dLat);
        }

        double GetMinLongitude(double dLng)
        {
            return Math.Min(val1: dblMinLng, val2: dLng);
        }

        double GetMaxLongitude(double dLng)
        {
            return Math.Max(val1: dblMaxLng, val2: dLng);
        }


        void AssignViewingRectangle((string strLat, string strLng) locationCoord, bool addMarker)
        {
            if (addMarker)
            {
                // Add marker location
                HelperVariables.HTMLAddMarker += "var marker = L.marker([" +
                                                 locationCoord.strLat +
                                                 ", " +
                                                 locationCoord.strLng +
                                                 "],{\n" +
                                                 "draggable: true,\n" +
                                                 "autoPan: true\n" +
                                                 "}).addTo(map).openPopup();" +
                                                 "\n";

                Logger.Trace(message: "Added marker: strLatCoordinate: " +
                                      locationCoord.strLat +
                                      " / strLngCoordinate:" +
                                      locationCoord.strLng);
            }

            // Update viewing rectangle if needed
            dblLat = double.Parse(s: locationCoord.strLat,
                provider: CultureInfo.InvariantCulture);
            dblLng = double.Parse(s: locationCoord.strLng,
                provider: CultureInfo.InvariantCulture);

            dblMinLat = GetMinLatitude(dLat: dblLat);
            dblMaxLat = GetMaxLatitude(dLat: dblLat);
            dblMinLng = GetMinLongitude(dLng: dblLng);
            dblMaxLng = GetMaxLongitude(dLng: dblLng);
        }

        string BuildDestinationPolyLineStr(string multiCoordsDefaultStr)
        {
            // for each (numbered) destination group...
            for (int dictDestinationCounter = 0;
                 dictDestinationCounter < dictDestinations.Count;
                 dictDestinationCounter++)
            {
                string multiCoordsListStr = "";
                string multiCoordsNum = dictDestinationCounter.ToString();
                string multiCoordsStr = multiCoordsDefaultStr.Replace(
                    oldValue: "#multiCoordsNum#",
                    newValue: "multiCoords" + multiCoordsNum);
                foreach (string gpsCoord in dictDestinations
                                           .ElementAt(index: dictDestinationCounter)
                                           .Value)
                {
                    multiCoordsListStr += gpsCoord + ",";
                }

                multiCoordsListStr += dictDestinations
                                     .ElementAt(index: dictDestinationCounter)
                                     .Key;

                multiCoordsStr = multiCoordsStr.Replace(
                    oldValue: "#multiCoordsList#", newValue: multiCoordsListStr);
                showDestinationPolyLineStr += multiCoordsStr;
            }

            return showDestinationPolyLineStr;
        }
    }


    /// <summary>
    ///     Initialises the map in the app and browses to the default or last-used location.
    /// </summary>
    /// <returns></returns>
    private async Task InitialiseWebView()
    {
        Logger.Debug(message: "Starting");

        // Create Browser Connection
        try
        {
            // silly thing dumps the folder by default right into Program Files where it can't write further due to permission issues
            // need to move it elsewhere.
            Logger.Trace(message: "await CoreWebView2Environment");
            CoreWebView2Environment c2Wv = await CoreWebView2Environment.CreateAsync(
                browserExecutableFolder: null,
                userDataFolder: Path.GetTempPath(),
                options: new CoreWebView2EnvironmentOptions(
                    additionalBrowserArguments: null, language: "en"));
            await wbv_MapArea.EnsureCoreWebView2Async(environment: c2Wv);
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName:
                          "mbx_FrmMainApp_ErrorInitializeWebViewEnsureCoreWebView2Async") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }

        // Initialize WebView
        try
        {
            if (wbv_MapArea.CoreWebView2 != null)
            {
                Logger.Trace(message: "CoreWebView2.Settings.IsWebMessageEnabled");
                wbv_MapArea.CoreWebView2.Settings.IsWebMessageEnabled = true;
            }
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName:
                          "mbx_FrmMainApp_ErrorInitializeWebViewIsWebMessageEnabled") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }

        // read the "map.html" file.
        try
        {
            Logger.Trace(message: "Read map.html file");
            _mapHtmlTemplateCode = File.ReadAllText(
                path: Path.Combine(path1: HelperVariables.ResourcesFolderPath,
                    path2: "map.html"));
            Logger.Trace(message: "Read map.html file OK");
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Read map.html file - Error: " + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName:
                          "mbx_FrmMainApp_ErrorInitializeWebViewReadHTMLFile") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }

        // Get the ArcGis API Key
        if (string.IsNullOrEmpty(value: HelperVariables.UserSettingArcGisApiKey))
        {
            Logger.Trace(
                message:
                "Replace hard-coded values in the html code - UserSettingArcGisApiKey is null");
            HelperVariables.UserSettingArcGisApiKey =
                HelperDataApplicationSettings.DataReadSQLiteSettings(
                    dataTable: HelperVariables.DtHelperDataApplicationSettings,
                    settingTabPage: "tpg_Application",
                    settingId: "tbx_ARCGIS_APIKey",
                    returnBlankIfNull: true);
            Logger.Trace(
                message:
                "Replace hard-coded values in the html code - UserSettingArcGisApiKey obtained from SQLite OK");
        }

        // Parse coords from lat/lng text box
        (string LatCoordinate, string LngCoordinate) = ParseLatLngTextBox();

        // Set up replacements
        IDictionary<string, string> htmlReplacements = new Dictionary<string, string>();
        htmlReplacements.Add(key: "replaceLat", value: LatCoordinate);
        htmlReplacements.Add(key: "replaceLng", value: LngCoordinate);

        // Show on Map
        UpdateWebView(replacements: htmlReplacements);

        // Set up event handler for clicks in map
        try
        {
            Logger.Trace(message: "wbv_MapArea.WebMessageReceived");
            wbv_MapArea.WebMessageReceived += wbv_MapArea_WebMessageReceived;
        }
        catch (Exception ex)
        {
            Logger.Fatal(message: "Error:" + ex.Message);
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName:
                          "mbx_FrmMainApp_ErrorInitializeWebViewWebMessageReceived") +
                      ex.Message,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Error.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Error);
            customMessageBox.ShowDialog();
        }
    }

#endregion

#region File (that is, the "File" menu tree)

    /// <summary>
    ///     Handles the tmi_File_SaveAll_Click event -> triggers the file-save process
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void tmi_File_SaveAll_Click(object sender,
        EventArgs e)
    {
        // i think having an Item active can cause a lock on it
        while (HelperGenericFileLocking.FileListBeingUpdated ||
               HelperGenericFileLocking.FilesAreBeingSaved)
        {
            await Task.Delay(millisecondsDelay: 10);
        }

        lvw_FileList.SelectedItems.Clear();
        // also the problem here is that the exiftoolAsync can still be running and locking the file.

        await HelperExifWriteSaveToFile.ExifWriteExifToFile();
        HelperGenericFileLocking.FilesAreBeingSaved = false;
        //DtFileDataToWriteStage3ReadyToWrite.Rows.Clear();
    }

    /// <summary>
    ///     Handles the tmi_File_EditFiles_Click event -> opens the File Edit Form
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_File_EditFiles_Click(object sender,
        EventArgs e)
    {
        filesToEditGUIDStringList.Clear();

        ListView lvw = lvw_FileList;
        foreach (ListViewItem lvi in lvw.SelectedItems)
        {
            DirectoryElement directoryElement =
                lvi.Tag as DirectoryElement;

            filesToEditGUIDStringList.Add(
                item: directoryElement.GetAttributeValueString(
                    attribute: ElementAttribute.GUID,
                    version: DirectoryElement.AttributeVersion
                                             .Original, // GUIDs don't change
                    notFoundValue: null, nowSavingExif: false));
        }

        EditFileFormGeneric.ShowFrmEditFileData();
    }

    /// <summary>
    ///     Handles the tmi_File_CopyGeoData_Click event -> triggers LwvCopyGeoData
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_File_CopyGeoData_Click(object sender,
        EventArgs e)
    {
        FileListViewCopyPaste.ListViewCopyGeoData();
    }

    /// <summary>
    ///     Handles the tmi_File_PasteGeoData_Click event -> triggers LwvPasteGeoData
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_File_PasteGeoData_Click(object sender,
        EventArgs e)
    {
        FileListViewCopyPaste.ListViewPasteGeoData();
    }

    /// <summary>
    ///     Handles the tmi_File_ImportExportGPX_Click event -> Brings up the FrmImportExportGpx to import track
    ///     files
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_File_ImportExportGPX_Click(object sender,
        EventArgs e)
    {
        FrmImportExportGpx = new FrmImportExportGpx();
        FrmImportExportGpx.Text = HelperDataLanguageTZ.DataReadDTObjectText(
            objectType: ControlType.Form,
            objectName: "FrmImportExportGpx"
        );
        FrmImportExportGpx.ShowDialog();
    }

    /// <summary>
    ///     Handles the tmi_File_Quit_Click event -> cleans the user-folder then quits the app
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_File_Quit_Click(object sender,
        EventArgs e)
    {
        HelperFileSystemOperators.FsoCleanUpUserFolder();
        Application.Exit();
    }

#endregion

#region FrmMainApp's TaskBar Stuff

    /// <summary>
    ///     Handles the tsb_Refresh_lvwFileList_Click event -> checks if there is anything in the write-Q
    ///     ... then cleans up the user-folder and triggers lvw_FileList_LoadOrUpdate
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void tsb_Refresh_lvwFileList_Click(object sender,
        EventArgs e)
    {
        Logger.Debug(message: "Starting");

        HelperVariables.OperationChangeFolderIsOkay = false;
        await HelperFileSystemOperators
           .FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: false);
        if (HelperVariables.OperationChangeFolderIsOkay)
        {
            if (!Program.collectionModeEnabled)
            {
                if (Directory.Exists(path: tbx_FolderName.Text))
                {
                    if (!tbx_FolderName.Text.EndsWith(value: "\\"))
                    {
                        tbx_FolderName.Text += "\\";
                    }

                    try
                    {
                        lvw_FileList.ClearData();
                        // DirectoryElements.Clear();
                        HelperFileSystemOperators.FsoCleanUpUserFolder();
                        FolderName = tbx_FolderName.Text;
                        lvw_FileList_LoadOrUpdate();
                    }
                    catch (Exception ex)
                    {
                        ShowInvalidFolderMessage(exceptionMessage: ex.Message);
                    }
                }
                else if (tbx_FolderName.Text == Environment.SpecialFolder.MyComputer.ToString())
                {
                    lvw_FileList_LoadOrUpdate();
                }

                else
                {
                    ShowInvalidFolderMessage();
                }
            }
            else
            {
                lvw_FileList_LoadOrUpdate();
            }
        }

        void ShowInvalidFolderMessage(string exceptionMessage = "")
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                          messageBoxName:
                          "mbx_FrmMainApp_ErrorInvalidFolder") +
                      exceptionMessage,
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Question.ToString()),
                buttons: MessageBoxButtons.YesNo,
                icon: MessageBoxIcon.Question);
            DialogResult dialogResult = customMessageBox.ShowDialog();
            if (dialogResult == DialogResult.Yes)
            {
                tbx_FolderName.Text = @"C:\";
                tbx_FolderName.Select();
                SendKeys.Send(keys: "{ENTER}");
            }
        }
    }

    /// <summary>
    ///     Performs a pull of Toponomy & Altitude info for all of the selected files.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void tsb_GetAllFromWeb_Click(object sender,
        EventArgs e)
    {
        HelperVariables.OperationAPIReturnedOKResponse = true;
        _StopProcessingRows = false;
        FrmMainApp frmMainAppInstance =
            (FrmMainApp)Application.OpenForms[name: "FrmMainApp"];
        if (frmMainAppInstance != null)
        {
            ListView lvw = frmMainAppInstance.lvw_FileList;
            if (lvw.SelectedItems.Count > 0)
            {
                foreach (ListViewItem lvi in
                         frmMainAppInstance.lvw_FileList.SelectedItems)
                {
                    DirectoryElement dirElemFileToModify =
                        lvi.Tag as DirectoryElement;
                    // don't do folders...
                    if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
                    {
                        string fileNameWithPath = dirElemFileToModify.FileNameWithPath;
                        string fileNameWithoutPath =
                            dirElemFileToModify.ItemNameWithoutPath;

                        // check it's not in the read-queue.
                        while (HelperGenericFileLocking.GenericLockCheckLockFile(
                                   fileNameWithoutPath: fileNameWithoutPath))
                        {
                            await Task.Delay(millisecondsDelay: 10);
                        }

                        string strGpsLatitude = lvi.SubItems[
                                                        index: lvw
                                                              .Columns[
                                                                   key: FileListView.COL_NAME_PREFIX +
                                                                        FileListView.FileListColumns
                                                                           .GPS_LATITUDE]
                                                              .Index]
                                                   .Text.ToString(
                                                        provider: CultureInfo
                                                           .InvariantCulture);
                        string strGpsLongitude = lvi.SubItems[
                                                         index: lvw
                                                               .Columns[
                                                                    key: FileListView.COL_NAME_PREFIX +
                                                                         FileListView.FileListColumns
                                                                            .GPS_LONGITUDE]
                                                               .Index]
                                                    .Text.ToString(
                                                         provider: CultureInfo
                                                            .InvariantCulture);
                        double parsedLat = 0.0;
                        double parsedLng = 0.0;
                        if (double.TryParse(s: strGpsLatitude,
                                style: NumberStyles.Any,
                                provider: CultureInfo.InvariantCulture,
                                result: out parsedLat) &&
                            double.TryParse(s: strGpsLongitude,
                                style: NumberStyles.Any,
                                provider: CultureInfo.InvariantCulture,
                                result: out parsedLng))
                        {
                            lvw_FileList_UpdateTagsFromWeb(
                                strGpsLatitude: strGpsLatitude,
                                strGpsLongitude: strGpsLongitude, lvi: lvi);
                        }
                    }
                }
            }
        }

        //done
        HandlerUpdateLabelText(label: lbl_ParseProgress, text: "");
    }


    /// <summary>
    ///     Generally similar to the above.(btn_Refresh_lvwFileList_Click)
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void btn_ts_Refresh_lvwFileList_Click(object sender,
        EventArgs e)
    {
        Logger.Debug(message: "Starting");

        HelperVariables.OperationChangeFolderIsOkay = false;
        await HelperFileSystemOperators
           .FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: false);
        Logger.Trace(message: "OperationChangeFolderIsOkay: " +
                              HelperVariables.OperationChangeFolderIsOkay);

        if (HelperVariables.OperationChangeFolderIsOkay)
        {
            tsb_Refresh_lvwFileList_Click(sender: this, e: EventArgs.Empty);
        }
    }

    /// <summary>
    ///     Handles the btn_OneFolderUp_Click event -> Ensures the write-Q is emtpy, that the parent folder exists and
    ///     ... if all's well then moves folder. On error moves to C:\
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void btn_OneFolderUp_Click(object sender,
        EventArgs e)
    {
        Logger.Debug(message: "Starting");

        HelperVariables.OperationChangeFolderIsOkay = false;
        await HelperFileSystemOperators
           .FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: false);
        Logger.Trace(message: "OperationChangeFolderIsOkay: " +
                              HelperVariables.OperationChangeFolderIsOkay);

        if (HelperVariables.OperationChangeFolderIsOkay)
        {
            string? tmpStrParent = null;
            string? tmpStrRoot = null;
            // this is a bit derp but alas
            if (tbx_FolderName.Text.EndsWith(value: "\\"))
            {
                try
                {
                    tmpStrParent =
                        HelperFileSystemOperators.FsoGetParent(path: tbx_FolderName.Text);
                }
                catch
                {
                    tmpStrParent = HelperGenericTypeOperations.Coalesce(
                        Directory.GetDirectoryRoot(path: tbx_FolderName.Text)
                      , "C:"
                    );
                }

                tmpStrRoot = HelperGenericTypeOperations.Coalesce(
                    Directory.GetDirectoryRoot(path: tbx_FolderName.Text),
                    "C:"
                );
                tbx_FolderName.Text =
                    HelperGenericTypeOperations.Coalesce(tmpStrParent, tmpStrRoot);
            }

            Application.DoEvents();
            FolderName = tbx_FolderName.Text;

            Logger.Trace(message: "FolderName: " + FolderName);

            btn_ts_Refresh_lvwFileList_Click(sender: this, e: EventArgs.Empty);
        }
    }

    /// <summary>
    ///     Handles the tsb_EditFile_Click event -> shows the Edit File Form
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tsb_EditFile_Click(object sender,
        EventArgs e)
    {
        filesToEditGUIDStringList.Clear();

        ListView lvw = lvw_FileList;
        foreach (ListViewItem lvi in lvw.SelectedItems)
        {
            DirectoryElement directoryElement =
                lvi.Tag as DirectoryElement;

            filesToEditGUIDStringList.Add(
                item: directoryElement.GetAttributeValueString(
                    attribute: ElementAttribute.GUID,
                    version: DirectoryElement.AttributeVersion
                                             .Original, // GUIDs don't change
                    notFoundValue: null, nowSavingExif: false));
        }

        EditFileFormGeneric.ShowFrmEditFileData();
    }

    /// <summary>
    ///     Handles the tsb_RemoveGeoData_Click event -> calls HelperStatic.ExifRemoveLocationData to remove GeoData from all
    ///     selected files
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void tsb_RemoveGeoData_Click(object sender,
        EventArgs e)
    {
        // if user is impatient and hammer-spams the button it could create a very long queue of nothing-useful.
        if (!RemoveGeoDataIsRunning)
        {
            RemoveGeoDataIsRunning = true;
            await HelperExifDataPointInteractions.ExifRemoveLocationData(
                senderName: "FrmMainApp");
            RemoveGeoDataIsRunning = false;
            FileListViewReadWrite.ListViewCountItemsWithGeoData();
        }
    }

    /// <summary>
    ///     Handles the tsb_ImportExportGPX_Click event -> shows the FrmImportExportGpx Form
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tsb_ImportExportGPX_Click(object sender,
        EventArgs e)
    {
        bool validFilesToImport = false;
        foreach (ListViewItem lvi in lvw_FileList.SelectedItems)
        {
            DirectoryElement dirElemFileToModify =
                lvi.Tag as DirectoryElement;
            if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
            {
                validFilesToImport = true;
                break;
            }
        }

        if (validFilesToImport)
        {
            FrmImportExportGpx frmImportGpx = new();
            frmImportGpx.StartPosition = FormStartPosition.CenterScreen;
            frmImportGpx.ShowDialog();
        }
        else
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmImportExportGpx_NoFileSelected"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Warning.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Warning);
            customMessageBox.ShowDialog();
        }
    }

    /// <summary>
    ///     Handles various keypress events. -> currently for tbx_FolderName when pressing Enter it will move to the folder
    ///     ... if value is a folder subject to the usual "move folder" requirements.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void tbx_FolderName_KeyDown(object sender,
        KeyEventArgs e)
    {
        if (e.KeyCode == Keys.Enter)
        {
            HelperVariables.OperationChangeFolderIsOkay = false;
            await HelperFileSystemOperators
               .FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: false);
            if (HelperVariables.OperationChangeFolderIsOkay)
            {
                btn_ts_Refresh_lvwFileList_Click(sender: this, e: new EventArgs());
            }
        }
    }

    /// <summary>
    ///     This handles the event when the user clicks into the textbox -> current value gets selected.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tbx_FolderName_Enter(object sender,
        EventArgs e)
    {
        tbx_FolderName.SelectAll();
    }

    /// <summary>
    ///     Handles the tsb_SaveFiles_Click event -> triggers ExifWriteExifToFile
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void tsb_SaveFiles_Click(object sender,
        EventArgs e)
    {
        while (HelperGenericFileLocking.FileListBeingUpdated ||
               HelperGenericFileLocking.FilesAreBeingSaved)
        {
            await Task.Delay(millisecondsDelay: 10);
        }

        // i think having an Item active can cause a lock on it
        lvw_FileList.SelectedItems.Clear();
        // also the problem here is that the exiftoolAsync can still be running and locking the file.

        await HelperExifWriteSaveToFile.ExifWriteExifToFile();
        HelperGenericFileLocking.FilesAreBeingSaved = false;
        //DtFileDataToWriteStage3ReadyToWrite.Rows.Clear();
    }

#endregion

#region Themeing

    // via https://stackoverflow.com/a/75716080/3968494
    private void ListView_DrawColumnHeader(object sender,
        DrawListViewColumnHeaderEventArgs e)
    {
        Color foreColor = HelperVariables.UserSettingUseDarkMode
            ? Color.White
            : Color.Black;

        Color backColor = HelperVariables.UserSettingUseDarkMode
            ? ColorTranslator.FromHtml(htmlColor: "#404040")
            : SystemColors.ControlDark;

        //Fills one solid background for each cell.
        using (SolidBrush backColorkBrush = new(color: backColor))
        {
            e.Graphics.FillRectangle(brush: backColorkBrush, rect: e.Bounds);
        }

        //Draw the borders for the header around each cell.
        using (Pen foreColorPen = new(color: foreColor))
        {
            e.Graphics.DrawRectangle(pen: foreColorPen, rect: e.Bounds);
        }

        using (SolidBrush foreColorBrush = new(color: foreColor))
        {
            StringFormat stringFormat = GetStringFormat();

            //Do some padding, since these draws right up next to the border for Left/Near.  Will need to change this if you use Right/Far
            Rectangle rect = e.Bounds;
            rect.X += 2;
            e.Graphics.DrawString(s: e.Header.Text, font: e.Font, brush: foreColorBrush,
                layoutRectangle: rect, format: stringFormat);
        }
    }

    private StringFormat GetStringFormat()
    {
        return new StringFormat
        {
            Alignment = StringAlignment.Near,
            LineAlignment = StringAlignment.Center
        };
    }

    private void ListView_DrawItem(object sender,
        DrawListViewItemEventArgs e)
    {
        e.DrawDefault = true;
    }

    private void ListView_DrawSubItem(object sender,
        DrawListViewSubItemEventArgs e)
    {
        e.DrawDefault = true;
    }


    // via https://stackoverflow.com/questions/9260303/how-to-change-menu-hover-color
    private class DarkMenuStripRenderer : ToolStripProfessionalRenderer
    {
        public DarkMenuStripRenderer() : base(professionalColorTable: new DarkColours())
        {
        }

        protected override void OnRenderItemText(ToolStripItemTextRenderEventArgs e)
        {
            e.TextColor = Color.White;

            base.OnRenderItemText(e: e);
        }
    }


    private class DarkColours : ProfessionalColorTable
    {
        public override Color MenuItemBorder =>
            ColorTranslator.FromHtml(htmlColor: "#BAB9B9");

        public override Color MenuBorder =>
            Color.Silver; //added for changing the menu border

        public override Color MenuItemPressedGradientBegin =>
            ColorTranslator.FromHtml(htmlColor: "#4C4A48");

        public override Color MenuItemPressedGradientEnd =>
            ColorTranslator.FromHtml(htmlColor: "#5F5D5B");

        public override Color ToolStripBorder =>
            ColorTranslator.FromHtml(htmlColor: "#4C4A48");

        public override Color MenuItemSelectedGradientBegin =>
            ColorTranslator.FromHtml(htmlColor: "#4C4A48");

        public override Color MenuItemSelectedGradientEnd =>
            ColorTranslator.FromHtml(htmlColor: "#5F5D5B");

        public override Color MenuItemSelected =>
            ColorTranslator.FromHtml(htmlColor: "#5F5D5B");

        public override Color ToolStripDropDownBackground =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ToolStripGradientBegin =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ToolStripGradientEnd =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ToolStripGradientMiddle =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ImageMarginGradientBegin =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ImageMarginGradientEnd =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ImageMarginGradientMiddle =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ImageMarginRevealedGradientBegin =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ImageMarginRevealedGradientEnd =>
            ColorTranslator.FromHtml(htmlColor: "#404040");

        public override Color ImageMarginRevealedGradientMiddle =>
            ColorTranslator.FromHtml(htmlColor: "#404040");
    }

#endregion

#region lvw_FileList Interaction

    /// <summary>
    ///     Pulls data from the various APIs and fills up the listView
    /// </summary>
    /// <param name="strGpsLatitude">Latitude as string</param>
    /// <param name="strGpsLongitude">Longitude as string</param>
    /// <param name="lvi">ListViewItem in the the main grid</param>
    private void lvw_FileList_UpdateTagsFromWeb(string strGpsLatitude,
        string strGpsLongitude,
        ListViewItem lvi)
    {
        if (!_StopProcessingRows)
        {
            DirectoryElement dirElemFileToModify =
                lvi.Tag as DirectoryElement;
            string fileNameWithoutPath = dirElemFileToModify.ItemNameWithoutPath;

            HelperVariables.CurrentAltitude = null;
            HelperVariables.CurrentAltitude = lvw_FileList
                                             .FindItemWithText(text: fileNameWithoutPath)
                                             .SubItems[
                                                  index: lvw_FileList
                                                        .Columns[
                                                             key: FileListView.COL_NAME_PREFIX +
                                                                  FileListView.FileListColumns.GPS_ALTITUDE]
                                                        .Index]
                                             .Text.ToString(
                                                  provider: CultureInfo.InvariantCulture);

            DataTable dtToponomy =
                HelperExifReadExifData.DTFromAPIExifGetToponomyFromWebOrSQL(
                    lat: strGpsLatitude,
                    lng: strGpsLongitude,
                    fileNameWithoutPath: fileNameWithoutPath);
            if (dtToponomy.Rows.Count > 0)
            {
                // Send off to SQL
                List<(ElementAttribute attribute, string toponomyOverwriteVal)>
                    toponomyOverwrites = new()
                    {
                        (ElementAttribute.CountryCode,
                         dtToponomy.Rows[index: 0][columnName: "CountryCode"]
                                   .ToString()),
                        (ElementAttribute.Country,
                         dtToponomy.Rows[index: 0][columnName: "Country"]
                                   .ToString())
                    };

                foreach (ElementAttribute attribute in HelperGenericAncillaryListsArrays
                            .ToponomyReplaces())
                {
                    string colName = GetElementAttributesName(attributeToFind: attribute);
                    string settingVal = HelperExifReadExifData.ReplaceBlankToponomy(
                        settingId: attribute,
                        settingValue: dtToponomy.Rows[index: 0][columnName: colName]
                                                .ToString());
                    toponomyOverwrites.Add(item: (attribute, settingVal));
                }

                // timeZone is a bit special but that's just how we all love it....not.
                string TZ = dtToponomy.Rows[index: 0][columnName: "timeZoneId"]
                                      .ToString();

                DateTime createDate;
                bool _ = DateTime.TryParse(s: lvi.SubItems[index: lvw_FileList
                                                                 .Columns[
                                                                      key: FileListView.COL_NAME_PREFIX +
                                                                           FileListView.FileListColumns
                                                                              .CREATE_DATE]
                                                                 .Index]
                                                 .Text.ToString(
                                                      provider: CultureInfo
                                                         .InvariantCulture),
                    result: out createDate);

                try
                {
                    string IANATZ = TZConvert.IanaToWindows(ianaTimeZoneName: TZ);
                    string TZOffset;
                    TimeZoneInfo tst = TimeZoneInfo.FindSystemTimeZoneById(id: IANATZ);

                    TZOffset = tst.GetUtcOffset(dateTime: createDate)
                                  .ToString()
                                  .Substring(startIndex: 0, length: tst
                                                                   .GetUtcOffset(dateTime: createDate)
                                                                   .ToString()
                                                                   .Length -
                                                                    3);
                    toponomyOverwrites.Add(
                        item: !TZOffset.StartsWith(value: NullStringEquivalentGeneric)
                            ? (ElementAttribute.OffsetTime, "+" + TZOffset)
                            : (ElementAttribute.OffsetTime, TZOffset));
                }
                catch
                {
                    // don't do anything.
                }

                foreach ((ElementAttribute attribute, string toponomyOverwriteVal)
                         toponomyDetail in toponomyOverwrites)
                {
                    dirElemFileToModify.SetAttributeValueAnyType(
                        attribute: toponomyDetail.attribute,
                        value: toponomyDetail.toponomyOverwriteVal,
                        version: DirectoryElement.AttributeVersion.Stage3ReadyToWrite,
                        isMarkedForDeletion: false);

                    lvi.SubItems[index: lvw_FileList
                                       .Columns[
                                            key: GetElementAttributesColumnHeader(
                                                attributeToFind:
                                                toponomyDetail.attribute)]
                                       .Index]
                       .Text = toponomyDetail.toponomyOverwriteVal;
                }

                if (lvi.Index % 10 == 0)
                {
                    Application.DoEvents();
                    // not adding the xmp here because the current code logic would pull a "unified" data point.                         

                    lvw_FileList.ScrollToDataPoint(itemText: fileNameWithoutPath);
                }

                HandlerUpdateLabelText(label: lbl_ParseProgress,
                    text: "Processing: " + fileNameWithoutPath);
                lvw_FileList.UpdateItemColour(itemText: fileNameWithoutPath,
                    color: Color.Red);
            }
            else
            {
                Dictionary<string, string> checkboxDictionary = new()
                {
                    {
                        HelperDataLanguageTZ.DataReadDTObjectText(
                            objectType: ControlType.CheckBox,
                            objectName: "ckb_QuestionStopProcessingRows"
                        ),
                        "_stopprocessing"
                    }
                };
                Dictionary<string, string> buttonsDictionary = new()
                {
                    {
                        HelperDataLanguageTZ.DataReadDTObjectText(
                            objectType: ControlType.Button,
                            objectName: "btn_Yes"
                        ),
                        "yes"
                    },
                    {
                        HelperDataLanguageTZ.DataReadDTObjectText(
                            objectType: ControlType.Button,
                            objectName: "btn_No"
                        ),
                        "no"
                    }
                };

                // ReSharper disable once InconsistentNaming
                List<string> APIHandlingChoice =
                    DialogWithOrWithoutCheckBox.DisplayAndReturnList(
                        labelText: GenericGetMessageBoxText(
                            messageBoxName: "mbx_FrmMainApp_QuestionNoRowsFromAPI"),
                        caption: GenericGetMessageBoxCaption(
                            captionType: MessageBoxCaption.Question.ToString()),
                        buttonsDictionary: buttonsDictionary,
                        orientation: "Horizontal",
                        checkboxesDictionary: checkboxDictionary);

                if (APIHandlingChoice.Contains(value: "yes"))
                {
                    List<(ElementAttribute attribute, string toponomyOverwriteVal)>
                        toponomyOverwrites = new();
                    toponomyOverwrites.Add(item: (ElementAttribute.CountryCode, null));
                    toponomyOverwrites.Add(item: (ElementAttribute.Country, null));

                    foreach (ElementAttribute attribute in
                             HelperGenericAncillaryListsArrays.ToponomyReplaces())
                    {
                        toponomyOverwrites.Add(item: (attribute, null));
                    }

                    foreach ((ElementAttribute attribute, string toponomyOverwriteVal)
                             toponomyDetail in toponomyOverwrites)
                    {
                        dirElemFileToModify.SetAttributeValueAnyType(
                            attribute: toponomyDetail.attribute,
                            value: toponomyDetail.toponomyOverwriteVal,
                            version: DirectoryElement.AttributeVersion.Stage3ReadyToWrite,
                            isMarkedForDeletion: false);

                        lvi.SubItems[index: lvw_FileList
                                           .Columns[
                                                key: GetElementAttributesColumnHeader(
                                                    attributeToFind: toponomyDetail
                                                       .attribute)]
                                           .Index]
                           .Text = toponomyDetail.toponomyOverwriteVal;
                    }
                }

                // nothing
                if (APIHandlingChoice.Contains(value: "_stopprocessing"))
                {
                    _StopProcessingRows = true;
                }
            }
        }
    }

    /// <summary>
    ///     Responsible for updating the main listview.
    ///     Also I've introduced a "Please Wait" Form to block the Main Form from being interacted with while the folder is
    ///     refreshing. Soz but needed.
    /// </summary>
    private void lvw_FileList_LoadOrUpdate()
    {
        Logger.Debug(message: "Starting");

        Logger.Trace(message: "Clear lvw_FileList");
        lvw_FileList.ClearData();
        // DirectoryElements.Clear();
        HelperVariables.LstTrackPath.Clear();
        Application.DoEvents();
        HelperGenericFileLocking.FilesBeingProcessed.Clear();
        RemoveGeoDataIsRunning = false;

    #region FrmPleaseWaitBox

        Logger.Trace(message: "Create FrmPleaseWaitBox");

        Form FrmPleaseWaitBox = new()
        {
            ControlBox = false,
            ShowInTaskbar = false,
            Size = new Size(width: 300, height: 40),
            Padding = new Padding(left: 4, top: 2, right: 2, bottom: 4),
            Text = HelperDataLanguageTZ.DataReadDTObjectText(
                objectType: ControlType.Form,
                objectName: "FrmPleaseWaitBox"
            ),
            StartPosition = FormStartPosition.CenterScreen
        };

        Logger.Trace(message: "Show FrmPleaseWaitBox");
        FrmPleaseWaitBox.Show();
        Logger.Trace(message: "Disable FrmMainApp");
        Enabled = false;

    #endregion

        // Clear Tables that keep track of the current folder...
        Logger.Trace(message: "Clear OriginalTakenDateDict and OriginalCreateDateDict");

        tbx_FolderName.Enabled = !Program.collectionModeEnabled;

        if (Program.collectionModeEnabled)
        {
            Logger.Trace(message: "FolderName: disabled - using collectionModeEnabled");
            tbx_FolderName.Text =
                @"** collectionMode enabled **"; // point here is that this doesn't exist and as such will block certain operations (like "go up one level"), which is what we want.

            // Load data (and add to DEs)
            DirectoryElements.ParseFolderOrFileListToDEs(
                folderOrCollectionFileName: Program.collectionFileLocation,
                statusMethod: delegate(string statusText)
                {
                    HandlerUpdateLabelText(label: lbl_ParseProgress,
                        text: statusText);
                },
                collectionModeEnabled: Program.collectionModeEnabled);
        }
        // not collectionModeEnabled
        else
        {
            tbx_FolderName.Enabled = true;

            Logger.Trace(message: "tbx_FolderName.Text: " + tbx_FolderName.Text);
            if (tbx_FolderName.Text != null)
            {
                // this shouldn't really happen but just in case
                Logger.Trace(message: "FolderName: " + FolderName);
                if (FolderName is null)
                {
                    if (!Directory.Exists(path: tbx_FolderName.Text))
                    {
                        tbx_FolderName.Text = @"C:\";
                    }

                    FolderName = tbx_FolderName.Text;
                    Logger.Trace(message: "FolderName [was null, now updated]: " +
                                          FolderName);
                }

                // Load data (and add to DEs)
                DirectoryElements.ParseFolderOrFileListToDEs(
                    folderOrCollectionFileName: FolderName,
                    statusMethod: delegate(string statusText)
                    {
                        HandlerUpdateLabelText(label: lbl_ParseProgress,
                            text: statusText);
                    },
                    collectionModeEnabled: Program.collectionModeEnabled);
            }
        }

        // Show Form
        lvw_FileList.ReloadFromDEs(directoryElements: DirectoryElements);

        HelperGenericFileLocking.FileListBeingUpdated = false;
        HandlerUpdateLabelText(label: lbl_ParseProgress, text: "Ready.");
        Logger.Trace(message: "Enable FrmMainApp");
        Enabled = true;
        Logger.Trace(message: "Hide PleaseWaitBox");
        FrmPleaseWaitBox.Hide();

        // Not logging this.
        FileListViewReadWrite.ListViewCountItemsWithGeoData();
    }

    /// <summary>
    ///     Handles the lvw_FileList_MouseDoubleClick event -> if user clicked on a folder then enter, if a file then edit
    ///     ... else warn and don't do anything.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void lvw_FileList_MouseDoubleClick(object sender,
        MouseEventArgs e)
    {
        Logger.Debug(message: "Starting");

        ListViewHitTestInfo info = lvw_FileList.HitTest(x: e.X, y: e.Y);
        ListViewItem item = info.Item;

        if (item == null)
        {
            lvw_FileList.SelectedItems.Clear();
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_WarningNoItemSelected"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Warning);
            customMessageBox.ShowDialog();
            return;
        }

        DirectoryElement directoryElement = (DirectoryElement)item.Tag;
        Logger.Trace(message: "item: " + item.Text);

        switch (directoryElement.Type)
        {
            // if .. (parent) then do a folder-up
            case DirectoryElement.ElementType.ParentDirectory:
                btn_OneFolderUp_Click(sender: sender, e: EventArgs.Empty);
                break;

            // if this is a folder or drive, enter
            case DirectoryElement.ElementType.SubDirectory:
            case DirectoryElement.ElementType.MyComputer:
            case DirectoryElement.ElementType.Drive:
                // check for outstanding files first and save if user wants
                HelperVariables.OperationChangeFolderIsOkay = false;
                await HelperFileSystemOperators
                   .FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: false);
                if (HelperVariables.OperationChangeFolderIsOkay)
                {
                    if (Directory.Exists(
                            path: Path.Combine(path1: tbx_FolderName.Text,
                                path2: item.Text)))
                    {
                        tbx_FolderName.Text =
                            Path.Combine(path1: tbx_FolderName.Text, path2: item.Text);
                    }
                    else
                    {
                        // itemText.Text here will be something like "C_Windows_320GB_M2_nVME (C:\)"
                        // so just extract whatever is in the parentheses
                        tbx_FolderName.Text = item.Text.Split('(')
                                                  .Last()
                                                  .Split(')')
                                                  .FirstOrDefault() +
                                              @"\";
                    }

                    btn_ts_Refresh_lvwFileList_Click(sender: this, e: EventArgs.Empty);
                }

                break;

            // Edit file
            case DirectoryElement.ElementType.File:
                Logger.Trace(message: "Trigger FrmEditFileData");
                filesToEditGUIDStringList.Clear();

                filesToEditGUIDStringList.Add(
                    item: directoryElement.GetAttributeValueString(
                        attribute: ElementAttribute.GUID,
                        version: DirectoryElement.AttributeVersion
                                                 .Original, // GUIDs don't change
                        notFoundValue: null, nowSavingExif: false));

                Logger.Trace(message: "Add File To lvw_FileListEditImages");
                EditFileFormGeneric.ShowFrmEditFileData();
                break;
        }
    }

    /// <summary>
    ///     Handles an update of map location and image preview based on selected file
    /// </summary>
    private async Task lvw_HandleSelectionChange()
    {
        if (lvw_FileList.FocusedItem != null)
        {
            FileListViewMapNavigation.ListViewItemClickNavigate();

            lvw_ExifData.Items.Clear();

            // it's easier to call the create-preview here than in the other one because focusedItems misbehave/I don't quite understand it/them
            // also we'll push the DE/Exif data into lvw_ExifData here.
            if (lvw_FileList.SelectedItems.Count > 0)
            {
                ListViewItem lvi = lvw_FileList.SelectedItems[index: 0];
                DirectoryElement dirElemFileToModify =
                    lvw_FileList.SelectedItems[index: 0].Tag as DirectoryElement;

                await UpdateLvwExifDataItems(directoryElement: dirElemFileToModify);
                string fileNameWithPath = dirElemFileToModify.FileNameWithPath;

                if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
                {
                    await HelperExifReadGetImagePreviews.GenericCreateImagePreview(
                        fileNameWithPath: fileNameWithPath, initiator: "FrmMainApp");
                }
                else
                {
                    pbx_imagePreview.Image = null;
                }
            }

            Request_Map_NavigateGo();
            // pbx_imagePreview.Image = null;
        }
    }

    private async Task UpdateLvwExifDataItems(DirectoryElement directoryElement)
    {
        // fill lvw_ExifData
        foreach (ElementAttribute attribute in (ElementAttribute[])Enum.GetValues(
                     enumType: typeof(ElementAttribute)))

        {
            List<ElementAttribute> attributesWithValidOrderIDs =
                Enum.GetValues(enumType: typeof(ElementAttribute))
                    .Cast<ElementAttribute>()
                    .Where(predicate: attribute =>
                         GetElementAttributesOrderID(
                             attributeToFind
                             : attribute) >
                         0)
                    .ToList();

            if (attributesWithValidOrderIDs.Contains(item: attribute))
            {
                ListViewItem lvi = new()
                {
                    Text = GetElementAttributesName(attributeToFind: attribute)
                };
                lvi.SubItems.Add(text: directoryElement.GetAttributeValueString(
                    attribute: attribute,
                    version: DirectoryElement.AttributeVersion.Original,
                    notFoundValue: null, nowSavingExif: false));
                lvi.SubItems.Add(text: directoryElement.GetAttributeValueString(
                    attribute: attribute,
                    version: DirectoryElement.AttributeVersion
                                             .Stage3ReadyToWrite,
                    notFoundValue: null, nowSavingExif: false));
                lvw_ExifData.Items.Add(value: lvi);
            }
        }

        foreach (ColumnHeader columnHeader in lvw_ExifData.Columns)
        {
            columnHeader.Width = -2;
        }
    }

    /// <summary>
    ///     Technically same as lvw_FileList_KeyDown but movement is a bit b...chy with "Down".
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void lvw_FileList_KeyUp(object sender,
        KeyEventArgs e)
    {
        if (
            e.KeyCode == Keys.PageUp ||
            e.KeyCode == Keys.PageDown ||
            e.KeyCode == Keys.Up ||
            e.KeyCode == Keys.Down ||
            e.KeyCode == Keys.Home ||
            e.KeyCode == Keys.End
        )
        {
            await lvw_HandleSelectionChange();
        }
    }

    /// <summary>
    ///     Handles the various keypress combinations. See inline comments for details.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">The key pressed</param>
    private async void lvw_FileList_KeyDown(object sender,
        KeyEventArgs e)
    {
        // control A -> select all
        if (e.Modifiers == Keys.Control &&
            e.KeyCode == Keys.A)
        {
            HelperVariables.OperationNowSelectingAllItems = true;

            for (int i = 0; i < lvw_FileList.Items.Count; i++)
            {
                lvw_FileList.Items[index: i]
                            .Selected = true;
                // so because there is no way to do a proper "select all" w/o looping i only want to run the "navigate" (which is triggered on select-state-change at the end)
                if (i == lvw_FileList.Items.Count - 1)
                {
                    HelperVariables.OperationNowSelectingAllItems = false;
                    FileListViewMapNavigation.ListViewItemClickNavigate();
                    Request_Map_NavigateGo();
                }
            }

            // just in case...
            HelperVariables.OperationNowSelectingAllItems = false;
        }

        // Shift Ctrl C -> copy details
        else if (e.Control &&
                 e.Shift &&
                 e.KeyCode == Keys.C)
        {
            FileListViewCopyPaste.ListViewCopyGeoData();
        }

        // Shift Ctrl V -> paste details
        else if (e.Control &&
                 e.Shift &&
                 e.KeyCode == Keys.V)
        {
            FileListViewCopyPaste.ListViewPasteGeoData();
        }

        // Ctrl Enter -> Edit File
        else if (e.Modifiers == Keys.Control &&
                 e.KeyCode == Keys.Enter)
        {
            filesToEditGUIDStringList.Clear();

            ListView lvw = lvw_FileList;
            foreach (ListViewItem lvi in lvw.SelectedItems)
            {
                DirectoryElement directoryElement =
                    lvi.Tag as DirectoryElement;

                filesToEditGUIDStringList.Add(
                    item: directoryElement.GetAttributeValueString(
                        attribute: ElementAttribute.GUID,
                        version: DirectoryElement.AttributeVersion
                                                 .Original, // GUIDs don't change
                        notFoundValue: null, nowSavingExif: false));
            }

            EditFileFormGeneric.ShowFrmEditFileData();
        }

        // Backspace -> Up one folder
        else if (e.KeyCode == Keys.Back)
        {
            btn_OneFolderUp_Click(sender: sender, e: EventArgs.Empty);
        }

        // Enter  -> enter if folder / drive
        else if (e.KeyCode == Keys.Enter)
        {
            if (lvw_FileList.SelectedItems.Count == 1)
            {
                ListViewItem lvi = lvw_FileList.SelectedItems[index: 0];
                DirectoryElement dirElemFileToModify =
                    lvi.Tag as DirectoryElement;

                // if .. (parent) then do a folder-up
                if (dirElemFileToModify.Type ==
                    DirectoryElement.ElementType.ParentDirectory)
                {
                    btn_OneFolderUp_Click(sender: sender, e: EventArgs.Empty);
                }
                // if this is a folder or drive, enter
                else if (dirElemFileToModify.Type ==
                         DirectoryElement.ElementType.SubDirectory)
                {
                    // check for outstanding files first and save if user wants
                    HelperVariables.OperationChangeFolderIsOkay = false;
                    await HelperFileSystemOperators
                       .FsoCheckOutstandingFileDataOkayToChangeFolderAsync(isTheAppClosing: false);
                    if (HelperVariables.OperationChangeFolderIsOkay)
                    {
                        if (Directory.Exists(path: dirElemFileToModify.FileNameWithPath))
                        {
                            tbx_FolderName.Text = dirElemFileToModify.FileNameWithPath;
                        }

                        btn_ts_Refresh_lvwFileList_Click(
                            sender: this, e: EventArgs.Empty);
                    }
                }
            }
        }

        // F5 -> Refresh folder
        else if (e.KeyCode == Keys.F5)
        {
            tsb_Refresh_lvwFileList_Click(sender: sender, e: EventArgs.Empty);
            e.Handled = true;
        }

        // Control S -> Save files
        else if (e.Control &&
                 e.KeyCode == Keys.S)
        {
            while (HelperGenericFileLocking.FileListBeingUpdated ||
                   HelperGenericFileLocking.FilesAreBeingSaved)
            {
                await Task.Delay(millisecondsDelay: 10);
            }

            // i think having an Item active can cause a lock on it
            lvw_FileList.SelectedItems.Clear();

            await HelperExifWriteSaveToFile.ExifWriteExifToFile();
            HelperGenericFileLocking.FilesAreBeingSaved = false;
            //DtFileDataToWriteStage3ReadyToWrite.Rows.Clear();
        }
    }


    /// <summary>
    ///     Watches for the user to lift the mouse button while over the listview. This will trigger the collection of
    ///     coordinates and map them.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private async void lvw_FileList_MouseUp(object sender,
        MouseEventArgs e)
    {
        await lvw_HandleSelectionChange();
    }


    /// <summary>
    ///     Handles the tmi_Settings_Settings_Click event -> brings up the Settings Form
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_Settings_Settings_Click(object sender,
        EventArgs e)
    {
        FrmSettings = new FrmSettings();
        FrmSettings.Text = HelperDataLanguageTZ.DataReadDTObjectText(
            objectType: ControlType.Form,
            objectName: "FrmSettings"
        );
        FrmSettings.ShowDialog();
    }

    /// <summary>
    ///     Brings up the Manage Favourites Form
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_Settings_Favourites_Click(object sender,
        EventArgs e)
    {
        DtFavourites = HelperGenericAppStartup.AppStartupLoadFavourites();
        if (DtFavourites.Rows.Count > 0)
        {
            FrmManageFavourites frmManageFavouritesInstance = new();
            frmManageFavouritesInstance.ShowDialog();
        }
        else
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_NoFavouritesDefined"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Information);
            customMessageBox.ShowDialog();
        }
    }

    /// <summary>
    ///     Handles the tmi_Help_About_Click event -> brings up the About Form
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void tmi_Help_About_Click(object sender,
        EventArgs e)
    {
        FrmAboutBox frmAboutBox = new();
        frmAboutBox.ShowDialog();
    }

    private void tmi_Help_FeedbackFeatureRequest_Click(object sender,
        EventArgs e)
    {
        Process.Start(
            fileName:
            "https://github.com/nemethviktor/GeoTagNinja/issues/new?template=feature_request.md");
    }

    private void tmi_Help_BugReport_Click(object sender,
        EventArgs e)
    {
        Process.Start(
            fileName:
            "https://github.com/nemethviktor/GeoTagNinja/issues/new?template=bug_report.md");
    }


    private void tsb_FeedbackFeatureRequest_Click(object sender,
        EventArgs e)
    {
        Process.Start(
            fileName:
            "https://github.com/nemethviktor/GeoTagNinja/issues/new?template=feature_request.md");
    }

    private void tsb_BugReport_Click(object sender,
        EventArgs e)
    {
        Process.Start(
            fileName:
            "https://github.com/nemethviktor/GeoTagNinja/issues/new?template=bug_report.md");
    }

    /// <summary>
    ///     Updates the Text of any Label from outside the thread.
    /// </summary>
    /// <param name="label">The Label Control that needs updating</param>
    /// <param name="text">The Text that will be assigned</param>
    internal static void HandlerUpdateLabelText(Label label,
        string text)
    {
        // If the current thread is not the UI thread, InvokeRequired will be true
        if (label.InvokeRequired)
        {
            // If so, call Invoke, passing it a lambda expression which calls
            // UpdateText with the same label and text, but on the UI thread instead.
            label.Invoke(method: (Action)(() =>
                HandlerUpdateLabelText(label: label, text: text)));
            return;
        }

        // If we're running on the UI thread, we'll get here, and can safely update 
        // the label's text.
        label.Text = text;
        label.Refresh();
    }


    /// <summary>
    ///     This is a dummy. It's here to help me find where things go wrong when clicked on the map. Doesn't do anything.
    /// </summary>
    /// <param name="sender">Unused</param>
    /// <param name="e">Unused</param>
    private void wbv_MapArea_Click(object sender,
        EventArgs e)
    {
        // note to self: the one you're looking for is called wbv_MapArea_WebMessageReceived
    }

    private void FrmMainApp_ResizeBegin(object sender,
        EventArgs e)
    {
        wbv_MapArea.Hide();
    }

    private void FrmMainApp_ResizeEnd(object sender,
        EventArgs e)
    {
        wbv_MapArea.Show();
    }

    private void selectColumnsToolStripMenuItem_Click(object sender,
        EventArgs e)
    {
        lvw_FileList.ShowColumnSelectionDialog();
    }

    private void btn_SaveLocation_Click(object sender,
        EventArgs e)
    {
        if (cbx_Favourites.Text.Length > 0)
        {
            ListView lvw = lvw_FileList;
            if (lvw_FileList.SelectedItems.Count > 0)
            {
                ListViewItem lvi = lvw_FileList.SelectedItems[index: 0];

                string favouriteName = cbx_Favourites.Text;

                DataTable dtFavourite =
                    HelperDataFavourites.DataReadSQLiteFavourites(structureOnly: true);
                dtFavourite.Clear();
                DataRow drFavourite = dtFavourite.NewRow();
                drFavourite[columnName: "favouriteName"] = favouriteName;

                foreach (ElementAttribute attribute in HelperGenericAncillaryListsArrays
                            .GetFavouriteTags())
                {
                    string colName = GetElementAttributesName(attributeToFind: attribute);
                    string addStr = lvi.SubItems[
                                            index: lvw
                                                  .Columns[
                                                       key:
                                                       GetElementAttributesColumnHeader(
                                                           attributeToFind: attribute)]
                                                  .Index]
                                       .Text.ToString(
                                            provider: CultureInfo.InvariantCulture);

                    if (addStr == NullStringEquivalentGeneric)
                    {
                        addStr = "";
                    }

                    drFavourite[columnName: colName] = addStr;
                }

                HelperDataFavourites.DataDeleteSQLiteFavourite(
                    favouriteName: favouriteName);
                HelperDataFavourites.DataWriteSQLiteAddNewFavourite(
                    drFavourite: drFavourite);

                DtFavourites = HelperGenericAppStartup.AppStartupLoadFavourites();
                CustomMessageBox customMessageBox = new(
                    text: GenericGetMessageBoxText(
                        messageBoxName: "mbx_FrmMainApp_InfoFavouriteSaved"),
                    caption: GenericGetMessageBoxCaption(
                        captionType: MessageBoxCaption.Information.ToString()),
                    buttons: MessageBoxButtons.OK,
                    icon: MessageBoxIcon.Information);
                customMessageBox.ShowDialog();
            }

            else
            {
                CustomMessageBox customMessageBox = new(
                    text: GenericGetMessageBoxText(
                        messageBoxName: "mbx_FrmMainApp_WarningNoItemSelected"),
                    caption: GenericGetMessageBoxCaption(
                        captionType: MessageBoxCaption.Information.ToString()),
                    buttons: MessageBoxButtons.OK,
                    icon: MessageBoxIcon.Warning);
                customMessageBox.ShowDialog();
            }
        }
        else
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_InfoFavouriteNameCannotBeBlank"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Warning);
            customMessageBox.ShowDialog();
        }
    }

    private async void btn_LoadFavourite_Click(object sender,
        EventArgs e)
    {
        string favouriteToLoad = cbx_Favourites.Text;

        // pull favs (this needs doing each time as user may have changed it)

        DtFavourites = HelperGenericAppStartup.AppStartupLoadFavourites();

        if (LstFavourites.Contains(item: favouriteToLoad))
        {
            EnumerableRowCollection<DataRow> drDataTableData =
                from DataRow dataRow in DtFavourites.AsEnumerable()
                where dataRow.Field<string>(columnName: "favouriteName") ==
                      favouriteToLoad
                select dataRow;

            DataRow drFavouriteData = drDataTableData.FirstOrDefault();

            bool filesAreSelected = false;
            if (lvw_FileList.SelectedItems.Count > 0)
            {
                foreach (ListViewItem lvi in lvw_FileList.SelectedItems)
                {
                    DirectoryElement dirElemFileToModify =
                        lvi.Tag as DirectoryElement;
                    if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
                    {
                        filesAreSelected = true;
                        break;
                    }
                }
            }

            if (filesAreSelected && drFavouriteData != null)
            {
                foreach (ListViewItem lvi in lvw_FileList.SelectedItems)
                {
                    DirectoryElement dirElemFileToModify =
                        lvi.Tag as DirectoryElement;
                    if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
                    {
                        foreach (ElementAttribute attribute in
                                 HelperGenericAncillaryListsArrays.GetFavouriteTags())
                        {
                            string colName =
                                GetElementAttributesName(attributeToFind: attribute);
                            string settingValue = drFavouriteData[columnName: colName]
                               .ToString();

                            dirElemFileToModify.SetAttributeValueAnyType(
                                attribute: attribute,
                                value: settingValue,
                                version: DirectoryElement.AttributeVersion
                                                         .Stage3ReadyToWrite,
                                isMarkedForDeletion: false);
                        }

                        await FileListViewReadWrite
                           .ListViewUpdateRowFromDEStage3ReadyToWrite(lvi: lvi);
                    }
                }
            }

            else
            {
                CustomMessageBox customMessageBox = new(
                    text: GenericGetMessageBoxText(
                        messageBoxName: "mbx_FrmMainApp_WarningNoItemSelected"),
                    caption: GenericGetMessageBoxCaption(
                        captionType: MessageBoxCaption.Information.ToString()),
                    buttons: MessageBoxButtons.OK,
                    icon: MessageBoxIcon.Warning);
                customMessageBox.ShowDialog();
            }
        }
        else
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_InfoFavouriteNotValid"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Information);
            customMessageBox.ShowDialog();
        }
    }

    /// <summary>
    ///     Clears cached data for any selected items if there is any to clear
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void cmi_removeCachedData_Click(object sender,
        EventArgs e)
    {
        bool dataHasBeenRemoved = false;
        foreach (ListViewItem lvi in lvw_FileList.SelectedItems)
        {
            try
            {
                string lat = lvi.SubItems[index: lvw_FileList
                                                .Columns[
                                                     key: FileListView.COL_NAME_PREFIX +
                                                          FileListView.FileListColumns.GPS_LATITUDE]
                                                .Index]
                                .Text;
                string lng = lvi.SubItems[index: lvw_FileList
                                                .Columns[
                                                     key: FileListView.COL_NAME_PREFIX +
                                                          FileListView.FileListColumns.GPS_LONGITUDE]
                                                .Index]
                                .Text;

                for (int i = DtToponomySessionData.Rows.Count - 1; i >= 0; i--)
                {
                    DataRow dr = DtToponomySessionData.Rows[index: i];
                    if (dr[columnName: "lat"]
                           .ToString() ==
                        lat &&
                        dr[columnName: "lng"]
                           .ToString() ==
                        lng)
                    {
                        dr.Delete();
                    }

                    dataHasBeenRemoved = true;
                }

                DtToponomySessionData.AcceptChanges();
            }
            catch
            {
                // nothing
            }
        }

        if (dataHasBeenRemoved)
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_InfoCahcedDataRemoved"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Information);
            customMessageBox.ShowDialog();
        }
        else
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_InfoCahcedDataNotRemoved"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Information);
            customMessageBox.ShowDialog();
        }
    }

    private void cbx_Favourites_SelectedValueChanged(object sender,
        EventArgs e)
    {
        string favouriteToLoad = cbx_Favourites.Text;

        // pull favs (this needs doing each time as user may have changed it)
        DtFavourites =
            HelperGenericAppStartup.AppStartupLoadFavourites(clearDropDown: false);
        cbx_Favourites.Text = favouriteToLoad;
        if (LstFavourites.Contains(item: favouriteToLoad))
        {
            EnumerableRowCollection<DataRow> drDataTableData =
                from DataRow dataRow in DtFavourites.AsEnumerable()
                where dataRow.Field<string>(columnName: "favouriteName") ==
                      favouriteToLoad
                select dataRow;

            DataRow drFavouriteData = drDataTableData.FirstOrDefault();

            if (drFavouriteData != null)
            {
                double favLat = double.Parse(s: drFavouriteData[columnName: "GPSLatitude"]
                       .ToString(),
                    provider: CultureInfo.InvariantCulture);
                double favLng = double.Parse(
                    s: drFavouriteData[columnName: "GPSLongitude"]
                       .ToString(), provider: CultureInfo.InvariantCulture);

                // this may be redundant but lazy to check
                char favLatRef = drFavouriteData[columnName: "GPSLatitudeRef"]
                   .ToString()[index: 0];
                char favLngRef = drFavouriteData[columnName: "GPSLongitudeRef"]
                   .ToString()[index: 0];

                if (favLatRef == 'S')
                {
                    favLat = Math.Abs(value: favLat) * -1;
                }

                if (favLngRef == 'W')
                {
                    favLng = Math.Abs(value: favLng) * -1;
                }

                nud_lat.Text = favLat.ToString(provider: CultureInfo.InvariantCulture);
                nud_lng.Text = favLng.ToString(provider: CultureInfo.InvariantCulture);

                nud_lat.Value =
                    Convert.ToDecimal(value: favLat,
                        provider: CultureInfo.InvariantCulture);
                nud_lng.Value =
                    Convert.ToDecimal(value: favLng,
                        provider: CultureInfo.InvariantCulture);

                btn_NavigateMapGo_Click(sender: null, e: null);
            }
        }
    }

    /// <summary>
    ///     Manages favourites
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    private void btn_ManageFavourites_Click(object sender,
        EventArgs e)
    {
        DtFavourites = HelperGenericAppStartup.AppStartupLoadFavourites();
        if (DtFavourites.Rows.Count > 0)
        {
            FrmManageFavourites frmManageFavouritesInstance = new();
            frmManageFavouritesInstance.ShowDialog();
        }
        else
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_NoFavouritesDefined"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Information.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Information);
            customMessageBox.ShowDialog();
        }
    }


    private void cmi_OpenCoordsInAPI_Click(object sender,
        EventArgs e)
    {
        bool selectionIsValid = false;
        string GPSLatStr = NullStringEquivalentGeneric;
        string GPSLngStr = NullStringEquivalentGeneric;
        ListView lvw = lvw_FileList;

        if (lvw.SelectedItems.Count == 1)
        {
            ListViewItem lvi = lvw_FileList.SelectedItems[index: 0];
            DirectoryElement dirElemFileToModify =
                lvi.Tag as DirectoryElement;
            if (dirElemFileToModify.Type == DirectoryElement.ElementType.File)
            {
                try
                {
                    GPSLatStr =
                        dirElemFileToModify.GetAttributeValueString(
                            attribute: ElementAttribute.GPSLatitude);
                    GPSLngStr =
                        dirElemFileToModify.GetAttributeValueString(
                            attribute: ElementAttribute.GPSLongitude);
                    selectionIsValid = true;
                }
                catch
                {
                    // nothing
                }
            }
        }

        if (!selectionIsValid)
        {
            CustomMessageBox customMessageBox = new(
                text: GenericGetMessageBoxText(
                    messageBoxName: "mbx_FrmMainApp_WarningTooManyFilesSelected"),
                caption: GenericGetMessageBoxCaption(
                    captionType: MessageBoxCaption.Warning.ToString()),
                buttons: MessageBoxButtons.OK,
                icon: MessageBoxIcon.Warning);
            customMessageBox.ShowDialog();
        }
        else
        {
            CultureInfo cIEnUS = new(name: "en-US");
            string SOnlyShowFCodePPL = HelperVariables.UserSettingOnlyShowFCodePPL
                ? "&fcode=PPL"
                : "";
            string openAPILink =
                "http://api.geonames.org/findNearbyPlaceNameJSON?formatted=true&lat=" +
                GPSLatStr +
                "&lng=" +
                GPSLngStr +
                "&lang=" +
                HelperVariables.APILanguageToUse +
                SOnlyShowFCodePPL +
                "&style=FULL" +
                "&radius=" +
                HelperVariables.ToponomyRadiusValue +
                "&maxRows=" +
                HelperVariables.ToponymaxRows +
                "&username=" +
                HelperVariables.UserSettingGeoNamesUserName +
                "&password=any";
            Process.Start(fileName: openAPILink);
        }
    }

    private void lvw_ExifData_KeyUp(object sender,
        KeyEventArgs e)
    {
        // unused
    }

    private void lvw_ExifData_KeyDown(object sender,
        KeyEventArgs e)
    {
        if (e.Control &&
            e.KeyCode == Keys.C)
        {
            CopySelectedValuesToClipboard();
        }

        void CopySelectedValuesToClipboard()
        {
            StringBuilder builder = new();
            foreach (ListViewItem lvi in lvw_ExifData.SelectedItems)
            {
                for (int i = 0; i < lvi.SubItems.Count; i++)
                {
                    builder.AppendLine(value: lvi.SubItems[index: i].Text);
                }
            }

            Clipboard.SetText(text: builder.ToString());
        }
    }
}

#endregion

public static class ControlExtensions
{
    /// <summary>
    ///     Makes sure the Control in question gets doubleBufferPropertyInfo enabled/disabled.
    ///     ...Realistically we're using this to assign doubleBufferPropertyInfo = enabled to the main listView.
    ///     ...This helps stop the flickering on updating the various data points and/or rows (Items).
    ///     Also I can't seem to move this off to HelperControlAndMessageBoxHandling
    /// </summary>
    /// <param name="control">The Control that needs the value assigned</param>
    /// <param name="enable">Bool true or false (aka on or off)</param>
    public static void DoubleBuffered(this Control control,
        bool enable)
    {
        PropertyInfo doubleBufferPropertyInfo = control.GetType()
                                                       .GetProperty(
                                                            name: "DoubleBuffered",
                                                            bindingAttr: BindingFlags
                                                                            .Instance |
                                                                         BindingFlags.NonPublic);
        doubleBufferPropertyInfo.SetValue(obj: control, value: enable, index: null);
    }
}