private void DoPerformSync()                                      // in Background worker
        {
            InvokeAsyncOnUiThread.Invoke(() => OnSyncStarting?.Invoke()); // tell listeners sync is starting

            resyncEDSMEDDBRequestedFlag = 1;                              // sync is happening, stop any async requests..

            Debug.WriteLine(BaseUtils.AppTicks.TickCountLap() + " Perform EDSM/EDDB sync");

            try
            {
                bool[] grids = new bool[GridId.MaxGridID];
                foreach (int i in GridId.FromString(EDDConfig.Instance.EDSMGridIDs))
                {
                    grids[i] = true;
                }

                syncstate.ClearCounters();

                if (syncstate.perform_edsm_fullsync || syncstate.perform_eddb_edsmalias_sync)
                {
                    if (syncstate.perform_edsm_fullsync && !PendingClose)
                    {
                        // Download new systems
                        try
                        {
                            string edsmsystems = Path.Combine(EliteConfigInstance.InstanceOptions.AppDataDirectory, "edsmsystems.json");

                            ReportSyncProgress("Performing full download of EDSM Database from server");

                            bool success = BaseUtils.DownloadFile.HTTPDownloadFile(EliteConfigInstance.InstanceConfig.EDSMFullSystemsURL, edsmsystems, false, out bool newfile);

                            syncstate.perform_edsm_fullsync = false;

                            if (success)
                            {
                                syncstate.edsm_fullsync_count = SQLiteConnectionSystem.UpgradeSystemTableFromFile(edsmsystems, grids, () => PendingClose, ReportSyncProgress);

                                if (syncstate.edsm_fullsync_count < 0)     // this should always update something, the table is replaced.  If its not, its been cancelled
                                {
                                    return;
                                }

                                BaseUtils.FileHelpers.DeleteFileNoError(edsmsystems);       // remove file - don't hold in storage
                            }
                        }
                        catch (Exception ex)
                        {
                            LogLineHighlight("GetAllEDSMSystems exception:" + ex.Message);
                        }
                    }

                    if (!PendingClose)
                    {
                        try
                        {
                            EDSMClass edsm       = new EDSMClass();
                            string    jsonhidden = edsm.GetHiddenSystems();

                            if (jsonhidden != null)
                            {
                                SystemsDB.ParseAliasString(jsonhidden);

                                string eddbsystems = Path.Combine(EliteConfigInstance.InstanceOptions.AppDataDirectory, "eddbsystems.json");

                                bool success = BaseUtils.DownloadFile.HTTPDownloadFile(EliteConfigInstance.InstanceConfig.EDDBSystemsURL, eddbsystems, false, out bool newfile);

                                syncstate.perform_eddb_edsmalias_sync = false;

                                if (success)
                                {
                                    syncstate.eddb_sync_count = SystemsDB.ParseEDDBJSONFile(eddbsystems, () => PendingClose);

                                    if (syncstate.eddb_sync_count < 0)      // on a cancel or error
                                    {
                                        return;
                                    }

                                    SQLiteConnectionSystem.SetLastEDDBDownloadTime();

                                    BaseUtils.FileHelpers.DeleteFileNoError(eddbsystems);       // remove file - don't hold in storage
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            LogLineHighlight("GetEDDBUpdate exception: " + ex.Message);
                        }
                    }
                }

                if (!PendingClose)
                {
                    syncstate.edsm_updatesync_count = UpdateSync(grids, () => PendingClose, ReportSyncProgress);
                }
            }
            catch (OperationCanceledException)
            {
                // Swallow Operation Cancelled exceptions
            }
            catch (Exception ex)
            {
                LogLineHighlight("Check Systems exception: " + ex.Message + Environment.NewLine + "Trace: " + ex.StackTrace);
            }

            InvokeAsyncOnUiThread(() => PerformSyncCompletedonUI());
        }