ExportForm.cs

using System;
using System.IO;
using System.Threading;
using Eto.Drawing;
using Eto.Forms;

namespace devtime
{
    public class ExportForm : Dialog<DialogResult>
    {
        private readonly string _outputFile;
        private readonly string _context;
        private readonly string _from;
        private readonly string _to;
        private readonly Exporter.ExportFormat _exportFormat;
        private readonly bool _exportDate;
        private readonly bool _exportTime;
        private readonly bool _exportLog;
        private readonly Exporter.TimeFormat _timeFormat;
        private readonly Exporter.TimeApproximation _timeApproximation;

        private readonly ProgressBar _progressBar;
        private Thread? _exporterThread;
        private volatile bool _exporterShouldRun = true;
        private DialogResult _result = DialogResult.Cancel;

        public ExportForm(string outputFile, string context, string from, string to, Exporter.ExportFormat exportFormat, bool exportDate, bool exportTime, bool exportLog, Exporter.TimeFormat timeFormat, Exporter.TimeApproximation timeApproximation)
        {
            Title = "Exporting...";
            Icon = IconLoader.LoadIcon("export.png");
            Resizable = false;

            _outputFile = outputFile;
            _context = context;
            _from = from;
            _to = to;
            _exportFormat = exportFormat;
            _exportDate = exportDate;
            _exportTime = exportTime;
            _exportLog = exportLog;
            _timeFormat = timeFormat;
            _timeApproximation = timeApproximation;

            _progressBar = new ProgressBar { MinValue = 0, MaxValue = 100, Value = 0 };

            Content = new StackLayout
            {
                Padding = new Padding(15, 10),
                Spacing = 5,
                HorizontalContentAlignment = HorizontalAlignment.Stretch,
                Items =
                {
                    new Label { Text = "Exporting data..." },
                    _progressBar
                }
            };

            Shown += (s, e) =>
            {
                _exporterThread = new Thread(ExportWork);
                _exporterThread.Start();
            };

            Closing += (s, e) =>
            {
                if (_exporterThread != null && _exporterThread.IsAlive)
                {
                    _exporterShouldRun = false;
                    _exporterThread.Join();
                }
            };
        }

        private void ExportWork()
        {
            try
            {
                using (StreamWriter output = new StreamWriter(_outputFile))
                {
                    Exporter? exporter = null;
                    switch (_exportFormat)
                    {
                        case Exporter.ExportFormat.CSV:
                            exporter = new CsvExporter(output, _exportDate, _exportTime, _exportLog, _timeFormat, _timeApproximation);
                            break;
                        case Exporter.ExportFormat.JSON:
                            exporter = new JsonExporter(output, _exportDate, _exportTime, _exportLog, _timeFormat, _timeApproximation);
                            break;
                    }

                    if (exporter == null) return;

                    long totalEntries = DB.SelectTotalEntryCount(_context, _from, _to);
                    long bufferSize = Config.DatabaseExportBufferSize;
                    if (bufferSize <= 0) bufferSize = 30; // fallback
                    long iterations = totalEntries / bufferSize + (totalEntries % bufferSize > 0 ? 1 : 0);

                    Application.Instance.Invoke(() =>
                    {
                        _progressBar.MaxValue = (int)Math.Max(1, iterations);
                    });

                    exporter.ExportStart();

                    bool first = true;
                    for (long i = 0; i < iterations && _exporterShouldRun; ++i)
                    {
                        var entries = DB.SelectEntries(_context, _from, _to, (int)bufferSize, (int)(i * bufferSize));
                        for (int j = 0; j < entries.Count && _exporterShouldRun; ++j)
                        {
                            if (!first)
                            {
                                exporter.ExportMid();
                            }
                            first = false;

                            var entry = entries[j];
                            exporter.ExportEntry(entry.Date, entry.LoggedTime, entry.Log ?? "");
                        }

                        Application.Instance.Invoke(() =>
                        {
                            _progressBar.Value = (int)i + 1;
                        });
                    }

                    exporter.ExportEnd();

                    if (_exporterShouldRun)
                    {
                        _result = totalEntries > 0 ? DialogResult.Ok : DialogResult.Retry;
                    }
                }
            }
            catch (Exception ex)
            {
                Application.Instance.Invoke(() =>
                {
                    MessageBox.Show(this, $"Failed to export data.\n\n{ex.Message}", "devtime error", MessageBoxButtons.OK, MessageBoxType.Error);
                });
            }

            Application.Instance.AsyncInvoke(() =>
            {
                Close(_result);
            });
        }
    }
}