using DesertPaintLab;

public partial class MainWindow : Gtk.Window

{

	bool unsavedData = false;

	bool shouldShutDown = false;

	string appDataPath;

	List<string> profileList = new List<string>();

        reagents[1] = null;

        reagents[2] = null;

        string colorsPath = FileUtils.FindApplicationResourceFile("colors.txt");

		Palette.Load(colorsPath);

        string ingredientsPath = FileUtils.FindApplicationResourceFile("ingredients.txt");

        ReagentManager.Load(ingredientsPath);

		Build();

			{

				// Set profile name.

				SetProfileName(newProfileDialog.ProfileName);

			}

		}

		newProfileDialog.Destroy();

		return newProfileCreated;

		}

		if (profileSelected)

		{

			PopulateDropDowns();

            recipe.Reactions = profile.Reactions;

		}

		return profileSelected;

	}

		}

		if (NewProfile())

		{

			PopulateDropDowns();

            recipe.Reactions = profile.Reactions;

		}

	}

	protected virtual void OnOpenProfile(object sender, System.EventArgs e)

	{

			profileSelected = NewProfile();

		}

		if (profileSelected)

		{

			PopulateDropDowns();

		}

	}

	protected virtual void OnAbout(object sender, System.EventArgs e)

	{

		AboutDialog aboutDialog = new AboutDialog();

        aboutDialog.ProgramName = "Desert Paint Lab";

        aboutDialog.Comments = "Desert Paint Lab paint reaction recorder for A Tale in the Desert";

        aboutDialog.Authors = new string [] {"Tess Snider", "Jason Maltzen"};

        //aboutDialog.Website = "http://www.google.com/";

		aboutDialog.Run();

            else

            {

                profile.Import(targetFile);

            }

            PopulateDropDowns();

            recipe.Reactions = profile.Reactions;

        }

        fileDialog.Destroy();

    }

}

        byte CalculateColor(int baseSum, uint pigmentCount, int reactSum)

        {

            // Changed to Math.Floor from Math.Round, since Round appears to be incorrect.

        }

        // Compute the color including reactions based on the player's profile

        private void ComputeReactedColor()

 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

 THE SOFTWARE.

*/

using System;

using System.IO;

using System.IO.Compression;

