THE SOFTWARE.

*/

using System;

using System.IO;

using System.Collections.Generic;

using System.Text.RegularExpressions;

using Gtk;

using DesertPaintLab;

public partial class MainWindow : Gtk.Window

{

	bool unsavedData = false;

	bool shouldShutDown = false;

	string appDataPath;

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

	PlayerProfile profile = null;

	PaintColor expectedColor = new PaintColor();

	PaintColor reactedColor = new PaintColor();

	int screenWidth = 0;

	int screenHeight = 0;

	int pixelMultiplier = 1;

		{

			if (dir.Name != "template")

			{

				profileList.Add(dir.Name);

			}

		}

        reagents[0] = null;

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

		if (unmodifiedSwatch != null)

		{

			unmodifiedSwatch.Clear();

		}

		if (reactionSwatch != null)

		{

			reactionSwatch.Clear();

		}

					resp = (ResponseType)md.Run();

					md.Destroy();

					duplicateName = true;

					break;	

				}

			}

			if (!duplicateName)

			{

				// Set profile name.

				SetProfileName(newProfileDialog.ProfileName);

			}

		}

		newProfileDialog.Destroy();

		return newProfileCreated;

	}

	bool OpenProfile()

	{

		bool profileSelected = false;

		if (profileList.Count > 0)

		{

						profileSelected = NewProfile();

						if (profileSelected)

						{

							profile.ImportFromPP(directory);

						}

					}

				}

			}

		}

		if (profileSelected)

		{

			PopulateDropDowns();

            recipe.Reactions = profile.Reactions;

		}

		return profileSelected;

	}

	void PopulateDropDowns()

	{

		ReagentManager.PopulateReagents(ref ingredient1ComboBox);

		ReagentManager.PopulateReagents(ref ingredient2ComboBox);

		ReagentManager.PopulateReagents(ref ingredient3ComboBox);

		ingredient2ComboBox.Sensitive = false;

		ingredient3ComboBox.Sensitive = false;

	            "Are you sure you want to lose your changes?");

			ResponseType resp = (ResponseType)md.Run();

			md.Destroy();

			if (resp != ResponseType.Ok)

			{

				return;	

			}

		}

		if (NewProfile())

		{

			PopulateDropDowns();

            recipe.Reactions = profile.Reactions;

		}

	}

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

	{

		bool profileSelected = false;

		SelectProfileDialog selectProfileDialog = new SelectProfileDialog();

		selectProfileDialog.ProfileList = profileList;

		ResponseType resp = (ResponseType)selectProfileDialog.Run();

		selectProfileDialog.Destroy();

		if (resp == ResponseType.Ok) // Selected a profile.

		{

			SetProfileName(selectProfileDialog.SelectedProfile);

			profileSelected = true;

		}

		else if (resp == ResponseType.Accept) // New profile.

		{

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

		aboutDialog.Destroy();

	}

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

	{

		if (ConfirmedExit())

		{

			Application.Quit();

                resp = (ResponseType)md.Run();

                md.Destroy();

                if (resp == ResponseType.Ok)

                {

                    Directory.Delete(profile.Directory, true);

                    profile.Import(targetFile);

                }

            }

            else

            {

                profile.Import(targetFile);

            }

            PopulateDropDowns();

            recipe.Reactions = profile.Reactions;

        }

        fileDialog.Destroy();

    }

}

            reagents.Add(reagentName);

        }

        public void Clear()

        {

            reagents.Clear();

            recipe.Clear();

        }

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

        {

            RGB baseRGB;

            baseRGB.r = 0;

            baseRGB.g = 0;

            baseRGB.b = 0;

            RGB reactionColor;

            reactionColor.r = 0;

            reactionColor.g = 0;

 The above copyright notice and this permission notice shall be included in

 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

 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;

using System.Text.RegularExpressions;

namespace DesertPaintLab

{

	public class PlayerProfile

	{

		string name;

		string directory;

		//	new SortedDictionary<string, SortedDictionary<string, Reaction>>();

        SortedDictionary<string, PaintRecipe> recipes;

        static PlayerProfile current = null;

        static PlayerProfile Current

        {

            get {

                return current;

            }

        }

		public PlayerProfile(string name, string directory)

		{

			this.name = name;

			this.directory = directory;

			this.reactFile = System.IO.Path.Combine(directory, "dp_reactions.txt");

            this.reagentFile = System.IO.Path.Combine(directory, "ingredients.txt");

            this.recipes = new SortedDictionary<string, PaintRecipe>();

            foreach (PaintColor color in Palette.Colors)

            {

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

            }

		}

                int count = 0;

                foreach (PaintRecipe recipe in this.recipes.Values)

                {

                    if (recipe.IsValid)

                    {

                        ++count;

                    }

                }

                return count;

            }

        }

		{

			// Create new directory.

			System.IO.Directory.CreateDirectory(directory);

			// Copy template files into new 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;

			using (StreamReader reader = new StreamReader(ppFile))

			{

				using (StreamWriter writer = new StreamWriter(dpFile))

				{

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

                	{

						string[] tokens = line.Split(null);

						if ((tokens.Length > 0) && (tokens[0] != "//"))

		}

        public void Import(string file)

        {

            ZipFile.ExtractToDirectory(file, directory);

        }

		public void Export(string file)

		{

            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) 

               	{

					string[] tokens = line.Split(null);

                    Reagent reagent1 = ReagentManager.GetReagent(tokens[0]);

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

		{

			Reaction reaction;

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

			{

                foreach (string reagentName1 in ReagentManager.Names)

                {

                    // TODO: could be more efficient by only iterating over the names after reagent1

                    foreach (string reagentName2 in ReagentManager.Names)

                    {

    public class RecipeGenerator

    {

        public enum SearchType {

            DEPTH_FIRST,

            BREADTH_FIRST

        };

        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;

        bool running = false;

        int runningThreads = 0;

        SortedDictionary<string, uint> recipeCosts = new SortedDictionary<string, uint>();

        SortedDictionary<string, PaintRecipe> recipes = new SortedDictionary<string, PaintRecipe>();

        uint totalReagents;

        public event EventHandler Progress;

        public event EventHandler<NewRecipeEventArgs> NewRecipe;

        public RecipeGenerator(ReactionSet reactions)

        {

            Mode = SearchType.BREADTH_FIRST;

            this.reactions = reactions;

            foreach (PaintColor color in Palette.Colors)

            {

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

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

            }

        }

        public SortedDictionary<string, PaintRecipe> Recipes

        {

            get

            {

                return recipes;

            }

        }

        public ulong RecipeCount

        {

        private void InitSortedReagents()

        {

            costSortedReagents.Clear();

            foreach (string name in ReagentManager.Names)

            {

                Reagent reagent = ReagentManager.GetReagent(name);

                costSortedReagents.Add(reagent);

            }

            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;

            // first, sort reagents by cost.

            InitSortedReagents();

            totalReagents = (uint)costSortedReagents.Count;

            // Pre-populate recipes list with:

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

            // 2) any previously-generated recipes

                if (reagent.Enabled)

                {

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

                    {

                        recipe.Clear();

                        recipe.AddReagent(reagent.Name, 10);

                        AddCheapestRecipe(recipe);

                    }

                    ++enabledReagentCount;

                }

            }

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

            while (!searchQueue.IsEmpty)

            {

                RecipeSearchNode node;

                searchQueue.TryDequeue(out node);

            }

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

            {

                if (costSortedReagents[(int)reagentIdx].Enabled)

                {

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

        }

        public void ResumeRecipeGeneration()

        {

            if (running)

            {

                // Already running - don't start again

                return;

        }

        public bool SaveState(string file)

        {

            if (running)

            {

                // can't save state while running

                return false;

            }

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

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

                writer.WriteLine("SearchType: {0}", Mode.ToString());

                foreach (KeyValuePair<string, PaintRecipe> pair in recipes)

                {

                    PaintRecipe recipe = pair.Value;

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

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

                    foreach (PaintRecipe.RecipeIngredient ingredient in recipe.Ingredients)

            Match match;

            string line;

            using (StreamReader reader = new StreamReader(file, false))

            {

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

                {

                    match = keyValueRegex.Match(line);

                    if (match.Success)

                    {

                        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;

                            case "FullQuantity":

                                FullQuantity = uint.Parse(value);

                                break;

                            case "TotalReagents":

                                totalReagents = uint.Parse(value);

                                break;

                            case "RecipeCount":

                                if (!ulong.TryParse(value, out recipeCount))

                                    {

                                        success = false;

                                    }

                                }

                                break;

                            case "SearchNodes":

                                int nodeCount = int.Parse(match.Groups["value"].Value);

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

                                {

                                    RecipeSearchNode node = new RecipeSearchNode(costSortedReagents);

                                    node.FullQuantity = FullQuantity;

                                    node.FullQuantityDepth = FullQuantityDepth;

                                    node.MaxReagents = MaxReagents;

                                    node.MaxQuantity = MaxQuantity;

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

                                    if (success)

                                    {

                                        searchQueue.Enqueue(node);

                                    }

                                }

                                break;

                            case "SearchType":

                                Mode = (SearchType)Enum.Parse(typeof(SearchType), match.Groups["value"].Value);

                                break;

            if (NextRecipeSize(node))

            {

                //System.Console.WriteLine("Found next recipe size {0}", node.CurrentTargetQuantity);

                return true;

            }

            // Search for next ingredient combo - all quantity combos for previous were searched

            //System.Console.WriteLine("Finding next ingredient combo");

            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;

                    }

                    node.ReplaceLastReagent(nextReagent);

                }

            } while (node.MaxQuantity < (10 + node.CatalystCount));

            node.InitForQuantity(node.MaxQuantity);

            //string outStr = "{0} : {1} : ";

            //for (int i = 0; i < currentReagents.Count; ++i)

            //{

            // next reagent in last position

            // if at end, pop reagent

            //Console.WriteLine("Finding new recipe after quantity {0}/{1} used {2}", newQuantity, node.MaxQuantity, node.UsedQuantity);

            node.InitForQuantity(10+node.CatalystCount); // reset quantity

            int currentDepth = node.ReagentCount;

            bool recipeFound = false;

            uint nextReagent;

            do {

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

                                if (nextReagent < totalReagents)

                                {

                                    //Console.WriteLine("Replace last reagent with {0}", nextReagent);

                                    node.ReplaceLastReagent(nextReagent);

                                    break;

                                }

                                else

                                {