private DateTime _mostRecentTime;

        public DateTime MostRecentTime { get => _mostRecentTime; private set => this.RaiseAndSetIfChanged(ref _mostRecentTime, value); }

        private GeneratorRecipe? _mostRecentRecipe;

        public GeneratorRecipe? MostRecentRecipe { get => _mostRecentRecipe; private set => this.RaiseAndSetIfChanged(ref _mostRecentRecipe, value); }

        private int _productIndex = 0;

        public int ProductIndex { get => _productIndex; private set => this.RaiseAndSetIfChanged(ref _productIndex, value); }

        private int _maxReagents;

        public int MaxReagents { get => _maxReagents; private set => this.RaiseAndSetIfChanged(ref _maxReagents, value); }

        private int _maxConcentration;

        public int MaxConcentration { get => _maxConcentration; private set => this.RaiseAndSetIfChanged(ref _maxConcentration, value); }

        private int _fullQuantity;

        public int FullQuantity { get => _fullQuantity; private set => this.RaiseAndSetIfChanged(ref _fullQuantity, value); }

        private int _fullQuantityDepth;

        public int FullQuantityDepth { get => _fullQuantityDepth; private set => this.RaiseAndSetIfChanged(ref _fullQuantityDepth, value); }

        private int _maxConcentrationMax;

        public int MaxConcentrationMax { get => _maxConcentrationMax; private set => this.RaiseAndSetIfChanged(ref _maxConcentrationMax, value); }

        private int _fullQuantitynMax;

        public int FullQuantityMax { get => _fullQuantitynMax; private set => this.RaiseAndSetIfChanged(ref _fullQuantitynMax, value); }

        #region Flags

        private bool _isPaused = false;

        public bool IsPaused  { get => _isPaused; private set => this.RaiseAndSetIfChanged(ref _isPaused, value); }

        private bool _isInProgress = false;

        public bool IsInProgress { get => _isInProgress; private set => this.RaiseAndSetIfChanged(ref _isInProgress, value); }

        private bool _isRunning = false;

        public bool IsRunning {  get => _isRunning; private set => this.RaiseAndSetIfChanged(ref _isRunning, value); }

        private bool _canStart = false;

        public bool CanStart {  get => _canStart; private set => this.RaiseAndSetIfChanged(ref _canStart, value); }

        private bool _canClear = false;

        public bool CanClear {  get => _canClear; private set => this.RaiseAndSetIfChanged(ref _canClear, value); }

        #endregion // Flags

        #region Collections

        public ObservableCollection<Reagent> Reagents { get; } = new();

        public ObservableCollection<GeneratorRecipe> AllRecipes { get; } = new();

        #endregion // Collections

        private readonly RecipeGenerator _generator;

        private DateTime _lastSave = DateTime.Now;

        private readonly PlayerProfile _profile;

        private uint _minConcentration;

        private readonly ConcurrentQueue<PaintRecipe> _pendingNewRecipes = new();

        private volatile int _newRecipeCount;

        private volatile bool _updatesAvailable;

        private readonly DispatcherTimer _updateTimer;

        private bool _ribbonMode;

        private bool _unsavedRecipes;

        private bool _saving;

        public RecipeGeneratorViewModel()

        {

            List<string> reagentNames = ReagentService.Names;

            foreach (string name in reagentNames)

            {

                Reagents.Add(ReagentService.GetReagent(name));

            }

            SettingsService.Get("Generator.RibbonMode", out bool ribbonMode, false);

            ProductIndex = ribbonMode ? 1 : 0;

            _ribbonMode = ribbonMode;

            PlayerProfile? profile = ProfileManager.CurrentProfile;

            Debug.Assert(profile != null);

            _profile = profile;

            _profile.LoadRecipes();

            _generator = new RecipeGenerator();

            _generator.Progress  += OnProgress;

            _generator.NewRecipe += OnNewRecipe;

            _generator.Finished  += OnGeneratorStopped;

            if (ribbonMode)

            {

                InitStateForRibbons();

            }

            else

            {

                InitStateForPaint();

            }

            _updateTimer = new DispatcherTimer {Interval = TimeSpan.FromMilliseconds(UpdateInterval)};

            _updateTimer.Tick += Update;

            this.WhenAnyValue(x => x.ProductIndex).Subscribe(_ => ChangeMode());

        }

        public void Start()

        {

            IsInProgress = true;

            IsRunning = true;

            ReagentService.SaveProfileReagents(_profile.ReagentFile);

            SaveSettings(_ribbonMode ? "Ribbon" : "Paint");

            _updateTimer.Start();

            SelectedView = 1;

            _generator.CloseLog();

            SettingsService.Get("Generator.Logging", out bool logGenerator, false);

            if (logGenerator)

            {

                string logDir = DesertPaintCodex.Util.FileUtils.AppDataPath;

                _generator.Log = System.IO.Path.Combine(logDir, "recipe_generator_log.txt");

            }

            _generator.BeginRecipeGeneration(

                _minConcentration, 

                (uint)MaxConcentration, 

                1, 

                (uint)MaxReagents, 

                (uint)FullQuantityDepth, 

                (uint)FullQuantity);

        }

        public void End()

        {

            IsPaused     = false;

            IsRunning    = false;

            IsInProgress = false;

            _updateTimer.Stop();

            _profile.SaveRecipes();

            _generator.ResetQueue();

            SaveState();

            CanClear = true;

        }

        public void Pause()

        {

            IsPaused  = true;

            IsRunning = false;

            _updateTimer.Stop();

            _generator.Stop();

        }

        public void Resume()

        {

            IsPaused  = false;

            IsRunning = true;

            _updateTimer.Start();

            SelectedView = 1;

            _generator.CloseLog();

            SettingsService.Get("Generator.Logging", out bool logGenerator, false);

            if (logGenerator)

            {

                string logDir = DesertPaintCodex.Util.FileUtils.AppDataPath;

                _generator.Log = System.IO.Path.Combine(logDir, "recipe_generator_log.txt");

            }

            _generator.ResumeRecipeGeneration();

        }

        public async Task Clear()

        {

            bool result = await ShowYesNoBox("Clear Recipes", "Are you sure you want to clear your recipes?");

            if (result)

            {

                CanClear = false;

                if (_ribbonMode)

                {

                    _profile.ClearRibbonRecipes();

                }

                else

                {

                    _profile.ClearPaintRecipes();

                }