// Generate paint recipes.

        // minConcentration - the minimum permitted concentration in a recipe (10 for paint, 50 for ribbons)

        // maxConcentration - the maximum concentration for a recipe

        // minReagents - the minimum number of ingredients in a recipe

        // maxReagents - the maximum number of ingredients allowed in a recipe

        // fullQuantityDepth - at this depth of ingredient or below, allow up to fullQuantity of any reagent

        // fullQuantity - the maximum amount of any reagent to permit up to the full quantity depth. After that, reagents are limited by the

        //                per-reagent value

        public void BeginRecipeGeneration(uint minConcentration, uint maxConcentration, uint minReagents, uint maxReagents, uint fullQuantityDepth, uint fullQuantity)

        {

            if (_running)

            {

                // Already running - don't start again

                return;

            }

            MinConcentration = minConcentration;

            MaxConcentration = maxConcentration;

            MinReagents = minReagents;

            MaxReagents = maxReagents;

            FullQuantity = fullQuantity;

            FullQuantityDepth = fullQuantityDepth;

            // first, sort reagents by cost.

            InitSortedReagents();

            _totalReagents = (uint)_costSortedReagents.Count;

            // Pre-populate recipes list with:

            // 1) 1-ingredient recipes @ min concentration for all enabled ingredients with a count >= min concentration

            // 2) any previously-generated recipes

            WriteLog($"===================== BEGIN RECIPE GENERATION ========================== {DateTime.Now}");

            WriteLog("Pre-populating basic recipes.");

            int enabledReagentCount = 0;

            PaintRecipe recipe = new();

            foreach (var reagent in _costSortedReagents.Where(reagent => reagent.Enabled))

            {

                if (!reagent.IsCatalyst && ((reagent.RecipeMax >= minConcentration) || ((FullQuantityDepth > 0) && (FullQuantity >= minConcentration))))

                {

                    recipe.Clear();

                    recipe.AddReagent(reagent.Name, minConcentration);

                    AddCheapestRecipe(recipe);

                }

                ++enabledReagentCount;

            }

            MaxReagents = (uint)Math.Min(enabledReagentCount, MaxReagents);

            MinReagents = Math.Min(MinReagents, MaxReagents);

                    while ((ok = IterateBreadthFirst(node)) && !_requestCancel)

                    {

                        Progress?.Invoke(this, EventArgs.Empty);

                    }

                }

                if (ok)

                {

                    // stopped because cancel was requested - requeue the node in its current state for resume

                    _searchQueue.Enqueue(node);

                }

            } while (!_requestCancel);

            bool done;

            lock(_workerLock)

            {

                --_runningThreads;

                //generatorThreads.Remove(Thread.CurrentThread);

                done = (_runningThreads == 0);

            }

            if (!done) return;

            _running       = false;

            _requestCancel = false;

            Finished?.Invoke(this, EventArgs.Empty);

        }

        // Add the cheapest recipe to the recipe list

        // returns the discarded recipe from the pair (or null if no original recipe to replace)

        private void AddCheapestRecipe(PaintRecipe recipe)

        {

            if (!recipe.IsValidForConcentration(MinConcentration)) return;

            string colorName = PaletteService.FindNearest(recipe.ReactedColor);

            lock (_workerLock)

            {

                uint newCost = recipe.Cost;

                if (_recipeCosts.TryGetValue(colorName, out var cost))

                {

                    if (cost < newCost)

                    {

                        // WriteLog($"Skipping recipe (cost {newCost} > {cost}): {recipe}");

                        return;

                    }

                    PaintRecipe origRecipe = _recipes[colorName];

                    if (cost == newCost && recipe.Concentration >= origRecipe.Concentration)

                    {