RecipeGenerator generator;

        PlayerProfile profile;

        bool canceling = false;

        bool running = false;

        bool pauseForCheckpoint = false;

        const long RECIPE_SAVE_INTERVAL = 30000; // msec between saving recipes

        const long CHECKPOINT_INTERVAL = 17000; // msec between saving out generator state

        const string STATE_FILE = "dp_generator_state";

        static Gtk.ListStore colorStore = new Gtk.ListStore(typeof(string));

        List<KeyValuePair<string, string>> missingReactions = new List<KeyValuePair<string, string>>();

        long lastProgressUpdate;

        long lastStatusUpdate;

        long lastProfileSave;

        long lastCheckpoint;

        static public Gtk.ListStore RecipeModel

        {

            get

            {

                return colorStore;   

            }

        }

        Gtk.ThreadNotify notifyFinished;

        Gtk.ThreadNotify notifyProgress;

        Gtk.ThreadNotify notifyNewRecipe;

        ConcurrentQueue<PaintRecipe> pendingNewRecipes = new ConcurrentQueue<PaintRecipe>();

        Gtk.ListStore reagentListStore;

        // end reagent view

        public RecipeGeneratorWindow(PlayerProfile profile) : base(Gtk.WindowType.Toplevel)

        {

            this.profile = profile;

            this.Build();

            minIngredientsSpinButton.Value = 1; // TODO: read/save profile info

            maxIngredientsSpinButton.Value = 5; // TODO: read/save profile info

            maxRecipeSpinButton.Value = 20; // TODO: read/save profile info

            fullQuantitySpinButton.Value = 20; // TODO: read/save profile info

            fullQuantityDepthSpinButton.Value = 4; // TODO: read/save profile info

            fullQuantityDepthSpinButton.SetRange(0, ReagentManager.Names.Count);

            maxIngredientsSpinButton.SetRange(1, ReagentManager.Names.Count);

            minIngredientsSpinButton.SetRange(1, ReagentManager.Names.Count);

            Gtk.TreeViewColumn recipeColorColumn = new Gtk.TreeViewColumn();

            Gtk.CellRendererText recipeColumnCell = new Gtk.CellRendererText();

            recipeColorColumn.PackStart(recipeColumnCell, true);       

            recipeColorColumn.Title = "Color";

            recipeList.AppendColumn(recipeColorColumn);

            recipeColorColumn.AddAttribute(recipeColumnCell, "text", 0);

            colorStore.Clear();

            colorStore.SetSortColumnId(0, Gtk.SortType.Ascending);

            recipeList.Model = RecipeModel;

            recipeList.Selection.Changed += OnColorSelected;

            recipeIngredientsView.AppendColumn("Quantity", new Gtk.CellRendererText(), "text", 0);

            recipeIngredientsView.AppendColumn("Ingredient", new Gtk.CellRendererText(), "text", 1);

            recipeIngredientsView.Model = new Gtk.ListStore(typeof(string), typeof(string));

            profile.LoadRecipes();

            // init UI

            foreach (KeyValuePair<string, PaintRecipe> pair in profile.Recipes)

            {

                if (pair.Value.IsValid)

                {

                    string colorName = pair.Key;

                    colorStore.AppendValues(colorName);

                }

            }

            canceling = false;

            running = false;

            pauseForCheckpoint = false;

            generator = new RecipeGenerator(profile.Reactions);

            int threads;

            DesertPaintLab.Settings.Get("GeneratorThreads", out threads);

            if (threads <= 0) { threads = 15; }

            generator.MaxThreads = (uint)threads;

            generator.InitRecipes(profile.Recipes);

            generator.Progress += OnProgress;

            generator.Finished += OnFinished;

            generator.NewRecipe += OnNewRecipe;

            string stateFile = System.IO.Path.Combine(profile.Directory, STATE_FILE);

            if (System.IO.File.Exists(stateFile))

            {

                generator.LoadState(stateFile);

                if (generator.CanResume)

                {

                    beginButton.Label = "Restart";

                    stopResumeButton.Label = "Resume";

                    stopResumeButton.Sensitive = true;

                    maxRecipeSpinButton.Value = Math.Max(generator.MaxQuantity, 14); //

                    fullQuantitySpinButton.Value = generator.FullQuantity; // TODO: read/save profile info

                    fullQuantityDepthSpinButton.Value = generator.FullQuantityDepth; // TODO: read/save profile info

                    maxIngredientsSpinButton.Value = generator.MaxReagents;

                }

            }

            //generator.Log = System.IO.Path.Combine(profile.Directory, "dp_log.txt");

            countLabel.Text = String.Format("{0} / {1}", profile.RecipeCount, Palette.Count);

            Destroyed += OnDestroyed;

            notifyFinished = new Gtk.ThreadNotify(new Gtk.ReadyEvent(HandleFinished));

            notifyProgress = new Gtk.ThreadNotify(new Gtk.ReadyEvent(HandleProgress));

            notifyNewRecipe = new Gtk.ThreadNotify(new Gtk.ReadyEvent(HandleNewRecipe));

            // initialize reagent list

            // Add the columns to the TreeView

            Gtk.TreeViewColumn reagentEnabledColumn = new Gtk.TreeViewColumn ();

            reagentEnabledColumn.Title = "Enabled";

            Gtk.CellRendererToggle reagentEnabledCell = new Gtk.CellRendererToggle ();

            reagentEnabledCell.Activatable = true;

            reagentEnabledCell.Sensitive = true;

            reagentEnabledCell.Mode = Gtk.CellRendererMode.Activatable;

            reagentEnabledCell.Visible = true;

            reagentEnabledCell.Toggled += new Gtk.ToggledHandler(OnReagentEnableToggled);

            reagentEnabledColumn.PackStart (reagentEnabledCell, true);

            //reagentEnabledColumn.AddAttribute(reagentEnabledCell, "active", 0);

            Gtk.TreeViewColumn reagentNameColumn = new Gtk.TreeViewColumn ();

            reagentNameColumn.Title = "Ingredient";

            Gtk.CellRendererText reagentNameCell = new Gtk.CellRendererText ();

            reagentNameCell.Mode = Gtk.CellRendererMode.Inert;

            reagentNameColumn.PackStart (reagentNameCell, true);

            reagentNameColumn.AddAttribute(reagentNameCell, "text", 1);

            reagentNameColumn.Expand = true;

            Gtk.TreeViewColumn reagentCostColumn = new Gtk.TreeViewColumn ();

            reagentCostColumn.Title = "Cost";

            Gtk.CellRendererText reagentCostCell = new Gtk.CellRendererText ();

            reagentCostCell.Edited += OnReagentCostChanged;

            reagentCostCell.Editable = true;

            reagentCostCell.Sensitive = true;

            reagentCostCell.Mode = Gtk.CellRendererMode.Editable;

            reagentCostColumn.PackStart (reagentCostCell, true);

            //reagentCostColumn.AddAttribute(reagentCostCell, "text", 0);

            Gtk.TreeViewColumn reagentMaxColumn = new Gtk.TreeViewColumn ();

            reagentMaxColumn.Title = "Max";

            Gtk.CellRendererText reagentMaxCell = new Gtk.CellRendererText ();

            reagentMaxCell.Edited += OnReagentQuantityChanged;

            reagentMaxCell.Editable = true;

            reagentMaxCell.Sensitive = true;

            reagentCostCell.Mode = Gtk.CellRendererMode.Editable;

            reagentMaxColumn.PackStart (reagentMaxCell, true);

            //reagentMaxColumn.AddAttribute(reagentMaxCell, "text", 0);

            reagentListStore = new Gtk.ListStore(typeof(Reagent), typeof(string), typeof(Reagent), typeof(Reagent));

            foreach (string reagentName in ReagentManager.Names)

            {

                Reagent reagent = ReagentManager.GetReagent(reagentName);

                reagentListStore.AppendValues(reagent, reagentName); // , reagent, reagent);

            }

            reagentEnabledColumn.SetCellDataFunc (reagentEnabledCell, new Gtk.TreeCellDataFunc (RenderReagentToggle));

            reagentCostColumn.SetCellDataFunc (reagentCostCell, new Gtk.TreeCellDataFunc (RenderReagentCost));

            reagentMaxColumn.SetCellDataFunc (reagentMaxCell, new Gtk.TreeCellDataFunc (RenderReagentQuantity));

            // Assign the model to the TreeView

            reagentListView.Model = reagentListStore;

            reagentListView.Sensitive = true;

            reagentListView.AppendColumn(reagentEnabledColumn);

            reagentListView.AppendColumn(reagentNameColumn);

            reagentListView.AppendColumn(reagentCostColumn);

            reagentListView.AppendColumn(reagentMaxColumn);

            reagentListView.

            ShowAll();

        }

        protected void OnMinIngredientsChanged(object sender, EventArgs e)

        {

            Gtk.SpinButton button = (Gtk.SpinButton) sender;

            if (button.ValueAsInt > maxIngredientsSpinButton.ValueAsInt)

            {

                maxIngredientsSpinButton.Value = button.ValueAsInt;

            }

            maxIngredientsSpinButton.SetRange(button.ValueAsInt, maxIngredientsSpinButton.Adjustment.Upper);

        }

        protected void OnMaxIngredientsChanged(object sender, EventArgs e)

        {

            Gtk.SpinButton button = (Gtk.SpinButton) sender;

            if (button.ValueAsInt < minIngredientsSpinButton.ValueAsInt)

            {

                minIngredientsSpinButton.Value = button.ValueAsInt;

            }

            minIngredientsSpinButton.SetRange(1, button.ValueAsInt);

            // TODO: save profile setting

            // TODO: no longer permit resume

        }

        protected void OnMaxRecipeChanged(object sender, EventArgs e)

        {

            // TODO: save profile setting

            // TODO: no longer permit resume

        }

        protected void OnFullQuantityDepthChanged(object sender, EventArgs e)

        {

            // TODO: save profile setting

            // TODO: no longer permit resume

        }

        protected void OnFullQuantityChanged(object sender, EventArgs e)

        {

            // TODO: save profile setting

            // TODO: no longer permit resume

        }

        protected void OnBegin(object sender, EventArgs e)

        {

            minIngredientsSpinButton.Sensitive = false;

            maxIngredientsSpinButton.Sensitive = false;

            ExportToWikiAction.Sensitive = false;

            IngredientsAction.Sensitive = false;

            maxRecipeSpinButton.Sensitive = false;

            beginButton.Sensitive = false; // TODO: change to "pause"?

            stopResumeButton.Sensitive = true;

            fullQuantitySpinButton.Sensitive = false;

            fullQuantityDepthSpinButton.Sensitive = false;

            reagentListView.Sensitive = false;

            countLabel.Text = String.Format("{0} / {1}", profile.RecipeCount, Palette.Count);

            // TODO: hook up event notifications

            // - progress

            // - complete

            // - new recipe / recipe update

            // Total recipe search count

            //int current = ReagentManager.Names.Count;

            //long recipePermutations = 1;

            //for (int i = 0; i < maxIngredientsSpinButton.ValueAsInt; ++i)

            //{

            //    recipePermutations *= current;

            //    --current;

            //}

            //System.Console.WriteLine("Will search {0} reagent permutations.", recipePermutations);

            lastProgressUpdate = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

            lastStatusUpdate = lastProgressUpdate;

            lastProfileSave = lastProgressUpdate;

            lastCheckpoint = lastProgressUpdate;

            running = true;

            canceling = false;

            pauseForCheckpoint = false;

            stopResumeButton.Label = "Pause";

            generator.BeginRecipeGeneration((uint)maxRecipeSpinButton.ValueAsInt, (uint)minIngredientsSpinButton.Value, (uint)maxIngredientsSpinButton.ValueAsInt, (uint)fullQuantityDepthSpinButton.ValueAsInt, (uint)fullQuantitySpinButton.ValueAsInt);

        }

        protected void OnStopResume(object sender, EventArgs e)

        {

            if (generator != null)

            {

                if (running)

                {

                    canceling = true;

                    pauseForCheckpoint = false;

                    generator.Stop();

                }

                else

                {

                    // Resume previous run

                    ExportToWikiAction.Sensitive = false;

                    IngredientsAction.Sensitive = false;

                    reagentListView.Sensitive = false;

                    minIngredientsSpinButton.Sensitive = false;

                    maxIngredientsSpinButton.Sensitive = false;

                    maxRecipeSpinButton.Sensitive = false;

                    beginButton.Sensitive = false;

                    stopResumeButton.Sensitive = true;

                    fullQuantitySpinButton.Sensitive = false;

                    fullQuantityDepthSpinButton.Sensitive = false;

                    reagentListView.Sensitive = false;

                    lastProgressUpdate = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

                    lastStatusUpdate = lastProgressUpdate;

                    lastProfileSave = lastProgressUpdate;

                    lastCheckpoint = lastProgressUpdate;

                    canceling = false;

                    pauseForCheckpoint = false;

                    running = true;

                    stopResumeButton.Label = "Pause";

                    generator.ResumeRecipeGeneration();

                }

            }

        }

        private void HandleFinished()

        {

            generator.Wait();

            if (pauseForCheckpoint)

            {

                pauseForCheckpoint = false;

                generator.SaveState(System.IO.Path.Combine(profile.Directory, STATE_FILE));

                generator.ResumeRecipeGeneration();

            }

            else

            {

                running = false;

                beginButton.Sensitive = true;

                ExportToWikiAction.Sensitive = true;

                IngredientsAction.Sensitive = true;

                stopResumeButton.Sensitive = false;

                minIngredientsSpinButton.Sensitive = true;

                maxIngredientsSpinButton.Sensitive = true;

                maxRecipeSpinButton.Sensitive = true;

                fullQuantitySpinButton.Sensitive = true;

                fullQuantityDepthSpinButton.Sensitive = true;

                reagentListView.Sensitive = true;

                //generator = null; // don't. Hang on to generator for resume.

                profile.SaveRecipes();

                if (canceling)

                {

                    generator.SaveState(System.IO.Path.Combine(profile.Directory, STATE_FILE));

                    stopResumeButton.Label = "Resume";

                    stopResumeButton.Sensitive = true;

                    beginButton.Label = "Restart";

                }

                else

                {

                    System.IO.File.Delete(System.IO.Path.Combine(profile.Directory, STATE_FILE));

                }

            }

        }

        protected void OnFinished(object sender, EventArgs args)

        {

            notifyFinished.WakeupMain();

            //Gtk.Application.Invoke(delegate {

            //    HandleFinished();

            //});

        }

        private void HandleNewRecipe()

        {

            progressBar.Pulse();

            PaintRecipe recipe = null;

            if (pendingNewRecipes.TryDequeue(out recipe))

            {

                string recipeColor = Palette.FindNearest(recipe.ReactedColor);

                // TODO: Add item to recipe list only if not already listed

                bool exists = false;

                Gtk.TreeIter iter;

                if (colorStore.GetIterFirst(out iter))

                {

                    do

                    {

                        string color = (string)colorStore.GetValue(iter, 0);

                        if (color.Equals(recipeColor))

                        {

                            exists = true;

                            break;

                        }

                    } while (colorStore.IterNext(ref iter));

                }

                if (!exists)

                {

                    //    bool isMissingReactions = args.Recipe.CheckMissingReactions(ref missingReactions);

                    //    string missingReactionLabel = isMissingReactions ? "X" : "";

                    colorStore.AppendValues(recipeColor); // , missingReactionLabel);

                    countLabel.Text = String.Format("{0} / {1}", profile.RecipeCount+1, Palette.Count);

                }

                profile.SetRecipe(recipe);

                long progressTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

                long delta = progressTime - lastProfileSave;

                if (delta >= RECIPE_SAVE_INTERVAL)

                {

                    profile.SaveRecipes();

                    lastProfileSave = progressTime;

                }

            }

        }

        protected void OnNewRecipe(object sender, NewRecipeEventArgs args)

        {

            PaintRecipe recipe = new PaintRecipe(args.Recipe); // copy it, so the worker thread can release

            lock(this) {

                pendingNewRecipes.Enqueue(recipe);

            }

            notifyNewRecipe.WakeupMain();

            //Gtk.Application.Invoke(delegate {

            //    HandleNewRecipe();

            //});

        }

        private void HandleProgress()

        {

            long progressTime = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;

            long delta = progressTime - lastProgressUpdate;

            if (delta > 30)

            {

                lastProgressUpdate = progressTime;

                progressBar.Pulse();

            }

            delta = progressTime - lastStatusUpdate;

            if (delta > 500)

            {

                lastStatusUpdate = progressTime;

                statusLabel.Text = String.Format("Recipes searched: {0:N00}", generator.RecipeCount);

            }

            delta = progressTime - lastCheckpoint;

            if (delta > CHECKPOINT_INTERVAL)

            {

                lastCheckpoint = progressTime;

                pauseForCheckpoint = true;

                generator.Stop();

            }

        }

        protected void OnProgress(object sender, EventArgs args)

        {

            notifyProgress.WakeupMain();

        }

        protected void OnColorSelected(object o, EventArgs args)

        {

            Gtk.TreeModel model;

            Gtk.TreeIter iter;

            Gtk.TreeSelection selection = recipeList.Selection;

            if ((selection != null) && selection.GetSelected(out model, out iter))

            {

                string colorName = (string)colorStore.GetValue(iter, 0);

                PaintRecipe recipe;

                if (profile.Recipes.TryGetValue(colorName, out recipe))

                {

                    }

            }

        }

        protected void OnExportToWiki(object sender, EventArgs e)

        {

            Gtk.FileChooserDialog fileDialog =

                new Gtk.FileChooserDialog("Select destination file.",

                        this, Gtk.FileChooserAction.Save,

                        Gtk.Stock.Cancel, Gtk.ResponseType.Cancel,

                        Gtk.Stock.Save, Gtk.ResponseType.Accept);

            Gtk.ResponseType resp = (Gtk.ResponseType)fileDialog.Run();

            if (resp == Gtk.ResponseType.Accept)

            {

                string fileName = fileDialog.Filename;

                string directory = fileDialog.CurrentFolder;

                profile.ExportWikiRecipes(System.IO.Path.Combine(directory, fileName));

            }

            fileDialog.Destroy();

        }

        protected void OnShowIngredients(object sender, EventArgs e)

        {

            ReagentWindow win = new ReagentWindow(profile);

            win.Show();

        }

        protected void OnDestroyed(object o, EventArgs args)

        {

            if (running)

            {

                // window closed while generator running: stop and save

                generator.Finished -= OnFinished;

                generator.Progress -= OnProgress;

                generator.NewRecipe -= OnNewRecipe;

                generator.Stop();

                generator.Wait();

                generator.SaveState(System.IO.Path.Combine(profile.Directory, STATE_FILE));

            }

        }

        // Reagent view handling

        private void RenderReagentToggle (Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)

        {

            Reagent reagent = (Reagent) model.GetValue (iter, 0);

            Gtk.CellRendererToggle toggle = (cell as Gtk.CellRendererToggle);

            toggle.Active = reagent.Enabled;

            toggle.Activatable = !reagent.IsCatalyst;

            toggle.Mode = reagent.IsCatalyst ? Gtk.CellRendererMode.Inert : Gtk.CellRendererMode.Activatable;

        }

        private void RenderReagentCost (Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)

        {

            Reagent reagent = (Reagent) model.GetValue (iter, 0);

            (cell as Gtk.CellRendererText).Text = reagent.Cost.ToString();

        }

        private void RenderReagentQuantity (Gtk.TreeViewColumn column, Gtk.CellRenderer cell, Gtk.TreeModel model, Gtk.TreeIter iter)

        {

            Reagent reagent = (Reagent) model.GetValue (iter, 0);

            (cell as Gtk.CellRendererText).Text = reagent.RecipeMax.ToString();

        }

        private void OnReagentCostChanged(object o, Gtk.EditedArgs args)

        {

            uint newCost;

            if (uint.TryParse(args.NewText, out newCost))

            {

                Gtk.TreeIter iter;

                reagentListStore.GetIter (out iter, new Gtk.TreePath (args.Path));

                Reagent reagent = (Reagent) reagentListStore.GetValue (iter, 0);

                if (reagent.Cost != newCost)

                {

                    reagent.Cost = newCost;

                    SaveReagentSettings();

                }

            }

        }

        private void OnReagentQuantityChanged(object o, Gtk.EditedArgs args)

        {

            uint newMax;

            if (uint.TryParse(args.NewText, out newMax))

            {

                Gtk.TreeIter iter;

                reagentListStore.GetIter (out iter, new Gtk.TreePath (args.Path));

                Reagent reagent = (Reagent) reagentListStore.GetValue (iter, 0);

                if (reagent.RecipeMax != newMax)

                {

                    reagent.RecipeMax = newMax;

                    SaveReagentSettings();

                }

            }

        }

        private void OnReagentEnableToggled(object o, Gtk.ToggledArgs args)

        {

            Gtk.TreeIter iter;

            reagentListStore.GetIter (out iter, new Gtk.TreePath (args.Path));

            Reagent reagent = (Reagent) reagentListStore.GetValue (iter, 0);

            reagent.Enabled = !reagent.Enabled;

            SaveReagentSettings();

        }

        private void SaveReagentSettings()

        {

            // save out state

            ReagentManager.SaveProfileReagents(profile.ReagentFile);

        }

        protected void OnCopyRecipeToClipboard(object sender, EventArgs e)

        {

            Gtk.TreeModel model;

            Gtk.TreeIter iter;

            Gtk.Clipboard clipboard = recipeIngredientsView.GetClipboard(Gdk.Selection.Clipboard);

            Gtk.TreeSelection selection = recipeList.Selection;

            if ((selection != null) && selection.GetSelected(out model, out iter))

            {

                string colorName = (string)colorStore.GetValue(iter, 0);

                PaintRecipe recipe;

                if (profile.Recipes.TryGetValue(colorName, out recipe))

                {

                    clipboard.Text = recipe.ToString();

                }

            }

        }

        protected void OnCopyRecipeListToClipboard(object sender, EventArgs e)

        {

            Gtk.Clipboard clipboard = recipeList.GetClipboard(Gdk.Selection.Clipboard);

            StringWriter writer = new StringWriter();

            profile.ExportWikiFormat(writer);

            clipboard.Text = writer.ToString();

        }

    }

}