{

            if (_running)

            {

                return;

            }

            _recipeCosts.Clear();

            _recipes.Clear();

            foreach (PaintRecipe recipe in initialRecipes.Values)

            {

                //PaintRecipe recipeCopy = new PaintRecipe(recipe);

                AddCheapestRecipe(recipe);

            }

        }

        private void InitSortedReagents()

        {

            _costSortedReagents.Clear();

            foreach (string name in ReagentService.Names)

            {

                Reagent reagent = ReagentService.GetReagent(name);

                _costSortedReagents.Add(reagent);

            }

            _costSortedReagents.Sort(new ReagentCostSort());

        }

        // 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);

            _searchQueue.Clear();

            for (uint reagentIdx = 0; reagentIdx < _costSortedReagents.Count; ++reagentIdx)

            {

                if (!_costSortedReagents[(int) reagentIdx].Enabled) continue;

                // queue up all combinations of MinReagents

                RecipeSearchNode initialNode = new(_costSortedReagents, reagentIdx)

                {

                    FullQuantity      = FullQuantity,

                    FullQuantityDepth = FullQuantityDepth,

                    MinConcentration  = minConcentration,

                    MaxConcentration  = maxConcentration,

                    MinReagents       = minReagents,

                    MaxReagents       = maxReagents

                };

                initialNode.WriteLog = WriteLog;

                if (MinReagents > 1)

                {

                    while (NextReagentSetBreadthFirst(initialNode, 1, minReagents))

                    {

                        if (initialNode.ReagentCount != minReagents) continue;

                        node.InitForQuantity(targetQuantity);

                    } while (targetQuantity > MinConcentration && (node.CurrentTargetQuantity != node.UsedQuantity));

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

                    {

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

                    }

                }

                else

                {

                    // breadth-first search

                    uint targetQuantity = MinConcentration - 1;

                    uint quantityLimit = (node.ReagentCount <= FullQuantityDepth) 

                        ? (FullQuantity * (uint)node.ReagentCount) 

                        : node.MaxConcentration;

                    do {

                        ++targetQuantity;

                        if (node.ShouldLog)

                        {

                            WriteLog($" == Initializing {node} for quantity {targetQuantity}");

                        }

                        node.InitForQuantity(targetQuantity);

                    } while ((targetQuantity < quantityLimit) && (node.CurrentTargetQuantity != node.UsedQuantity));

                    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)

                    {

                        // Same cost, greater concentration - use the lower concentration recipe

                        WriteLog($"Skipping recipe (cost {newCost}, {recipe.Concentration} >= {origRecipe.Concentration}): {recipe}");

                        return;

                    }

                    _recipes[colorName].CopyFrom(recipe); // Copy recipe because the one passed in should be const and will get overwritten

                    _recipeCosts[colorName] = newCost;

                    WriteLog($"Replacing recipe (cost {newCost} < {cost}): {recipe}");

                    if (NewRecipe == null) return;

                    NewRecipeEventArgs args = new(colorName, _recipes[colorName]);

                    NewRecipe(this, args);

                }

                else

                {

                    // This would be an error!

                    _recipeCosts.Add(colorName, newCost);

                    PaintRecipe newRecipe = new PaintRecipe(recipe); // Copy recipe because the one passed in should be const and will get overwritten

                    _recipes.Add(colorName, newRecipe);

                    WriteLog($"New recipe (cost {newCost}): {recipe}");

                    if (NewRecipe == null) return;