using System.Collections.Generic;

                return current;

            }

        }

		public PlayerProfile(string name, string directory)

		{

			this.name = name;

			this.directory = directory;

                return count;

            }

        }

		{

			// Create new directory.

			System.IO.Directory.CreateDirectory(directory);

			string templatePath = FileUtils.FindApplicationResourceDirectory("template");

            if (!System.IO.Directory.Exists(templatePath))

            {

            }

			DirectoryInfo di = new DirectoryInfo(templatePath);

			FileInfo[] templateFiles = di.GetFiles();

			foreach (FileInfo file in templateFiles)

			{

			}

		}

		public void ConvertFromPP(string ppFile, string dpFile)

		{

			string line;

		{

            ZipFile.CreateFromDirectory(directory, file);

		}

		{

			string line;

			reactions.Clear();

			ReagentManager.LoadProfileReagents(reagentFile);

			ReagentManager.InitializeReactions(ref reactions);

			using (StreamReader reader = new StreamReader(reactFile))

			{

				while ((line = reader.ReadLine()) != null) 

               	{

                    Reagent reagent2 = ReagentManager.GetReagent(tokens[1]);

					reactions.Set(reagent1, reagent2, new Reaction(int.Parse(tokens[2]), int.Parse(tokens[3]), int.Parse(tokens[4])));

				}

			}

		}

		public void Save()

		{

        public SearchType Mode { get; set; }

        public uint MaxQuantity { get; private set; } // maximum number of total ingredients

        public uint MaxReagents { get; private set; } // maximum number of reagents to use in the recipe

        public uint FullQuantityDepth { get; private set; } // at or equal this number of reagents, ignore ingredient settings for max quantity

        public uint FullQuantity { get; private set; }  // The max number of a reagent to use at full quantity

        ReactionSet reactions;

            {

                recipes.Add(color.Name, new PaintRecipe());

                recipeCosts.Add(color.Name, uint.MaxValue);

            }

        }

        public SortedDictionary<string, PaintRecipe> Recipes

        {

            }

            costSortedReagents.Sort(new ReagentCostSort());

        }

        {

            if (running)

            {

                // Already running - don't start again

                return;

            }

            this.MaxQuantity = maxQuantity;

            this.MaxReagents = maxReagents;

            this.FullQuantity = fullQuantity;

            this.FullQuantityDepth = fullQuantityDepth;

                    ++enabledReagentCount;

                }

            }

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

            while (!searchQueue.IsEmpty)

            {

                RecipeSearchNode node;

                    RecipeSearchNode initialNode = new RecipeSearchNode(costSortedReagents, reagentIdx);

                    initialNode.FullQuantity = FullQuantity;

                    initialNode.FullQuantityDepth = FullQuantityDepth;

                    initialNode.MaxQuantity = maxQuantity;

                    initialNode.MaxReagents = maxReagents;

                    searchQueue.Enqueue(initialNode);

                }

            }

            recipeCount = 0;

            if (log != null)

            {

            }

            // start worker threads to do the actual work

            ResumeRecipeGeneration();

            }

            using (StreamWriter writer = new StreamWriter(file, false))

            {

                writer.WriteLine("MaxReagents: {0}", MaxReagents);

                writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);

                writer.WriteLine("FullQuantity: {0}", FullQuantity);

                writer.WriteLine("TotalReagents: {0}", totalReagents);

                    {

                        string value = match.Groups["value"].Value;

                        switch(match.Groups["key"].Value)

                        {

                            case "MaxReagents":

                                MaxReagents = uint.Parse(value);

                                break;

                            case "FullQuantityDepth":

                                FullQuantityDepth = uint.Parse(value);

                                break;

                                {

                                    RecipeSearchNode node = new RecipeSearchNode(costSortedReagents);

                                    node.FullQuantity = FullQuantity;

                                    node.FullQuantityDepth = FullQuantityDepth;

                                    node.MaxReagents = MaxReagents;

                                    node.MaxQuantity = MaxQuantity;

                                    success = success && node.LoadState(reader);

                                    if (success)

            do

            {

                if (!node.AddNextReagent())

                {

                    {

                        node.RemoveLastReagent();

                    }

                    {

                        // done

                        return false;

                    }

                    uint nextReagent = node.NextFreeReagent(node.LastReagent);

                    {

                        // No more reagents to try at this level

                        node.RemoveLastReagent();

                        {

                            nextReagent = node.NextFreeReagent(node.LastReagent);

                        }

                    }

                    {

                        // done

                        return false;

                    }

                //Console.WriteLine("Current depth: {0}/{1}", currentDepth, node.MaxReagents);

                do {

                    recipeFound = false;

                    // back out until we find a node that can be incremented

                    {

                        {

                            if (node.LastReagent < (totalReagents - 1))

                            {

                                nextReagent = node.NextFreeReagent(node.LastReagent);

                                {

                                    // shouldn't happen

                                    //Console.WriteLine("No available reagents at depth {0}!", node.ReagentCount);

                                    node.RemoveLastReagent();

                                    {

                                        // just popped the last reagent at the top level

                                        ++currentDepth;

                                        if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1}", currentDepth, node.MaxReagents); } }

                            else

                            {

                                //Console.WriteLine("Pop last reagent");

                                node.RemoveLastReagent();

                                {

                                    // just popped the last reagent at the top level

                                    ++currentDepth;

                                    if (log != null) { lock(log) { log.WriteLine("Increased depth to {0}/{1} [pop last reagent at top level]", currentDepth, node.MaxReagents); } }

                                }

                            }

                        }

                        // fill in the nodes up to the current depth

                        {

                            recipeFound = true;

                            while (node.ReagentCount < currentDepth)

                            {

                                }

                            }

                        }

                    }

                if (recipeFound)

                {

                    break;

                }

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

        {

            this.profile = profile;

            this.Build();

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

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

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

            ShowAll();

        }

        protected void OnMaxIngredientsChanged(object sender, EventArgs e)

        {

            // TODO: save profile setting

            // TODO: no longer permit resume

        }

        }

        protected void OnBegin(object sender, EventArgs e)

        {

            maxIngredientsSpinButton.Sensitive = false;

            ExportToWikiAction.Sensitive = false;

            IngredientsAction.Sensitive = false;

            maxRecipeSpinButton.Sensitive = false;

            canceling = false;

            pauseForCheckpoint = false;

            stopResumeButton.Label = "Pause";

        }

        protected void OnStopResume(object sender, EventArgs e)

        {

                    // Resume previous run

                    ExportToWikiAction.Sensitive = false;

                    IngredientsAction.Sensitive = false;

                    reagentListView.Sensitive = false;

                    maxIngredientsSpinButton.Sensitive = false;

                    maxRecipeSpinButton.Sensitive = false;

                    beginButton.Sensitive = false;

                    stopResumeButton.Sensitive = true;

                beginButton.Sensitive = true;

                ExportToWikiAction.Sensitive = true;

                IngredientsAction.Sensitive = true;

                stopResumeButton.Sensitive = false;

                maxIngredientsSpinButton.Sensitive = true;

                maxRecipeSpinButton.Sensitive = true;

                fullQuantitySpinButton.Sensitive = true;

                fullQuantityDepthSpinButton.Sensitive = true;

                testRecipe = value;

            }

        }

        public uint CurrentTargetQuantity { get; set; }

        public uint MaxQuantity { get; set; }

        public uint UsedQuantity { get; private set; }

        public uint CatalystCount { get; set; }

        public uint FullQuantityDepth { get; set; }

        public uint FullQuantity { get; set; }

        uint maxReagents;

        public uint MaxReagents

        {

                {

                    reagentInUse[reagentIdx] = true;

                }

            }

            MaxReagents = (uint)nextReagentPos; // better set this later!

            UsedQuantity = 0;

        }

                reagentInUse[reagentIdx] = false;

            }

            this.reagents[nextReagentPos++] = NextFreeReagent(startReagent);

            //Console.WriteLine("Added reagent {0} at pos {1}", this.reagents[nextReagentPos-1], nextReagentPos-1);

            MaxReagents = 1;

            UsedQuantity = 0;

        }

            {

                reagentInUse[reagentIdx] = false;

            }

            this.reagents[nextReagentPos++] = NextFreeReagent(0);

            MaxReagents = 1;

            UsedQuantity = 0;

        }

        public void SaveState(StreamWriter writer)

        {

            writer.WriteLine("---SearchNode---");

            writer.WriteLine("MaxReagents: {0}", MaxReagents);

            writer.WriteLine("Reagents: {0}", nextReagentPos);

            for (int i = 0; i < nextReagentPos; ++i)

            {

            writer.WriteLine("CurrentTargetQuantity: {0}", CurrentTargetQuantity);

            writer.WriteLine("MaxQuantity: {0}", MaxQuantity);

            writer.WriteLine("UsedQuantity: {0}", UsedQuantity);

            writer.WriteLine("CatalystCount: {0}", CatalystCount);

            writer.WriteLine("FullQuantity: {0}", FullQuantity);

            writer.WriteLine("FullQuantityDepth: {0}", FullQuantityDepth);

            writer.WriteLine("---EndNode---");

                                uint value = uint.Parse(match.Groups[2].Value);

                                MaxQuantity = value;

                            }

                            break;

                        case "MaxReagents":

                            {

                                uint value = uint.Parse(match.Groups[2].Value);

                                MaxReagents = value;

                            }

                            break;

                        case "InitialCount":

                            {

                            }

                            break;

                        case "FullQuantity":

                            {

		private global::Gtk.VBox vbox8;

		private global::Gtk.HBox hbox2;

		private global::Gtk.SpinButton maxIngredientsSpinButton;

		private global::Gtk.Label label3;

			this.hbox2 = new global::Gtk.HBox ();

			this.hbox2.Name = "hbox2";

			this.hbox2.Spacing = 6;

			// Container child hbox2.Gtk.Box+BoxChild

			w3.Position = 0;

			w3.Expand = false;

			w3.Fill = false;

			// Container child hbox2.Gtk.Box+BoxChild

			w4.Position = 1;

			w4.Expand = false;

			w4.Fill = false;

			this.vbox8.Add (this.hbox2);

			w5.Position = 0;

			w5.Expand = false;

			w5.Fill = false;

			// Container child vbox8.Gtk.Box+BoxChild

			this.hseparator3 = new global::Gtk.HSeparator ();

			this.hseparator3.Name = "hseparator3";

			this.vbox8.Add (this.hseparator3);

			// Container child vbox8.Gtk.Box+BoxChild