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()