using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Logging;
using DotNetGraph.Attributes;
using DotNetGraph.Compilation;
using DotNetGraph.Core;
using DotNetGraph.Extensions;
using JetBrains.Annotations;
using Jotunn.Entities;
using Jotunn.Managers;
using MonoMod.Utils;
using PrefabDependencyTree.Data;
using PrefabDependencyTree.Data.Drops;
using PrefabDependencyTree.Data.Drops.Generic;
using PrefabDependencyTree.Data.Filters;
using PrefabDependencyTree.Model;
using PrefabDependencyTree.Util;
using UnityEngine;

[assembly: AssemblyFileVersion("1.2.5")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PrefabDependencyTree")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("FixItFelix")]
[assembly: AssemblyProduct("PrefabDependencyTree")]
[assembly: AssemblyCopyright("Copyright 2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: CompilationRelaxations(8)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.5.0")]
[module: UnverifiableCode]
namespace PrefabDependencyTree
{
	[BepInPlugin("FixItFelix.PrefabDependencyTree", "PrefabDependencyTree", "1.2.5")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	internal class PrefabDependencyTreePlugin : BaseUnityPlugin
	{
		public const string PluginAuthor = "FixItFelix";

		public const string PluginGUID = "FixItFelix.PrefabDependencyTree";

		public const string PluginName = "PrefabDependencyTree";

		public const string PluginVersion = "1.2.5";

		private void Awake()
		{
			PrefabManager.OnPrefabsRegistered += DataHarvester.Initialize;
			CommandManager.Instance.AddConsoleCommand((ConsoleCommand)(object)new ConsoleController());
		}
	}
}
namespace PrefabDependencyTree.Util
{
	public class ConsoleController : ConsoleCommand
	{
		private const string prefabDependencyTreeCommand = "prefab_dependency_tree";

		private const string printOption = "print_tree";

		private const string printIncludeFilteredOption = "print_include_filtered_tree";

		private const string printExcludeFilteredOption = "print_exclude_filtered_tree";

		private const string debugLogAll = "debug_log_all";

		private const string debugLogItemsCategories = "debug_log_items_categories";

		private static readonly List<string> ItemTypeEnums = Enum.GetNames(typeof(ItemType)).ToList();

		private static readonly List<ItemType> WeaponsAndArmorEnums = new List<ItemType>
		{
			(ItemType)9,
			(ItemType)4,
			(ItemType)7,
			(ItemType)10,
			(ItemType)12,
			(ItemType)6,
			(ItemType)11,
			(ItemType)5,
			(ItemType)17,
			(ItemType)19,
			(ItemType)15,
			(ItemType)18,
			(ItemType)20,
			(ItemType)23,
			(ItemType)3,
			(ItemType)14,
			(ItemType)22
		};

		private static readonly List<string> WeaponsAndArmorTypes = WeaponsAndArmorEnums.Select((ItemType enumEntry) => ((object)(ItemType)(ref enumEntry)).ToString()).ToList();

		private const string WeaponsAndArmorTypesName = "WeaponsAndArmorTypes";

		public override string Name => "prefab_dependency_tree";

		public override string Help => "Prefab Dependency Tree Console Commands";

		private static List<string> ReplaceTypes(List<string> input)
		{
			if (!input.Contains("WeaponsAndArmorTypes"))
			{
				return input;
			}
			input.Remove("WeaponsAndArmorTypes");
			input.AddRange(WeaponsAndArmorTypes);
			return input;
		}

		public override void Run(string[] args)
		{
			Logger.LogInfo("called '" + ((ConsoleCommand)this).Name + "' with args '" + string.Join(" ", args) + "'");
			if (args.Length != 0)
			{
				switch (args[0])
				{
				case "print_tree":
					WriteGraphOutput(new UnfilteredData());
					break;
				case "print_include_filtered_tree":
					if (args.Length > 1)
					{
						WriteGraphOutput(new IncludeFilterTypes(ReplaceTypes(args[1].Split(new char[1] { ',' }).ToList())));
					}
					else
					{
						Logger.LogWarning("you did not provide item types to filter for, see usage");
						LogUsage();
					}
					break;
				case "print_exclude_filtered_tree":
					if (args.Length > 1)
					{
						WriteGraphOutput(new ExcludeFilterTypes(ReplaceTypes(args[1].Split(new char[1] { ',' }).ToList())));
					}
					else
					{
						Logger.LogWarning("you did not provide item types to filter for, see usage");
						LogUsage();
					}
					break;
				case "debug_log_items_categories":
				{
					List<string> values = DataHarvester.LogAllItemsToCategorizedYaml();
					string text2 = Path.Combine(Paths.ConfigPath, "FixItFelix.PrefabDependencyTree.all.items.categories.yaml");
					File.WriteAllText(text2, string.Join("\n", values));
					Logger.LogInfo("wrote file '" + text2 + "'");
					break;
				}
				case "debug_log_all":
				{
					List<string> list = DataHarvester.LogAllToString();
					list.ForEach(Logger.LogWarning);
					string text = Path.Combine(Paths.ConfigPath, "FixItFelix.PrefabDependencyTree.all.txt");
					File.WriteAllText(text, string.Join("\n", list));
					Logger.LogInfo("wrote file '" + text + "'");
					break;
				}
				default:
					Logger.LogWarning("this option '" + args[0] + "' is not supported, see usage");
					LogUsage();
					break;
				}
			}
			else
			{
				LogUsage();
			}
		}

		private static async void WriteGraphOutput(FilteredData filteredData)
		{
			using StringWriter writer = new StringWriter();
			CompilationContext context = new CompilationContext(writer, new CompilationOptions());
			filteredData.LogOverview();
			await filteredData.CreateGraph().CompileAsync(context);
			string text = Path.Combine(Paths.ConfigPath, "FixItFelix.PrefabDependencyTree.graph.dot");
			File.WriteAllText(text, writer.GetStringBuilder().ToString());
			Logger.LogInfo("wrote graph file '" + text + "'");
			RunGraphVizConverter(text);
		}

		private static void RunGraphVizConverter(string filePath)
		{
			string text = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), "Graphviz\\bin\\gv2gml.exe");
			if (!File.Exists(text))
			{
				return;
			}
			Logger.LogInfo("GraphViz installation binary detected at '" + text + "'");
			try
			{
				string text2 = filePath.Replace(".dot", ".gml");
				Process.Start(text, "\"" + filePath + "\" -o \"" + text2 + "\"")?.WaitForExit(100000);
				if (File.Exists(text2))
				{
					Logger.LogInfo("converted to GraphViz file to '" + text2 + "'");
				}
				else
				{
					Logger.LogWarning("converted file was not found as expected");
				}
			}
			catch (Exception ex)
			{
				Logger.LogWarning("error converting .dot file using GraphViz: " + ex.Message);
			}
		}

		private static void LogUsage()
		{
			Logger.LogInfo(" - prefab_dependency_tree usage - ");
			Logger.LogInfo("command option:");
			Logger.LogInfo("   print_tree -> will print the whole tree analyzed from game data");
			Logger.LogInfo("   debug_log_all -> will log warn all prefabs (this will be huge log output!)");
			Logger.LogInfo("   debug_log_items_categories -> writes all item prefabs by category into a yaml format file");
			Logger.LogInfo("   print_include_filtered_tree Material,Consumable -> print tree with items of the provided item types included (complete tree with link to any included items)");
			Logger.LogInfo("   print_exclude_filtered_tree Ammo,OneHandedWeapon -> print tree with items of the provided item types excluded (remove the provided types from tree)");
			Logger.LogInfo("        all item types: " + string.Join(", ", ItemTypeEnums) + ", WeaponsAndArmorTypes");
		}

		public override List<string> CommandOptionList()
		{
			return new List<string> { "print_tree", "print_include_filtered_tree", "print_exclude_filtered_tree", "debug_log_all", "debug_log_items_categories" };
		}
	}
	public static class Logger
	{
		private static readonly ManualLogSource LoggerInstance = Logger.CreateLogSource("PrefabDependencyTree");

		public static void LogDebug(string text)
		{
			LoggerInstance.LogDebug((object)text);
		}

		public static void LogInfo(string text)
		{
			LoggerInstance.LogInfo((object)text);
		}

		public static void LogWarning(string text)
		{
			LoggerInstance.LogWarning((object)text);
		}

		public static void LogError(string text)
		{
			LoggerInstance.LogError((object)text);
		}
	}
}
namespace PrefabDependencyTree.Model
{
	public class BaseCrafting
	{
		public readonly string Name;

		public readonly Dictionary<string, GraphRecipe> Recipes = new Dictionary<string, GraphRecipe>();

		protected BaseCrafting(string name)
		{
			Name = name;
		}

		protected BaseCrafting(string name, Dictionary<string, GraphRecipe> recipes)
		{
			Name = name;
			Recipes = recipes;
		}

		public bool ContainsItemTypes(List<string> itemTypes)
		{
			return Recipes.Any((KeyValuePair<string, GraphRecipe> recipe) => itemTypes.Contains(recipe.Value.CraftedItem.Item1.ItemType) || recipe.Value.RequiredItems.Any((KeyValuePair<GraphItem, int> requiredItem) => itemTypes.Contains(requiredItem.Key.ItemType)));
		}

		public void RemoveRecipesForTypes(List<string> itemTypes)
		{
			int count = Recipes.Count;
			Dictionary<string, GraphRecipe> dictionary = Recipes.Where((KeyValuePair<string, GraphRecipe> recipe) => !itemTypes.Contains(recipe.Value.CraftedItem.Item1.ItemType) && !recipe.Value.RequiredItems.Any((KeyValuePair<GraphItem, int> item) => itemTypes.Contains(item.Key.ItemType))).ToDictionary((KeyValuePair<string, GraphRecipe> recipe) => recipe.Key, (KeyValuePair<string, GraphRecipe> recipe) => recipe.Value);
			Recipes.Clear();
			Extensions.AddRange<string, GraphRecipe>(Recipes, dictionary);
			Logger.LogInfo("reduced '" + Name + "' recipes " + $"from original count {count} to reduced count {Recipes.Count}");
		}

		public override string ToString()
		{
			string text = string.Join("\n    ", Recipes.Select((KeyValuePair<string, GraphRecipe> recipe) => recipe.Value.ToString().Replace("\n", "\n    ")));
			return "name '" + Name + "' has recipes:\n    " + text;
		}
	}
	public class GraphCraftingStation : BaseCrafting
	{
		public readonly List<string> ExtensionNames;

		private GraphCraftingStation(string stationName, List<string> extensionNames)
			: base(stationName)
		{
			ExtensionNames = extensionNames;
		}

		public static Dictionary<string, GraphCraftingStation> FromExtensionsAndStations(List<StationExtension> extensions, List<CraftingStation> stations)
		{
			Dictionary<string, GraphCraftingStation> stationsFromExtensions = (from extension in extensions
				select Tuple.Create(((Object)(object)extension.m_craftingStation != (Object)null) ? ((Object)extension.m_craftingStation).name : "missing station", ((Object)extension).name) into tuple
				group tuple by tuple.Item1).ToDictionary((IGrouping<string, Tuple<string, string>> group) => group.Key, (IGrouping<string, Tuple<string, string>> group) => new GraphCraftingStation(group.Key, group.Select((Tuple<string, string> tuple) => tuple.Item2).ToList()));
			GraphCraftingStation value;
			return stations.ToDictionary((CraftingStation station) => ((Object)station).name, (CraftingStation station) => stationsFromExtensions.TryGetValue(((Object)station).name, out value) ? value : new GraphCraftingStation(((Object)station).name, new List<string>()));
		}

		public override string ToString()
		{
			if (ExtensionNames.Count <= 0)
			{
				return "[crafting station " + base.ToString() + "\n]";
			}
			string text = string.Join(", ", ExtensionNames);
			return "[crafting station " + base.ToString() + "\n  has extensions: " + text + "\n]";
		}
	}
	public class GraphItem
	{
		public string ItemName { get; private set; }

		public string ItemType { get; set; }

		private GraphItem()
		{
		}

		public static GraphItem GetOrCreate(string itemName, string itemType)
		{
			if (DataHarvester.Items.TryGetValue(itemName, out var value))
			{
				return value;
			}
			GraphItem graphItem = new GraphItem
			{
				ItemName = itemName,
				ItemType = itemType
			};
			DataHarvester.Items.Add(itemName, graphItem);
			return graphItem;
		}

		public static GraphItem GetOrCreate(ItemDrop drop)
		{
			return GetOrCreate(((Object)drop).name, ((object)(ItemType)(ref drop.m_itemData.m_shared.m_itemType)).ToString());
		}

		[CanBeNull]
		public static GraphItem GetOrCreate(GameObject gameObject)
		{
			ItemDrop val = default(ItemDrop);
			if (!gameObject.TryGetComponent<ItemDrop>(ref val))
			{
				return null;
			}
			return GetOrCreate(((Object)val).name, ((object)(ItemType)(ref val.m_itemData.m_shared.m_itemType)).ToString());
		}

		public override string ToString()
		{
			return "[item name '" + ItemName + "', type '" + ItemType + "']";
		}
	}
	public class GraphPiece
	{
		public string PieceName;

		public string RequiredCraftingStation;

		public Dictionary<GraphItem, int> BuildRequirements;

		public static GraphPiece FromPiece(Piece fromGame)
		{
			return new GraphPiece
			{
				PieceName = ((Object)fromGame).name,
				RequiredCraftingStation = (((Object)(object)fromGame.m_craftingStation == (Object)null) ? "no_station_required" : ((Object)fromGame.m_craftingStation).name),
				BuildRequirements = fromGame.m_resources.Where((Requirement resource) => (Object)(object)resource.m_resItem != (Object)null).ToDictionary((Requirement resource) => GraphItem.GetOrCreate(((Object)resource.m_resItem).name, ((object)(ItemType)(ref resource.m_resItem.m_itemData.m_shared.m_itemType)).ToString()), (Requirement resource) => resource.m_amount)
			};
		}

		public override string ToString()
		{
			if (BuildRequirements.Count <= 0)
			{
				return "[piece name '" + PieceName + "', requires station '" + RequiredCraftingStation + "']";
			}
			string text = string.Join("\n    ", BuildRequirements.Select((KeyValuePair<GraphItem, int> requirement) => $"[{requirement.Key} x{requirement.Value}]"));
			return "[piece name '" + PieceName + "', requires station '" + RequiredCraftingStation + "', requirements:\n    " + text + "\n]";
		}
	}
	public class GraphProcessor : BaseCrafting
	{
		private GraphProcessor(string name, Dictionary<string, GraphRecipe> recipes)
			: base(name, recipes)
		{
		}

		public static GraphProcessor FromSmelter(Smelter smelter)
		{
			return new GraphProcessor(((Object)smelter).name, GraphRecipe.FromSmelter(smelter));
		}

		public static GraphProcessor FromIncinerator(Incinerator incinerator)
		{
			return new GraphProcessor(((Object)incinerator).name, GraphRecipe.FromIncinerator(incinerator));
		}

		public static GraphProcessor FromFermenter(Fermenter fermenter)
		{
			return new GraphProcessor(((Object)fermenter).name, GraphRecipe.FromFermenter(fermenter));
		}

		public static GraphProcessor FromCookingStation(CookingStation cookingStation)
		{
			return new GraphProcessor(((Object)cookingStation).name, GraphRecipe.FromCookingStation(cookingStation));
		}

		public override string ToString()
		{
			return "[processor " + base.ToString() + "\n]";
		}
	}
	public class GraphRecipe
	{
		public string RecipeName;

		public Tuple<GraphItem, int> CraftedItem;

		public Dictionary<GraphItem, int> RequiredItems;

		private GraphRecipe()
		{
		}

		public static GraphRecipe FromRecipe(Recipe fromGame)
		{
			if ((Object)(object)fromGame.m_item == (Object)null)
			{
				throw new ArgumentException("recipe '" + ((Object)fromGame).name + "' does not produce an item");
			}
			if (!fromGame.m_resources.ToList().TrueForAll((Requirement recourse) => (Object)(object)recourse.m_resItem != (Object)null))
			{
				throw new ArgumentException("recipe '" + ((Object)fromGame).name + "' contains a null required resource");
			}
			return new GraphRecipe
			{
				RecipeName = ((Object)fromGame).name,
				CraftedItem = Tuple.Create(GraphItem.GetOrCreate(fromGame.m_item), 1),
				RequiredItems = fromGame.m_resources.ToDictionary((Requirement requirement) => GraphItem.GetOrCreate(requirement.m_resItem), (Requirement requirement) => requirement.m_amount)
			};
		}

		public static Dictionary<string, GraphRecipe> FromSmelter(Smelter smelter)
		{
			string fuel = (((Object)(object)smelter.m_fuelItem == (Object)null) ? "Air" : ((Object)smelter.m_fuelItem).name);
			return (from recipe in smelter.m_conversion.Select(delegate(ItemConversion conversion)
				{
					//IL_004b: Unknown result type (might be due to invalid IL or missing references)
					GraphRecipe obj = new GraphRecipe
					{
						RecipeName = GetProcessorRecipeName(((Object)conversion.m_from).name, ((Object)conversion.m_to).name),
						CraftedItem = Tuple.Create(GraphItem.GetOrCreate(conversion.m_to), 1)
					};
					Dictionary<GraphItem, int> dictionary = new Dictionary<GraphItem, int>();
					string itemName = fuel;
					ItemType val = (ItemType)1;
					dictionary.Add(GraphItem.GetOrCreate(itemName, ((object)(ItemType)(ref val)).ToString()), smelter.m_fuelPerProduct);
					dictionary.Add(GraphItem.GetOrCreate(conversion.m_from), 1);
					obj.RequiredItems = dictionary;
					return obj;
				})
				group recipe by recipe.RecipeName).ToDictionary((IGrouping<string, GraphRecipe> group) => group.Key, (IGrouping<string, GraphRecipe> group) => group.First());
		}

		public static Dictionary<string, GraphRecipe> FromIncinerator(Incinerator incinerator)
		{
			return (from conversion in incinerator.m_conversions
				select new GraphRecipe
				{
					RecipeName = GetProcessorRecipeName("Incinerator_Sacrifice", ((Object)conversion.m_result).name),
					CraftedItem = Tuple.Create(GraphItem.GetOrCreate(conversion.m_result), conversion.m_resultAmount),
					RequiredItems = conversion.m_requirements.ToDictionary((Requirement requirement) => GraphItem.GetOrCreate(requirement.m_resItem), (Requirement requirement) => requirement.m_amount)
				} into recipe
				group recipe by recipe.RecipeName).ToDictionary((IGrouping<string, GraphRecipe> group) => group.Key, (IGrouping<string, GraphRecipe> group) => new GraphRecipe
			{
				RecipeName = group.Key,
				CraftedItem = group.First().CraftedItem,
				RequiredItems = group.SelectMany((GraphRecipe recipe) => recipe.RequiredItems).ToDictionary((KeyValuePair<GraphItem, int> tuple) => tuple.Key, (KeyValuePair<GraphItem, int> tuple) => tuple.Value)
			});
		}

		public static Dictionary<string, GraphRecipe> FromFermenter(Fermenter fermenter)
		{
			return (from conversion in fermenter.m_conversion
				select new GraphRecipe
				{
					RecipeName = GetProcessorRecipeName(((Object)conversion.m_from).name, ((Object)conversion.m_to).name),
					CraftedItem = Tuple.Create(GraphItem.GetOrCreate(conversion.m_to), conversion.m_producedItems),
					RequiredItems = new Dictionary<GraphItem, int> { 
					{
						GraphItem.GetOrCreate(conversion.m_from),
						1
					} }
				} into recipe
				group recipe by recipe.RecipeName).ToDictionary((IGrouping<string, GraphRecipe> group) => group.Key, (IGrouping<string, GraphRecipe> group) => group.First());
		}

		public static Dictionary<string, GraphRecipe> FromCookingStation(CookingStation cookingStation)
		{
			string fuel = (((Object)(object)cookingStation.m_fuelItem == (Object)null) ? "Fire" : ((Object)cookingStation.m_fuelItem).name);
			return (from recipe in cookingStation.m_conversion.Select(delegate(ItemConversion conversion)
				{
					//IL_005d: Unknown result type (might be due to invalid IL or missing references)
					GraphRecipe obj = new GraphRecipe
					{
						RecipeName = GetProcessorRecipeName(((Object)conversion.m_from).name, ((Object)conversion.m_to).name),
						CraftedItem = Tuple.Create(GraphItem.GetOrCreate(conversion.m_to), 1)
					};
					Dictionary<GraphItem, int> obj2 = new Dictionary<GraphItem, int> { 
					{
						GraphItem.GetOrCreate(conversion.m_from),
						1
					} };
					string itemName = fuel;
					ItemType val = (ItemType)1;
					obj2.Add(GraphItem.GetOrCreate(itemName, ((object)(ItemType)(ref val)).ToString()), 1);
					obj.RequiredItems = obj2;
					return obj;
				})
				group recipe by recipe.RecipeName).ToDictionary((IGrouping<string, GraphRecipe> group) => group.Key, (IGrouping<string, GraphRecipe> group) => group.First());
		}

		private static string GetProcessorRecipeName(string fromItem, string toItem)
		{
			return "[processing " + fromItem + " to " + toItem + "]";
		}

		public override string ToString()
		{
			string text = string.Join("\n    ", RequiredItems.Select((KeyValuePair<GraphItem, int> requiredItem) => $"[{requiredItem.Key} x{requiredItem.Value}]"));
			return $"[recipe '{RecipeName}' to create {CraftedItem.Item1} requires:\n" + "    " + text + "\n]";
		}
	}
}
namespace PrefabDependencyTree.Data
{
	public static class DataHarvester
	{
		public static readonly Dictionary<string, GraphItem> Items = new Dictionary<string, GraphItem>();

		public static readonly Dictionary<string, GraphRecipe> UnboundRecipes = new Dictionary<string, GraphRecipe>();

		public static readonly Dictionary<string, GraphCraftingStation> CraftingStations = new Dictionary<string, GraphCraftingStation>();

		public static readonly Dictionary<string, GraphProcessor> Processors = new Dictionary<string, GraphProcessor>();

		public static readonly Dictionary<Tuple<string, DropType>, List<GraphItem>> Drops = new Dictionary<Tuple<string, DropType>, List<GraphItem>>();

		public static readonly Dictionary<string, GraphPiece> Pieces = new Dictionary<string, GraphPiece>();

		public static void Initialize()
		{
			InitializeSmelters();
			InitializeIncinerator();
			InitializeCookingStations();
			InitializeFermenters();
			InitializeCraftingStations();
			InitializePieces();
			InitializeRecipes();
			InitializeDrops();
			LogOverview();
			LogItemTypesOverview();
		}

		private static void LogOverview()
		{
			Logger.LogInfo("vvvv data harvester overview vvvv");
			Logger.LogInfo($"    total {Items.Count} items registered");
			Logger.LogInfo($"    total {Drops.Count} drops registered");
			Logger.LogInfo($"    total {Pieces.Count} pieces registered");
			Logger.LogInfo($"    total {CraftingStations.Count} crafting stations registered");
			Logger.LogInfo($"    total {Processors.Count} processor stations (fermenter, smelter, ...) registered");
			Logger.LogInfo($"    total {UnboundRecipes.Count} unbound recipes registered");
			Logger.LogInfo("^^^^ data harvester overview ^^^^");
		}

		private static void LogItemTypesOverview()
		{
			Dictionary<string, int> source = (from item in Items
				group item by item.Value.ItemType).ToDictionary((IGrouping<string, KeyValuePair<string, GraphItem>> group) => group.Key, (IGrouping<string, KeyValuePair<string, GraphItem>> group) => group.Count());
			Logger.LogInfo("vvvv item types overview vvvv");
			foreach (KeyValuePair<string, int> item in source.OrderBy((KeyValuePair<string, int> pair) => pair.Key))
			{
				Logger.LogInfo($"item type '{item.Key}' -> found {item.Value} items");
			}
			Logger.LogInfo("^^^^ item types overview ^^^^");
		}

		public static List<string> LogAllToString()
		{
			List<string> list = new List<string>();
			list.Add("==== debug log output for all prefabs ====");
			list.AddRange(Items.Select((KeyValuePair<string, GraphItem> item) => item.Value.ToString()));
			list.AddRange(from <>h__TransparentIdentifier0 in Drops.Select(delegate(KeyValuePair<Tuple<string, DropType>, List<GraphItem>> drop)
				{
					KeyValuePair<Tuple<string, DropType>, List<GraphItem>> keyValuePair = drop;
					return new
					{
						drop = drop,
						dropsList = string.Join("\n    ", keyValuePair.Value.Select((GraphItem item) => item.ToString()))
					};
				})
				select $"['{<>h__TransparentIdentifier0.drop.Key}' drops:\n" + "    " + <>h__TransparentIdentifier0.dropsList + "\n]");
			list.AddRange(Pieces.Select((KeyValuePair<string, GraphPiece> piece) => piece.Value.ToString()));
			list.AddRange(CraftingStations.Select((KeyValuePair<string, GraphCraftingStation> station) => station.Value.ToString()));
			list.AddRange(Processors.Select((KeyValuePair<string, GraphProcessor> processor) => processor.Value.ToString()));
			list.AddRange(UnboundRecipes.Select((KeyValuePair<string, GraphRecipe> recipe) => recipe.Value.ToString()));
			list.Add("==== debug log output for all prefabs ====");
			return list;
		}

		public static List<string> LogAllItemsToCategorizedYaml()
		{
			List<GraphItem> second = CraftingStations.SelectMany((KeyValuePair<string, GraphCraftingStation> cs) => cs.Value.Recipes.Select((KeyValuePair<string, GraphRecipe> recipe) => recipe.Value).ToList()).Union(UnboundRecipes.Select((KeyValuePair<string, GraphRecipe> unbound) => unbound.Value)).Union(Processors.SelectMany((KeyValuePair<string, GraphProcessor> processor) => processor.Value.Recipes.Select((KeyValuePair<string, GraphRecipe> recipe) => recipe.Value).ToList()))
				.ToList()
				.SelectMany(delegate(GraphRecipe recipe)
				{
					List<GraphItem> list2 = new List<GraphItem>();
					list2.Add(recipe.CraftedItem.Item1);
					list2.AddRange(recipe.RequiredItems.Select((KeyValuePair<GraphItem, int> req) => req.Key));
					return list2;
				})
				.ToList();
			Dictionary<string, List<string>> dictionary = (from item in Items.Select((KeyValuePair<string, GraphItem> item) => item.Value).Union(second).Union(Drops.SelectMany((KeyValuePair<Tuple<string, DropType>, List<GraphItem>> drop) => drop.Value))
					.ToList()
				group item by item.ItemType).ToDictionary((IGrouping<string, GraphItem> group) => group.Key, (IGrouping<string, GraphItem> group) => (from item in @group.Select((GraphItem item) => item.ItemName).Distinct()
				orderby item
				select item).ToList());
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, List<string>> item in dictionary)
			{
				list.Add(item.Key + ":");
				list.AddRange(item.Value.Select((string item) => "  - " + item));
			}
			return list;
		}

		private static void InitializePieces()
		{
			Dictionary<string, GraphPiece> dictionary = Cache.GetPrefabs(typeof(Piece)).ToDictionary((KeyValuePair<string, Object> kv) => kv.Key, (KeyValuePair<string, Object> kv) => GraphPiece.FromPiece((Piece)kv.Value));
			dictionary.Where((KeyValuePair<string, GraphPiece> kv) => !CraftingStations.ContainsKey(kv.Key) && !Processors.ContainsKey(kv.Key)).ToList().ForEach(delegate(KeyValuePair<string, GraphPiece> piece)
			{
				Pieces.Add(piece.Key, piece.Value);
			});
			Logger.LogInfo($"loaded {dictionary.Count} pieces from game");
		}

		private static void InitializeSmelters()
		{
			Dictionary<string, GraphProcessor> dictionary = Cache.GetPrefabs(typeof(Smelter)).ToDictionary((KeyValuePair<string, Object> kv) => kv.Key, (KeyValuePair<string, Object> kv) => GraphProcessor.FromSmelter((Smelter)kv.Value));
			dictionary.ToList().ForEach(delegate(KeyValuePair<string, GraphProcessor> smelter)
			{
				Processors.Add(smelter.Key, smelter.Value);
			});
			int num = dictionary.Select((KeyValuePair<string, GraphProcessor> smelter) => smelter.Value.Recipes.Count).Sum();
			Logger.LogInfo($"loaded {dictionary.Count} smelters with {num} conversions from game");
		}

		private static void InitializeIncinerator()
		{
			Dictionary<string, GraphProcessor> dictionary = Cache.GetPrefabs(typeof(Incinerator)).ToDictionary((KeyValuePair<string, Object> kv) => kv.Key, (KeyValuePair<string, Object> kv) => GraphProcessor.FromIncinerator((Incinerator)kv.Value));
			dictionary.ToList().ForEach(delegate(KeyValuePair<string, GraphProcessor> incinerator)
			{
				Processors.Add(incinerator.Key, incinerator.Value);
			});
			int num = dictionary.Select((KeyValuePair<string, GraphProcessor> incinerator) => incinerator.Value.Recipes.Count).Sum();
			Logger.LogInfo($"loaded {dictionary.Count} incinerators with {num} conversions from game");
		}

		private static void InitializeCookingStations()
		{
			Dictionary<string, GraphProcessor> dictionary = Cache.GetPrefabs(typeof(CookingStation)).ToDictionary((KeyValuePair<string, Object> kv) => kv.Key, (KeyValuePair<string, Object> kv) => GraphProcessor.FromCookingStation((CookingStation)kv.Value));
			dictionary.ToList().ForEach(delegate(KeyValuePair<string, GraphProcessor> fermenter)
			{
				Processors.Add(fermenter.Key, fermenter.Value);
			});
			int num = dictionary.Select((KeyValuePair<string, GraphProcessor> smelter) => smelter.Value.Recipes.Count).Sum();
			Logger.LogInfo($"loaded {dictionary.Count} cooking stations with {num} conversions from game");
		}

		private static void InitializeFermenters()
		{
			Dictionary<string, GraphProcessor> dictionary = Cache.GetPrefabs(typeof(Fermenter)).ToDictionary((KeyValuePair<string, Object> kv) => kv.Key, (KeyValuePair<string, Object> kv) => GraphProcessor.FromFermenter((Fermenter)kv.Value));
			dictionary.ToList().ForEach(delegate(KeyValuePair<string, GraphProcessor> fermenter)
			{
				Processors.Add(fermenter.Key, fermenter.Value);
			});
			int num = dictionary.Select((KeyValuePair<string, GraphProcessor> smelter) => smelter.Value.Recipes.Count).Sum();
			Logger.LogInfo($"loaded {dictionary.Count} fermenters with {num} conversions from game");
		}

		private static void InitializeCraftingStations()
		{
			Dictionary<string, GraphCraftingStation> dictionary = GraphCraftingStation.FromExtensionsAndStations(((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(StationExtension))).Select((Func<KeyValuePair<string, Object>, StationExtension>)((KeyValuePair<string, Object> kv) => (StationExtension)kv.Value)).ToList(), ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(CraftingStation))).Select((Func<KeyValuePair<string, Object>, CraftingStation>)((KeyValuePair<string, Object> kv) => (CraftingStation)kv.Value)).ToList());
			dictionary.ToList().ForEach(delegate(KeyValuePair<string, GraphCraftingStation> station)
			{
				CraftingStations.Add(station.Key, station.Value);
			});
			Logger.LogInfo($"loaded {dictionary.Count} crafting stations from game");
		}

		private static void InitializeRecipes()
		{
			foreach (KeyValuePair<string, Recipe> item in ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(Recipe))).ToDictionary((Func<KeyValuePair<string, Object>, string>)((KeyValuePair<string, Object> kv) => kv.Key), (Func<KeyValuePair<string, Object>, Recipe>)((KeyValuePair<string, Object> kv) => (Recipe)kv.Value)))
			{
				if ((Object)(object)item.Value.m_item == (Object)null)
				{
					Logger.LogInfo("recipe '" + item.Key + "' does not create an item - skipping");
				}
				else if ((Object)(object)item.Value.m_craftingStation != (Object)null)
				{
					if (CraftingStations.TryGetValue(((Object)item.Value.m_craftingStation).name, out var value))
					{
						value.Recipes.Add(item.Key, GraphRecipe.FromRecipe(item.Value));
						continue;
					}
					Logger.LogWarning("recipe '" + item.Key + "': station '" + ((Object)item.Value.m_craftingStation).name + "' not found");
				}
				else
				{
					UnboundRecipes.Add(item.Key, GraphRecipe.FromRecipe(item.Value));
				}
			}
			int num = CraftingStations.Select((KeyValuePair<string, GraphCraftingStation> station) => station.Value.Recipes.Count).Sum();
			Logger.LogInfo($"loaded {num} recipes bound to crafting stations from game");
			Logger.LogInfo($"loaded {UnboundRecipes.Count} recipes from game that are not bound to a crafting station");
		}

		private static void InitializeDrops()
		{
			List<Initializer> list = new List<Initializer>();
			list.Add(new ContainerDropsInitializer());
			list.Add(new DestructibleDropsInitializer());
			list.Add(new TreeLogDropsInitializer());
			list.Add(new TreeBaseDropsInitializer());
			list.Add(new CharacterDropInitializer());
			list.Add(new MineRockDropsInitializer());
			list.Add(new MineRock5DropInitializer());
			list.Add(new LootSpawnerDropsInitializer());
			list.Add(new PickableDropInitializer());
			list.Add(new PickableExtraDropInitializer());
			list.Add(new PickableItemDropInitializer());
			list.Add(new PickableItemRandomDropInitializer());
			list.ForEach(delegate(Initializer initializer)
			{
				try
				{
					initializer.InitializeDrops();
				}
				catch (Exception ex)
				{
					Logger.LogError("got exception on initializing: " + ex.Message);
					Logger.LogError(ex.StackTrace);
				}
			});
		}
	}
	public class GraphBuilder
	{
		private readonly DotGraph Graph = new DotGraph().WithIdentifier("graph").Directed();

		private readonly Dictionary<string, DotNode> Nodes = new Dictionary<string, DotNode>();

		private readonly Dictionary<string, DotEdge> Edges = new Dictionary<string, DotEdge>();

		public void AddNode(GraphItem item)
		{
			AddNode(item.ItemName, item.ItemType);
		}

		public void AddNode(string name, string nodeType)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(name))
			{
				Logger.LogWarning("tried adding empty node name");
			}
			else
			{
				if (Nodes.ContainsKey(name))
				{
					return;
				}
				DotNode dotNode = new DotNode().WithIdentifier(name).WithLabel(name).WithShape(DotNodeShape.Rectangle);
				if (nodeType != null)
				{
					DropType result2;
					if (Enum.TryParse<ItemType>(nodeType, out ItemType result))
					{
						SetNodeColorItemType(dotNode, result);
					}
					else if (Enum.TryParse<DropType>(nodeType, out result2))
					{
						SetNodeColorDropType(dotNode, result2);
					}
					else
					{
						if (!Enum.TryParse<NodeType>(nodeType, out var result3))
						{
							throw new ArgumentException("node type '" + nodeType + "' does not match any types known");
						}
						SetNodePieceTypeOption(dotNode, result3);
					}
				}
				Nodes.Add(name, dotNode);
			}
		}

		private static void SetNodeColorDropType(DotNode node, DropType dropType)
		{
			switch (dropType)
			{
			case DropType.Character:
				node.WithColor(DotColor.Orange);
				break;
			case DropType.Container:
			case DropType.LootSpawner:
				node.WithColor(DotColor.Beige);
				break;
			case DropType.Destructible:
				node.WithColor(DotColor.Crimson);
				break;
			case DropType.Pickable:
				node.WithColor(DotColor.Ivory);
				break;
			case DropType.Tree:
				node.WithColor(DotColor.Brown);
				break;
			case DropType.MineRock:
				node.WithShape(DotNodeShape.Diamond);
				node.WithColor(DotColor.SlateGrey);
				break;
			default:
				Logger.LogWarning("node type '" + dropType.ToString() + "' not supported");
				break;
			}
		}

		private static void SetNodeColorItemType(DotNode node, ItemType itemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected I4, but got Unknown
			switch ((int)itemType)
			{
			case 9:
			case 23:
				node.WithColor(DotColor.Cyan);
				break;
			case 6:
			case 7:
			case 11:
			case 12:
			case 17:
				node.WithColor(DotColor.DarkGrey);
				node.WithFontColor(DotColor.White);
				break;
			case 15:
			case 18:
			case 19:
				node.WithColor(DotColor.Indigo);
				break;
			case 3:
			case 4:
			case 5:
			case 14:
			case 20:
			case 22:
				node.WithColor(DotColor.IndianRed);
				break;
			case 2:
				node.WithColor(DotColor.LightGreen);
				break;
			case 21:
				node.WithColor(DotColor.LightBlue);
				break;
			case 1:
				node.WithColor(DotColor.SandyBrown);
				break;
			case 10:
			case 16:
				node.WithColor(DotColor.Grey);
				node.WithFontColor(DotColor.White);
				break;
			case 0:
				node.WithColor(DotColor.Yellow);
				break;
			case 13:
				node.WithColor(DotColor.Violet);
				node.WithFontColor(DotColor.White);
				break;
			default:
				throw new ArgumentException("type '" + ((object)(ItemType)(ref itemType)).ToString() + "' not supported");
			}
		}

		private static void SetNodePieceTypeOption(DotNode node, NodeType nodeType)
		{
			switch (nodeType)
			{
			case NodeType.Piece:
				node.WithShape(DotNodeShape.Assembly);
				node.WithColor(DotColor.Brown);
				break;
			case NodeType.Processor:
				node.WithShape(DotNodeShape.Circle);
				node.WithColor(DotColor.Gold);
				break;
			case NodeType.CraftingStation:
				node.WithShape(DotNodeShape.Circle);
				node.WithColor(DotColor.Gold);
				break;
			case NodeType.Recipe:
				node.WithShape(DotNodeShape.Note);
				node.WithColor(DotColor.Cornsilk);
				break;
			default:
				throw new ArgumentException("type '" + nodeType.ToString() + "' not supported");
			}
		}

		public void AddEdge(string from, string to)
		{
			string key = from + "->" + to;
			if (!Edges.ContainsKey(key))
			{
				Edges.Add(key, new DotEdge().From(from).To(to));
			}
		}

		public DotGraph BuildGraph()
		{
			Nodes.ToList().ForEach(delegate(KeyValuePair<string, DotNode> node)
			{
				Graph.Add(node.Value);
			});
			Edges.ToList().ForEach(delegate(KeyValuePair<string, DotEdge> edge)
			{
				Graph.Add(edge.Value);
			});
			return Graph;
		}
	}
	public enum NodeType
	{
		Piece,
		CraftingStation,
		Processor,
		Recipe
	}
	public enum DropType
	{
		Character,
		Container,
		Destructible,
		LootSpawner,
		MineRock,
		Pickable,
		Tree
	}
	public enum FilterType
	{
		Include,
		Exclude,
		Unfiltered
	}
}
namespace PrefabDependencyTree.Data.Filters
{
	public class ExcludeFilterTypes : FilteredData
	{
		public ExcludeFilterTypes(List<string> itemTypeFilters)
		{
			ItemTypeFilters = itemTypeFilters;
			FilterType = FilterType.Exclude;
			Items = DataHarvester.Items.Where((KeyValuePair<string, GraphItem> item) => !itemTypeFilters.Contains(item.Value.ItemType)).ToDictionary((KeyValuePair<string, GraphItem> pair) => pair.Key, (KeyValuePair<string, GraphItem> pair) => pair.Value);
			UnboundRecipes = DataHarvester.UnboundRecipes.Where((KeyValuePair<string, GraphRecipe> recipe) => !itemTypeFilters.Contains(recipe.Value.CraftedItem.Item1.ItemType) && !recipe.Value.RequiredItems.Any((KeyValuePair<GraphItem, int> requiredItem) => itemTypeFilters.Contains(requiredItem.Key.ItemType))).ToDictionary((KeyValuePair<string, GraphRecipe> pair) => pair.Key, (KeyValuePair<string, GraphRecipe> pair) => pair.Value);
			CraftingStations = (from station in DataHarvester.CraftingStations.ToDictionary((KeyValuePair<string, GraphCraftingStation> station) => station.Key, delegate(KeyValuePair<string, GraphCraftingStation> station)
				{
					station.Value.RemoveRecipesForTypes(itemTypeFilters);
					return station.Value;
				})
				where station.Value.Recipes.Count > 0
				select station).ToDictionary((KeyValuePair<string, GraphCraftingStation> kv) => kv.Key, (KeyValuePair<string, GraphCraftingStation> kv) => kv.Value);
			Processors = (from processor in DataHarvester.Processors.ToDictionary((KeyValuePair<string, GraphProcessor> processor) => processor.Key, delegate(KeyValuePair<string, GraphProcessor> processor)
				{
					processor.Value.RemoveRecipesForTypes(itemTypeFilters);
					return processor.Value;
				})
				where processor.Value.Recipes.Count > 0
				select processor).ToDictionary((KeyValuePair<string, GraphProcessor> kv) => kv.Key, (KeyValuePair<string, GraphProcessor> kv) => kv.Value);
			Drops = (from drop in DataHarvester.Drops.ToDictionary((KeyValuePair<Tuple<string, DropType>, List<GraphItem>> drop) => drop.Key, delegate(KeyValuePair<Tuple<string, DropType>, List<GraphItem>> drop)
				{
					List<GraphItem> collection = drop.Value.Where((GraphItem item) => !itemTypeFilters.Contains(item.ItemType)).ToList();
					drop.Value.Clear();
					drop.Value.AddRange(collection);
					return drop.Value;
				})
				where drop.Value.Count > 0
				select drop).ToDictionary((KeyValuePair<Tuple<string, DropType>, List<GraphItem>> kv) => kv.Key, (KeyValuePair<Tuple<string, DropType>, List<GraphItem>> kv) => kv.Value);
			Pieces = DataHarvester.Pieces.Where((KeyValuePair<string, GraphPiece> piece) => !piece.Value.BuildRequirements.Any((KeyValuePair<GraphItem, int> requirement) => itemTypeFilters.Contains(requirement.Key.ItemType))).ToDictionary((KeyValuePair<string, GraphPiece> pair) => pair.Key, (KeyValuePair<string, GraphPiece> pair) => pair.Value);
		}
	}
	public abstract class FilteredData
	{
		protected Dictionary<string, GraphItem> Items;

		protected Dictionary<string, GraphRecipe> UnboundRecipes;

		protected Dictionary<string, GraphCraftingStation> CraftingStations;

		protected Dictionary<string, GraphProcessor> Processors;

		protected Dictionary<Tuple<string, DropType>, List<GraphItem>> Drops;

		protected Dictionary<string, GraphPiece> Pieces;

		protected List<string> ItemTypeFilters;

		protected FilterType FilterType;

		public void LogOverview()
		{
			Logger.LogInfo("vvvv filtered data overview vvvv");
			Logger.LogInfo("  applied " + FilterType.ToString() + " filters: " + string.Join(", ", ItemTypeFilters));
			Logger.LogInfo($"    total {Items.Count} items registered");
			Logger.LogInfo($"    total {Drops.Count} drops registered");
			Logger.LogInfo($"    total {Pieces.Count} pieces registered");
			Logger.LogInfo($"    total {CraftingStations.Count} crafting stations registered");
			Logger.LogInfo($"    total {Processors.Count} processor stations (fermenter, smelter, ...) registered");
			Logger.LogInfo($"    total {UnboundRecipes.Count} unbound recipes registered");
			Logger.LogInfo("^^^^ filtered data overview ^^^^");
		}

		public DotGraph CreateGraph()
		{
			GraphBuilder graphBuilder = new GraphBuilder();
			Items.ToList().ForEach(delegate(KeyValuePair<string, GraphItem> item)
			{
				graphBuilder.AddNode(item.Value.ItemName, item.Value.ItemType);
			});
			foreach (KeyValuePair<Tuple<string, DropType>, List<GraphItem>> drop in Drops)
			{
				graphBuilder.AddNode(drop.Key.Item1, drop.Key.Item2.ToString());
				foreach (GraphItem item in drop.Value)
				{
					graphBuilder.AddNode(item);
					graphBuilder.AddEdge(drop.Key.Item1, item.ItemName);
				}
			}
			AddRecipesToGraph(graphBuilder, UnboundRecipes);
			foreach (KeyValuePair<string, GraphCraftingStation> craftingStation in CraftingStations)
			{
				graphBuilder.AddNode(craftingStation.Value.Name, NodeType.CraftingStation.ToString());
				foreach (string extensionName in craftingStation.Value.ExtensionNames)
				{
					graphBuilder.AddNode(extensionName, NodeType.CraftingStation.ToString());
					graphBuilder.AddEdge(extensionName, craftingStation.Value.Name);
				}
				AddRecipesToGraph(graphBuilder, craftingStation.Value.Recipes);
			}
			foreach (KeyValuePair<string, GraphProcessor> processor in Processors)
			{
				graphBuilder.AddNode(processor.Value.Name, NodeType.Processor.ToString());
				AddRecipesToGraph(graphBuilder, processor.Value.Recipes);
			}
			foreach (KeyValuePair<string, GraphPiece> piece in Pieces)
			{
				graphBuilder.AddNode(piece.Value.PieceName, NodeType.Piece.ToString());
				graphBuilder.AddNode(piece.Value.RequiredCraftingStation, NodeType.CraftingStation.ToString());
				graphBuilder.AddEdge(piece.Value.RequiredCraftingStation, piece.Value.PieceName);
				foreach (KeyValuePair<GraphItem, int> buildRequirement in piece.Value.BuildRequirements)
				{
					graphBuilder.AddNode(buildRequirement.Key);
					graphBuilder.AddEdge(buildRequirement.Key.ItemName, piece.Value.PieceName);
				}
			}
			return graphBuilder.BuildGraph();
		}

		private static void AddRecipesToGraph(GraphBuilder graphBuilder, Dictionary<string, GraphRecipe> recipes)
		{
			foreach (KeyValuePair<string, GraphRecipe> recipe in recipes)
			{
				graphBuilder.AddNode(recipe.Value.RecipeName, NodeType.Recipe.ToString());
				graphBuilder.AddNode(recipe.Value.CraftedItem.Item1);
				graphBuilder.AddEdge(recipe.Value.RecipeName, recipe.Value.CraftedItem.Item1.ItemName);
				foreach (KeyValuePair<GraphItem, int> requiredItem in recipe.Value.RequiredItems)
				{
					graphBuilder.AddNode(requiredItem.Key);
					graphBuilder.AddEdge(requiredItem.Key.ItemName, recipe.Value.RecipeName);
				}
			}
		}
	}
	public class IncludeFilterTypes : FilteredData
	{
		public IncludeFilterTypes(List<string> itemTypeFilters)
		{
			ItemTypeFilters = itemTypeFilters;
			FilterType = FilterType.Include;
			Items = DataHarvester.Items.Where((KeyValuePair<string, GraphItem> item) => itemTypeFilters.Contains(item.Value.ItemType)).ToDictionary((KeyValuePair<string, GraphItem> pair) => pair.Key, (KeyValuePair<string, GraphItem> pair) => pair.Value);
			UnboundRecipes = DataHarvester.UnboundRecipes.Where((KeyValuePair<string, GraphRecipe> recipe) => itemTypeFilters.Contains(recipe.Value.CraftedItem.Item1.ItemType) || recipe.Value.RequiredItems.Any((KeyValuePair<GraphItem, int> requiredItem) => itemTypeFilters.Contains(requiredItem.Key.ItemType))).ToDictionary((KeyValuePair<string, GraphRecipe> pair) => pair.Key, (KeyValuePair<string, GraphRecipe> pair) => pair.Value);
			CraftingStations = DataHarvester.CraftingStations.Where((KeyValuePair<string, GraphCraftingStation> station) => station.Value.ContainsItemTypes(itemTypeFilters)).ToDictionary((KeyValuePair<string, GraphCraftingStation> pair) => pair.Key, (KeyValuePair<string, GraphCraftingStation> pair) => pair.Value);
			Processors = DataHarvester.Processors.Where((KeyValuePair<string, GraphProcessor> processor) => processor.Value.ContainsItemTypes(itemTypeFilters)).ToDictionary((KeyValuePair<string, GraphProcessor> pair) => pair.Key, (KeyValuePair<string, GraphProcessor> pair) => pair.Value);
			Drops = DataHarvester.Drops.Where((KeyValuePair<Tuple<string, DropType>, List<GraphItem>> drop) => drop.Value.Any((GraphItem item) => itemTypeFilters.Contains(item.ItemType))).ToDictionary((KeyValuePair<Tuple<string, DropType>, List<GraphItem>> pair) => pair.Key, (KeyValuePair<Tuple<string, DropType>, List<GraphItem>> pair) => pair.Value);
			Pieces = DataHarvester.Pieces.Where((KeyValuePair<string, GraphPiece> piece) => piece.Value.BuildRequirements.Any((KeyValuePair<GraphItem, int> requirement) => itemTypeFilters.Contains(requirement.Key.ItemType))).ToDictionary((KeyValuePair<string, GraphPiece> pair) => pair.Key, (KeyValuePair<string, GraphPiece> pair) => pair.Value);
		}
	}
	public class UnfilteredData : FilteredData
	{
		public UnfilteredData()
		{
			FilterType = FilterType.Unfiltered;
			ItemTypeFilters = new List<string>();
			Items = DataHarvester.Items;
			UnboundRecipes = DataHarvester.UnboundRecipes;
			CraftingStations = DataHarvester.CraftingStations;
			Processors = DataHarvester.Processors;
			Drops = DataHarvester.Drops;
			Pieces = DataHarvester.Pieces;
		}
	}
}
namespace PrefabDependencyTree.Data.Drops
{
	public class CharacterDropInitializer : DropsInitializer<CharacterDrop, Drop>
	{
		protected override Dictionary<Tuple<string, DropType>, CharacterDrop> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(Character))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Character)), (Func<KeyValuePair<string, Object>, CharacterDrop>)((KeyValuePair<string, Object> kv) => (CharacterDrop)((Component)(Character)kv.Value).GetComponent(typeof(CharacterDrop))));
		}

		protected override List<Drop> GetDropList(CharacterDrop input)
		{
			if ((Object)(object)input != (Object)null && input.m_drops != null)
			{
				return input.m_drops.ToList();
			}
			return new List<Drop>();
		}

		protected override GameObject GetObject(Drop input)
		{
			return input.m_prefab;
		}
	}
	public class ContainerDropsInitializer : DropsInitializerDropData<Container>
	{
		protected override Dictionary<Tuple<string, DropType>, Container> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(Container))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Container)), (Func<KeyValuePair<string, Object>, Container>)((KeyValuePair<string, Object> kv) => (Container)kv.Value));
		}

		protected override List<DropData> GetDropList(Container input)
		{
			if (input.m_defaultItems != null)
			{
				return FromTable(input.m_defaultItems);
			}
			Logger.LogWarning($"'m_defaultItems' not found for {typeof(Container)}");
			return new List<DropData>();
		}
	}
	public class DestructibleDropsInitializer : DropsInitializerDropData<DropOnDestroyed>
	{
		protected override Dictionary<Tuple<string, DropType>, DropOnDestroyed> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(DropOnDestroyed))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Destructible)), (Func<KeyValuePair<string, Object>, DropOnDestroyed>)((KeyValuePair<string, Object> kv) => (DropOnDestroyed)kv.Value));
		}

		protected override List<DropData> GetDropList(DropOnDestroyed input)
		{
			if (input.m_dropWhenDestroyed != null)
			{
				return FromTable(input.m_dropWhenDestroyed);
			}
			Logger.LogWarning($"'m_dropWhenDestroyed' not found for {typeof(DropOnDestroyed)}");
			return new List<DropData>();
		}
	}
	public class LootSpawnerDropsInitializer : DropsInitializerDropData<LootSpawner>
	{
		protected override Dictionary<Tuple<string, DropType>, LootSpawner> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(LootSpawner))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.LootSpawner)), (Func<KeyValuePair<string, Object>, LootSpawner>)((KeyValuePair<string, Object> kv) => (LootSpawner)kv.Value));
		}

		protected override List<DropData> GetDropList(LootSpawner input)
		{
			if (input.m_items != null)
			{
				return FromTable(input.m_items);
			}
			Logger.LogWarning($"'m_items' not found for {typeof(LootSpawner)}");
			return new List<DropData>();
		}
	}
	public class MineRock5DropInitializer : DropsInitializerDropData<MineRock5>
	{
		protected override Dictionary<Tuple<string, DropType>, MineRock5> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(MineRock5))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.MineRock)), (Func<KeyValuePair<string, Object>, MineRock5>)((KeyValuePair<string, Object> kv) => (MineRock5)kv.Value));
		}

		protected override List<DropData> GetDropList(MineRock5 input)
		{
			if (input.m_dropItems != null)
			{
				return FromTable(input.m_dropItems);
			}
			Logger.LogWarning($"'m_dropItems' not found for {typeof(MineRock5)}");
			return new List<DropData>();
		}
	}
	public class MineRockDropsInitializer : DropsInitializerDropData<MineRock>
	{
		protected override Dictionary<Tuple<string, DropType>, MineRock> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(MineRock))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.MineRock)), (Func<KeyValuePair<string, Object>, MineRock>)((KeyValuePair<string, Object> kv) => (MineRock)kv.Value));
		}

		protected override List<DropData> GetDropList(MineRock input)
		{
			if (input.m_dropItems != null)
			{
				return FromTable(input.m_dropItems);
			}
			Logger.LogWarning($"'m_dropItems' not found for {typeof(MineRock)}");
			return new List<DropData>();
		}
	}
	public class PickableDropInitializer : DropsInitializer<Pickable, GameObject>
	{
		protected override Dictionary<Tuple<string, DropType>, Pickable> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(Pickable))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Pickable)), (Func<KeyValuePair<string, Object>, Pickable>)((KeyValuePair<string, Object> kv) => (Pickable)kv.Value));
		}

		protected override List<GameObject> GetDropList(Pickable input)
		{
			return new List<GameObject> { input.m_itemPrefab };
		}

		protected override GameObject GetObject(GameObject input)
		{
			return input;
		}
	}
	public class PickableExtraDropInitializer : DropsInitializerDropData<Pickable>
	{
		protected override Dictionary<Tuple<string, DropType>, Pickable> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(Pickable))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Pickable)), (Func<KeyValuePair<string, Object>, Pickable>)((KeyValuePair<string, Object> kv) => (Pickable)kv.Value));
		}

		protected override List<DropData> GetDropList(Pickable input)
		{
			if (input.m_extraDrops != null)
			{
				return FromTable(input.m_extraDrops);
			}
			Logger.LogWarning($"'m_extraDrops' not found for {typeof(Pickable)}");
			return new List<DropData>();
		}
	}
	public class PickableItemDropInitializer : DropsInitializer<PickableItem, ItemDrop>
	{
		protected override Dictionary<Tuple<string, DropType>, PickableItem> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(PickableItem))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Pickable)), (Func<KeyValuePair<string, Object>, PickableItem>)((KeyValuePair<string, Object> kv) => (PickableItem)kv.Value));
		}

		protected override List<ItemDrop> GetDropList(PickableItem input)
		{
			return new List<ItemDrop> { input.m_itemPrefab };
		}

		protected override GameObject GetObject(ItemDrop input)
		{
			return ((Component)input).gameObject;
		}
	}
	public class PickableItemRandomDropInitializer : DropsInitializer<PickableItem, RandomItem>
	{
		protected override Dictionary<Tuple<string, DropType>, PickableItem> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(PickableItem))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Pickable)), (Func<KeyValuePair<string, Object>, PickableItem>)((KeyValuePair<string, Object> kv) => (PickableItem)kv.Value));
		}

		protected override List<RandomItem> GetDropList(PickableItem input)
		{
			if (input.m_randomItemPrefabs != null)
			{
				return input.m_randomItemPrefabs.ToList();
			}
			Logger.LogWarning($"'m_randomItemPrefabs' not found for {typeof(PickableItem)}");
			return new List<RandomItem>();
		}

		protected override GameObject GetObject(RandomItem input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)input.m_itemPrefab).gameObject;
		}
	}
	public class TreeBaseDropsInitializer : DropsInitializerDropData<TreeBase>
	{
		protected override Dictionary<Tuple<string, DropType>, TreeBase> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(TreeBase))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Tree)), (Func<KeyValuePair<string, Object>, TreeBase>)((KeyValuePair<string, Object> kv) => (TreeBase)kv.Value));
		}

		protected override List<DropData> GetDropList(TreeBase input)
		{
			if (input.m_dropWhenDestroyed != null)
			{
				return FromTable(input.m_dropWhenDestroyed);
			}
			Logger.LogWarning($"'m_dropWhenDestroyed' not found for {typeof(TreeBase)}");
			return new List<DropData>();
		}
	}
	public class TreeLogDropsInitializer : DropsInitializerDropData<TreeLog>
	{
		protected override Dictionary<Tuple<string, DropType>, TreeLog> GetGameObjects()
		{
			return ((IEnumerable<KeyValuePair<string, Object>>)Cache.GetPrefabs(typeof(TreeLog))).ToDictionary((Func<KeyValuePair<string, Object>, Tuple<string, DropType>>)((KeyValuePair<string, Object> kv) => Tuple.Create(kv.Key, DropType.Tree)), (Func<KeyValuePair<string, Object>, TreeLog>)((KeyValuePair<string, Object> kv) => (TreeLog)kv.Value));
		}

		protected override List<DropData> GetDropList(TreeLog input)
		{
			if (input.m_dropWhenDestroyed != null)
			{
				return FromTable(input.m_dropWhenDestroyed);
			}
			Logger.LogWarning($"'m_dropWhenDestroyed' not found for {typeof(TreeLog)}");
			return new List<DropData>();
		}
	}
}
namespace PrefabDependencyTree.Data.Drops.Generic
{
	public abstract class DropsInitializer<T, U> : Initializer
	{
		protected abstract Dictionary<Tuple<string, DropType>, T> GetGameObjects();

		protected abstract List<U> GetDropList(T input);

		protected abstract GameObject GetObject(U input);

		public void InitializeDrops()
		{
			int count = DataHarvester.Drops.Count;
			foreach (KeyValuePair<Tuple<string, DropType>, T> gameObject in GetGameObjects())
			{
				List<U> list = (from drop in GetDropList(gameObject.Value)
					where drop != null
					select drop).ToList();
				if (list.Count <= 0)
				{
					Logger.LogInfo($"{typeof(T)} '{gameObject.Key}' does not have drop data - skipping");
					continue;
				}
				List<GraphItem> value;
				List<GraphItem> list2 = (DataHarvester.Drops.TryGetValue(gameObject.Key, out value) ? value : new List<GraphItem>());
				foreach (U item in list)
				{
					if (item == null)
					{
						Logger.LogInfo($"{typeof(T)} - {typeof(U)}: found null drop in drop data (length {list.Count})");
						continue;
					}
					object obj = item;
					ItemDrop val = (ItemDrop)((obj is ItemDrop) ? obj : null);
					if (val != null)
					{
						list2.Add(GraphItem.GetOrCreate(val));
						continue;
					}
					GraphItem orCreate = GraphItem.GetOrCreate(GetObject(item));
					if (orCreate != null)
					{
						list2.Add(orCreate);
					}
				}
				DataHarvester.Drops[Tuple.Create(gameObject.Key.Item1, gameObject.Key.Item2)] = list2.Distinct().ToList();
			}
			Logger.LogInfo($"loaded {DataHarvester.Drops.Count - count} drops from {typeof(T)} ({typeof(U)}) from game");
		}
	}
	public abstract class DropsInitializerDropData<T> : DropsInitializer<T, DropData>
	{
		protected override GameObject GetObject(DropData input)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return input.m_item;
		}

		protected List<DropData> FromTable(DropTable table)
		{
			if (table != null)
			{
				return table.m_drops;
			}
			Logger.LogWarning($"missing drop table for type '{typeof(T)}'");
			return new List<DropData>();
		}
	}
	public interface Initializer
	{
		void InitializeDrops();
	}
}
namespace DotNetGraph.Extensions
{
	internal static class DotBaseGraphExtensions
	{
		public static T WithIdentifier<T>(this T graph, string identifier, bool isHtml = false) where T : DotBaseGraph
		{
			graph.Identifier = new DotIdentifier(identifier, isHtml);
			return graph;
		}

		public static T WithRankDir<T>(this T graph, DotRankDir rankDir) where T : DotBaseGraph
		{
			graph.RankDir = new DotRankDirAttribute(rankDir);
			return graph;
		}

		public static T Add<T>(this T graph, IDotElement element) where T : DotBaseGraph
		{
			graph.Elements.Add(element);
			return graph;
		}
	}
	internal static class DotEdgeExtensions
	{
		public static DotEdge From(this DotEdge edge, string from, bool isHtml = false)
		{
			edge.From = new DotIdentifier(from, isHtml);
			return edge;
		}

		public static DotEdge From(this DotEdge edge, DotNode from)
		{
			edge.From = from.Identifier;
			return edge;
		}

		public static DotEdge To(this DotEdge edge, string to, bool isHtml = false)
		{
			edge.To = new DotIdentifier(to, isHtml);
			return edge;
		}

		public static DotEdge To(this DotEdge edge, DotNode to)
		{
			edge.To = to.Identifier;
			return edge;
		}

		public static DotEdge WithColor(this DotEdge edge, string color)
		{
			edge.Color = new DotColorAttribute(color);
			return edge;
		}

		public static DotEdge WithColor(this DotEdge edge, DotColor color)
		{
			edge.Color = new DotColorAttribute(color);
			return edge;
		}

		public static DotEdge WithStyle(this DotEdge edge, string style)
		{
			edge.Style = new DotEdgeStyleAttribute(style);
			return edge;
		}

		public static DotEdge WithStyle(this DotEdge edge, DotEdgeStyle style)
		{
			edge.Style = new DotEdgeStyleAttribute(style);
			return edge;
		}

		public static DotEdge WithPenWidth(this DotEdge edge, double width)
		{
			edge.PenWidth = new DotDoubleAttribute(width);
			return edge;
		}

		public static DotEdge WithArrowHead(this DotEdge edge, string arrowType)
		{
			edge.ArrowHead = new DotEdgeArrowTypeAttribute(arrowType);
			return edge;
		}

		public static DotEdge WithArrowHead(this DotEdge edge, DotEdgeArrowType arrowType)
		{
			edge.ArrowHead = new DotEdgeArrowTypeAttribute(arrowType);
			return edge;
		}

		public static DotEdge WithArrowTail(this DotEdge edge, string arrowType)
		{
			edge.ArrowTail = new DotEdgeArrowTypeAttribute(arrowType);
			return edge;
		}

		public static DotEdge WithArrowTail(this DotEdge edge, DotEdgeArrowType arrowType)
		{
			edge.ArrowTail = new DotEdgeArrowTypeAttribute(arrowType);
			return edge;
		}

		public static DotEdge WithPos(this DotEdge edge, string value)
		{
			edge.Pos = new DotPointAttribute(value);
			return edge;
		}

		public static DotEdge WithPos(this DotEdge edge, int x, int y, bool @fixed = false)
		{
			edge.Pos = new DotPointAttribute(new DotPoint(x, y, @fixed));
			return edge;
		}

		public static DotEdge WithPos(this DotEdge edge, int x, int y, int z, bool @fixed = false)
		{
			edge.Pos = new DotPointAttribute(new DotPoint(x, y, z, @fixed));
			return edge;
		}
	}
	internal static class DotElementExtensions
	{
		public static T WithAttribute<T>(this T element, string name, IDotAttribute attribute) where T : DotElement
		{
			element.SetAttribute(name, attribute);
			return element;
		}

		public static T WithAttribute<T>(this T element, string name, string value) where T : DotElement
		{
			element.SetAttribute(name, new DotAttribute(value));
			return element;
		}

		public static T WithLabel<T>(this T element, string label, bool isHtml = false) where T : DotElement
		{
			element.Label = new DotLabelAttribute(label, isHtml);
			return element;
		}

		public static T WithFontColor<T>(this T element, string color) where T : DotElement
		{
			element.FontColor = new DotColorAttribute(color);
			return element;
		}

		public static T WithFontColor<T>(this T element, DotColor color) where T : DotElement
		{
			element.FontColor = new DotColorAttribute(color);
			return element;
		}
	}
	internal static class DotGraphExtensions
	{
		public static DotGraph Directed(this DotGraph graph, bool directed = true)
		{
			graph.Directed = directed;
			return graph;
		}

		public static DotGraph Strict(this DotGraph graph, bool strict = true)
		{
			graph.Strict = strict;
			return graph;
		}
	}
	internal static class DotNodeExtensions
	{
		public static DotNode WithIdentifier(this DotNode node, string identifier, bool isHtml = false)
		{
			node.Identifier = new DotIdentifier(identifier, isHtml);
			return node;
		}

		public static DotNode WithColor(this DotNode node, string color)
		{
			node.Color = new DotColorAttribute(color);
			return node;
		}

		public static DotNode WithColor(this DotNode node, DotColor color)
		{
			node.Color = new DotColorAttribute(color);
			return node;
		}

		public static DotNode WithFillColor(this DotNode node, string color)
		{
			node.FillColor = new DotColorAttribute(color);
			return node;
		}

		public static DotNode WithFillColor(this DotNode node, DotColor color)
		{
			node.FillColor = new DotColorAttribute(color);
			return node;
		}

		public static DotNode WithShape(this DotNode node, string shape)
		{
			node.Shape = new DotNodeShapeAttribute(shape);
			return node;
		}

		public static DotNode WithShape(this DotNode node, DotNodeShape shape)
		{
			node.Shape = new DotNodeShapeAttribute(shape);
			return node;
		}

		public static DotNode WithStyle(this DotNode node, string style)
		{
			node.Style = new DotNodeStyleAttribute(style);
			return node;
		}

		public static DotNode WithStyle(this DotNode node, DotNodeStyle style)
		{
			node.Style = new DotNodeStyleAttribute(style);
			return node;
		}

		public static DotNode WithWidth(this DotNode node, double width)
		{
			node.Width = new DotDoubleAttribute(width);
			return node;
		}

		public static DotNode WithHeight(this DotNode node, double height)
		{
			node.Height = new DotDoubleAttribute(height);
			return node;
		}

		public static DotNode WithPenWidth(this DotNode node, double width)
		{
			node.PenWidth = new DotDoubleAttribute(width);
			return node;
		}

		public static DotNode WithPos(this DotNode node, string value)
		{
			node.Pos = new DotPointAttribute(value);
			return node;
		}

		public static DotNode WithPos(this DotNode node, int x, int y, bool @fixed = false)
		{
			node.Pos = new DotPointAttribute(new DotPoint(x, y, @fixed));
			return node;
		}

		public static DotNode WithPos(this DotNode node, int x, int y, int z, bool @fixed = false)
		{
			node.Pos = new DotPointAttribute(new DotPoint(x, y, z, @fixed));
			return node;
		}
	}
	internal static class DotSubgraphExtensions
	{
		public static DotSubgraph WithColor(this DotSubgraph subgraph, string color)
		{
			subgraph.Color = new DotColorAttribute(color);
			return subgraph;
		}

		public static DotSubgraph WithColor(this DotSubgraph subgraph, DotColor color)
		{
			subgraph.Color = new DotColorAttribute(color);
			return subgraph;
		}

		public static DotSubgraph WithStyle(this DotSubgraph subgraph, string style)
		{
			subgraph.Style = new DotSubgraphStyleAttribute(style);
			return subgraph;
		}

		public static DotSubgraph WithStyle(this DotSubgraph subgraph, DotSubgraphStyle style)
		{
			subgraph.Style = new DotSubgraphStyleAttribute(style);
			return subgraph;
		}
	}
	internal static class EnumExtensions
	{
		public static string FlagsToString<T>(this T enumValue) where T : Enum
		{
			if (typeof(T).GetCustomAttribute<FlagsAttribute>() == null)
			{
				throw new InvalidOperationException($"The type '{typeof(T)}' doesn't have the [Flags] attribute specified.");
			}
			return string.Join(",", from T a in Enum.GetValues(typeof(T))
				where enumValue.HasFlag(a)
				select a.ToString().ToLowerInvariant());
		}
	}
	internal static class StringExtensions
	{
		internal static string FormatGraphvizEscapedCharacters(this string value)
		{
			return value?.Replace("\\", "\\\\").Replace("\"", "\\\"").Replace("\r\n", "\\n")
				.Replace("\n", "\\n");
		}
	}
}
namespace DotNetGraph.Core
{
	internal abstract class DotBaseGraph : DotElement
	{
		public DotIdentifier Identifier { get; set; }

		public DotRankDirAttribute RankDir
		{
			get
			{
				return GetAttributeOrDefault<DotRankDirAttribute>("rankdir");
			}
			set
			{
				SetAttribute("rankdir", value);
			}
		}

		public List<IDotElement> Elements { get; } = new List<IDotElement>();


		public DotNode GetNodeByIdentifier(string identifier, bool isHtml = false)
		{
			return Elements.Where((IDotElement e) => e is DotNode).Cast<DotNode>().FirstOrDefault((DotNode node) => node.Identifier == new DotIdentifier(identifier, isHtml));
		}

		public abstract override Task CompileAsync(CompilationContext context);

		protected async Task CompileBodyAsync(CompilationContext context)
		{
			await Identifier.CompileAsync(context);
			await context.WriteLineAsync(" {");
			context.IndentationLevel++;
			await CompileAttributesAsync(context);
			foreach (IDotElement element in Elements)
			{
				await element.CompileAsync(context);
			}
			context.IndentationLevel--;
			await context.WriteIndentationAsync();
			await context.WriteLineAsync("}");
		}
	}
	internal struct DotColor : IEquatable<DotColor>
	{
		public byte R;

		public byte G;

		public byte B;

		public byte A;

		public static DotColor AliceBlue { get; } = new DotColor(240, 248, byte.MaxValue);


		public static DotColor AntiqueWhite { get; } = new DotColor(250, 235, 215);


		public static DotColor Aqua { get; } = new DotColor(0, byte.MaxValue, byte.MaxValue);


		public static DotColor Aquamarine { get; } = new DotColor(127, byte.MaxValue, 212);


		public static DotColor Azure { get; } = new DotColor(240, byte.MaxValue, byte.MaxValue);


		public static DotColor Beige { get; } = new DotColor(245, 245, 220);


		public static DotColor Bisque { get; } = new DotColor(byte.MaxValue, 228, 196);


		public static DotColor Black { get; } = new DotColor(0, 0, 0);


		public static DotColor BlanchedAlmond { get; } = new DotColor(byte.MaxValue, 235, 205);


		public static DotColor Blue { get; } = new DotColor(0, 0, byte.MaxValue);


		public static DotColor BlueViolet { get; } = new DotColor(138, 43, 226);


		public static DotColor Brown { get; } = new DotColor(165, 42, 42);


		public static DotColor Burlywood { get; } = new DotColor(222, 184, 135);


		public static DotColor CadetBlue { get; } = new DotColor(95, 158, 160);


		public static DotColor Chartreuse { get; } = new DotColor(127, byte.MaxValue, 0);


		public static DotColor Chocolate { get; } = new DotColor(210, 105, 30);


		public static DotColor Coral { get; } = new DotColor(byte.MaxValue, 127, 80);


		public static DotColor CornflowerBlue { get; } = new DotColor(100, 149, 237);


		public static DotColor Cornsilk { get; } = new DotColor(byte.MaxValue, 248, 220);


		public static DotColor Crimson { get; } = new DotColor(220, 20, 60);


		public static DotColor Cyan { get; } = new DotColor(0, byte.MaxValue, byte.MaxValue);


		public static DotColor DarkBlue { get; } = new DotColor(0, 0, 139);


		public static DotColor DarkCyan { get; } = new DotColor(0, 139, 139);


		public static DotColor DarkGoldenrod { get; } = new DotColor(184, 134, 11);


		public static DotColor DarkGray { get; } = new DotColor(169, 169, 169);


		public static DotColor DarkGreen { get; } = new DotColor(0, 100, 0);


		public static DotColor DarkGrey { get; } = new DotColor(169, 169, 169);


		public static DotColor DarkKhaki { get; } = new DotColor(189, 183, 107);


		public static DotColor DarkMagenta { get; } = new DotColor(139, 0, 139);


		public static DotColor DarkOliveGreen { get; } = new DotColor(85, 107, 47);


		public static DotColor Darkorange { get; } = new DotColor(byte.MaxValue, 140, 0);


		public static DotColor DarkOrchid { get; } = new DotColor(153, 50, 204);


		public static DotColor DarkRed { get; } = new DotColor(139, 0, 0);


		public static DotColor DarkSalmon { get; } = new DotColor(233, 150, 122);


		public static DotColor DarkSeaGreen { get; } = new DotColor(143, 188, 143);


		public static DotColor DarkSlateBlue { get; } = new DotColor(72, 61, 139);


		public static DotColor DarkSlateGray { get; } = new DotColor(47, 79, 79);


		public static DotColor DarkSlateGrey { get; } = new DotColor(47, 79, 79);


		public static DotColor DarkTurquoise { get; } = new DotColor(0, 206, 209);


		public static DotColor DarkViolet { get; } = new DotColor(148, 0, 211);


		public static DotColor DeepPink { get; } = new DotColor(byte.MaxValue, 20, 147);


		public static DotColor DeepSkyBlue { get; } = new DotColor(0, 191, byte.MaxValue);


		public static DotColor DimGray { get; } = new DotColor(105, 105, 105);


		public static DotColor DimGrey { get; } = new DotColor(105, 105, 105);


		public static DotColor DodgerBlue { get; } = new DotColor(30, 144, byte.MaxValue);


		public static DotColor Firebrick { get; } = new DotColor(178, 34, 34);


		public static DotColor FloralWhite { get; } = new DotColor(byte.MaxValue, 250, 240);


		public static DotColor ForestGreen { get; } = new DotColor(34, 139, 34);


		public static DotColor Fuchsia { get; } = new DotColor(byte.MaxValue, 0, byte.MaxValue);


		public static DotColor Gainsboro { get; } = new DotColor(220, 220, 220);


		public static DotColor GhostWhite { get; } = new DotColor(248, 248, byte.MaxValue);


		public static DotColor Gold { get; } = new DotColor(byte.MaxValue, 215, 0);


		public static DotColor Goldenrod { get; } = new DotColor(218, 165, 32);


		public static DotColor Gray { get; } = new DotColor(128, 128, 128);


		public static DotColor Green { get; } = new DotColor(0, 128, 0);


		public static DotColor GreenYellow { get; } = new DotColor(173, byte.MaxValue, 47);


		public static DotColor Grey { get; } = new DotColor(128, 128, 128);


		public static DotColor Honeydew { get; } = new DotColor(240, byte.MaxValue, 240);


		public static DotColor HotPink { get; } = new DotColor(byte.MaxValue, 105, 180);


		public static DotColor IndianRed { get; } = new DotColor(205, 92, 92);


		public static DotColor Indigo { get; } = new DotColor(75, 0, 130);


		public static DotColor Ivory { get; } = new DotColor(byte.MaxValue, byte.MaxValue, 240);


		public static DotColor Khaki { get; } = new DotColor(240, 230, 140);


		public static DotColor Lavender { get; } = new DotColor(230, 230, 250);


		public static DotColor LavenderBlush { get; } = new DotColor(byte.MaxValue, 240, 245);


		public static DotColor LawnGreen { get; } = new DotColor(124, 252, 0);


		public static DotColor LemonChiffon { get; } = new DotColor(byte.MaxValue, 250, 205);


		public static DotColor LightBlue { get; } = new DotColor(173, 216, 230);


		public static DotColor LightCoral { get; } = new DotColor(240, 128, 128);


		public static DotColor LightCyan { get; } = new DotColor(224, byte.MaxValue, byte.MaxValue);


		public static DotColor LightGoldenrodYellow { get; } = new DotColor(250, 250, 210);


		public static DotColor LightGray { get; } = new DotColor(211, 211, 211);


		public static DotColor LightGrey { get; } = new DotColor(211, 211, 211);


		public static DotColor LightGreen { get; } = new DotColor(144, 238, 144);


		public static DotColor LightPink { get; } = new DotColor(byte.MaxValue, 182, 193);


		public static DotColor LightSalmon { get; } = new DotColor(byte.MaxValue, 160, 122);


		public static DotColor LightSeaGreen { get; } = new DotColor(32, 178, 170);


		public static DotColor LightSkyBlue { get; } = new DotColor(135, 206, 250);


		public static DotColor LightSlateGray { get; } = new DotColor(119, 136, 153);


		public static DotColor LightSlateGrey { get; } = new DotColor(119, 136, 153);


		public static DotColor LightSteelBlue { get; } = new DotColor(176, 196, 222);


		public static DotColor LightYellow { get; } = new DotColor(byte.MaxValue, byte.MaxValue, 224);


		public static DotColor Lime { get; } = new DotColor(0, byte.MaxValue, 0);


		public static DotColor LimeGreen { get; } = new DotColor(50, 205, 50);


		public static DotColor Linen { get; } = new DotColor(250, 240, 230);


		public static DotColor Magenta { get; } = new DotColor(byte.MaxValue, 0, byte.MaxValue);


		public static DotColor Maroon { get; } = new DotColor(128, 0, 0);


		public static DotColor MediumAquamarine { get; } = new DotColor(102, 205, 170);


		public static DotColor MediumBlue { get; } = new DotColor(0, 0, 205);


		public static DotColor MediumOrchid { get; } = new DotColor(186, 85, 211);


		public static DotColor MediumPurple { get; } = new DotColor(147, 112, 219);


		public static DotColor MediumSeaGreen { get; } = new DotColor(60, 179, 113);


		public static DotColor MediumSlateBlue { get; } = new DotColor(123, 104, 238);


		public static DotColor MediumSpringGreen { get; } = new DotColor(0, 250, 154);


		public static DotColor MediumTurquoise { get; } = new DotColor(72, 209, 204);


		public static DotColor MediumVioletRed { get; } = new DotColor(199, 21, 133);


		public static DotColor MidnightBlue { get; } = new DotColor(25, 25, 112);


		public static DotColor MintCream { get; } = new DotColor(245, byte.MaxValue, 250);


		public static DotColor MistyRose { get; } = new DotColor(byte.MaxValue, 228, 225);


		public static DotColor Moccasin { get; } = new DotColor(byte.MaxValue, 228, 181);


		public static DotColor NavajoWhite { get; } = new DotColor(byte.MaxValue, 222, 173);


		public static DotColor Navy { get; } = new DotColor(0, 0, 128);


		public static DotColor OldLace { get; } = new DotColor(253, 245, 230);


		public static DotColor Olive { get; } = new DotColor(128, 128, 0);


		public static DotColor OliveDrab { get; } = new DotColor(107, 142, 35);


		public static DotColor Orange { get; } = new DotColor(byte.MaxValue, 165, 0);


		public static DotColor OrangeRed { get; } = new DotColor(byte.MaxValue, 69, 0);


		public static DotColor Orchid { get; } = new DotColor(218, 112, 214);


		public static DotColor PaleGoldenrod { get; } = new DotColor(238, 232, 170);


		public static DotColor PaleGreen { get; } = new DotColor(152, 251, 152);


		public static DotColor PaleTurquoise { get; } = new DotColor(175, 238, 238);


		public static DotColor PaleVioletRed { get; } = new DotColor(219, 112, 147);


		public static DotColor PapayaWhip { get; } = new DotColor(byte.MaxValue, 239, 213);


		public static DotColor PeachPuff { get; } = new DotColor(byte.MaxValue, 218, 185);


		public static DotColor Peru { get; } = new DotColor(205, 133, 63);


		public static DotColor Pink { get; } = new DotColor(byte.MaxValue, 192, 203);


		public static DotColor Plum { get; } = new DotColor(221, 160, 221);


		public static DotColor PowderBlue { get; } = new DotColor(176, 224, 230);


		public static DotColor Purple { get; } = new DotColor(128, 0, 128);


		public static DotColor Red { get; } = new DotColor(byte.MaxValue, 0, 0);


		public static DotColor RosyBrown { get; } = new DotColor(188, 143, 143);


		public static DotColor RoyalBlue { get; } = new DotColor(65, 105, 225);


		public static DotColor SaddleBrown { get; } = new DotColor(139, 69, 19);


		public static DotColor Salmon { get; } = new DotColor(250, 128, 114);


		public static DotColor SandyBrown { get; } = new DotColor(244, 164, 96);


		public static DotColor SeaGreen { get; } = new DotColor(46, 139, 87);


		public static DotColor SeaShell { get; } = new DotColor(byte.MaxValue, 245, 238);


		public static DotColor Sienna { get; } = new DotColor(160, 82, 45);


		public static DotColor Silver { get; } = new DotColor(192, 192, 192);


		public static DotColor SkyBlue { get; } = new DotColor(135, 206, 235);


		public static DotColor SlateBlue { get; } = new DotColor(106, 90, 205);


		public static DotColor SlateGray { get; } = new DotColor(112, 128, 144);


		public static DotColor SlateGrey { get; } = new DotColor(112, 128, 144);


		public static DotColor Snow { get; } = new DotColor(byte.MaxValue, 250, 250);


		public static DotColor SpringGreen { get; } = new DotColor(0, byte.MaxValue, 127);


		public static DotColor SteelBlue { get; } = new DotColor(70, 130, 180);


		public static DotColor Tan { get; } = new DotColor(210, 180, 140);


		public static DotColor Teal { get; } = new DotColor(0, 128, 128);


		public static DotColor Thistle { get; } = new DotColor(216, 191, 216);


		public static DotColor Tomato { get; } = new DotColor(byte.MaxValue, 99, 71);


		public static DotColor Turquoise { get; } = new DotColor(64, 224, 208);


		public static DotColor Violet { get; } = new DotColor(238, 130, 238);


		public static DotColor Wheat { get; } = new DotColor(245, 222, 179);


		public static DotColor White { get; } = new DotColor(byte.MaxValue, byte.MaxValue, byte.MaxValue);


		public static DotColor WhiteSmoke { get; } = new DotColor(245, 245, 245);


		public static DotColor Yellow { get; } = new DotColor(byte.MaxValue, byte.MaxValue, 0);


		public static DotColor YellowGreen { get; } = new DotColor(154, 205, 50);


		public DotColor(byte r, byte g, byte b, byte a = byte.MaxValue)
		{
			R = r;
			G = g;
			B = b;
			A = a;
		}

		public bool Equals(DotColor other)
		{
			if (R == other.R && G == other.G && B == other.B)
			{
				return A == other.A;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj is DotColor other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return (((((R.GetHashCode() * 397) ^ G.GetHashCode()) * 397) ^ B.GetHashCode()) * 397) ^ A.GetHashCode();
		}

		public override string ToString()
		{
			return $"[DotColor, R:{R}, G:{G}, B:{B}, A:{A}]";
		}

		public string ToHexString()
		{
			if (A != byte.MaxValue)
			{
				return $"#{R:X2}{G:X2}{B:X2}{A:X2}";
			}
			return $"#{R:X2}{G:X2}{B:X2}";
		}
	}
	internal class DotEdge : DotElement
	{
		public DotIdentifier From { get; set; }

		public DotIdentifier To { get; set; }

		public DotColorAttribute Color
		{
			get
			{
				return GetAttributeOrDefault<DotColorAttribute>("color");
			}
			set
			{
				SetAttribute("color", value);
			}
		}

		public DotEdgeStyleAttribute Style
		{
			get
			{
				return GetAttributeOrDefault<DotEdgeStyleAttribute>("style");
			}
			set
			{
				SetAttribute("style", value);
			}
		}

		public DotDoubleAttribute PenWidth
		{
			get
			{
				return GetAttribute<DotDoubleAttribute>("penwidth");
			}
			set
			{
				SetAttribute("penwidth", value);
			}
		}

		public DotEdgeArrowTypeAttribute ArrowHead
		{
			get
			{
				return GetAttribute<DotEdgeArrowTypeAttribute>("arrowhead");
			}
			set
			{
				SetAttribute("arrowhead", value);
			}
		}

		public DotEdgeArrowTypeAttribute ArrowTail
		{
			get
			{
				return GetAttribute<DotEdgeArrowTypeAttribute>("arrowtail");
			}
			set
			{
				SetAttribute("arrowtail", value);
			}
		}

		public DotPointAttribute Pos
		{
			get
			{
				return GetAttribute<DotPointAttribute>("pos");
			}
			set
			{
				SetAttribute("pos", value);
			}
		}

		public override async Task CompileAsync(CompilationContext context)
		{
			if ((object)From == null || (object)To == null)
			{
				throw new Exception("Can't compile edge with null From and/or To");
			}
			await context.WriteIndentationAsync();
			await From.CompileAsync(context);
			await context.WriteAsync(" " + (context.DirectedGraph ? "->" : "--") + " ");
			await To.CompileAsync(context);
			if (Attributes.Any())
			{
				await context.WriteLineAsync(" [");
				context.IndentationLevel++;
				await CompileAttributesAsync(context);
				context.IndentationLevel--;
				await context.WriteIndentationAsync();
				await context.WriteLineAsync("]");
			}
			else
			{
				await context.WriteLineAsync();
			}
		}
	}
	internal enum DotEdgeArrowType
	{
		Normal,
		Inv,
		Dot,
		InvDot,
		ODot,
		InvODot,
		None,
		Tee,
		Empty,
		InvEmpty,
		Diamond,
		ODiamond,
		EDiamond,
		Crow,
		Box,
		OBox,
		Open,
		HalfOpen,
		Vee
	}
	[Flags]
	internal enum DotEdgeStyle
	{
		Solid = 1,
		Dashed = 2,
		Dotted = 4,
		Bold = 8,
		Tapered = 0x10,
		Invis = 0x20
	}
	internal abstract class DotElement : IDotElement
	{
		protected readonly Dictionary<string, IDotAttribute> Attributes = new Dictionary<string, IDotAttribute>();

		public DotLabelAttribute Label
		{
			get
			{
				return GetAttributeOrDefault<DotLabelAttribute>("label");
			}
			set
			{
				SetAttribute("label", value);
			}
		}

		public DotColorAttribute FontColor
		{
			get
			{
				return GetAttributeOrDefault<DotColorAttribute>("fontcolor");
			}
			set
			{
				SetAttribute("fontcolor", value);
			}
		}

		public bool HasAttribute(string name)
		{
			return Attributes.ContainsKey(name);
		}

		public IDotAttribute GetAttribute(string name)
		{
			if (Attributes.TryGetValue(name, out var value))
			{
				return value;
			}
			throw new Exception("There is no attribute named '" + name + "'");
		}

		public IDotAttribute GetAttributeOrDefault(string name, IDotAttribute defaultValue = null)
		{
			if (Attributes.TryGetValue(name, out var value))
			{
				return value;
			}
			return defaultValue;
		}

		public T GetAttribute<T>(string name) where T : IDotAttribute
		{
			IDotAttribute attribute = GetAttribute(name);
			if (attribute is T)
			{
				return (T)attribute;
			}
			throw new Exception($"Attribute with name '{name}' doesn't match the expected type (expected: {typeof(T)}, current: {attribute.GetType()})");
		}

		public T GetAttributeOrDefault<T>(string name, T defaultValue = default(T)) where T : IDotAttribute
		{
			if (Attributes.TryGetValue(name, out var value))
			{
				if (value is T)
				{
					return (T)value;
				}
				throw new Exception($"Attribute with name '{name}' doesn't match the expected type (expected: {typeof(T)}, current: {value.GetType()})");
			}
			return defaultValue;
		}

		public bool TryGetAttribute(string name, out IDotAttribute attribute)
		{
			if (Attributes.TryGetValue(name, out var value))
			{
				attribute = value;
				return true;
			}
			attribute = null;
			return false;
		}

		public bool TryGetAttribute<T>(string name, out T attribute) where T : IDotAttribute
		{
			if (!TryGetAttribute(name, out var attribute2))
			{
				attribute = default(T);
				return false;
			}
			if (attribute2 is T val)
			{
				attribute = val;
				return true;
			}
			throw new Exception($"Attribute with name '{name}' doesn't match the expected type (expected: {typeof(T)}, current: {attribute2.GetType()})");
		}

		public void SetAttribute(string name, IDotAttribute value)
		{
			if (value == null)
			{
				RemoveAttribute(name);
			}
			else
			{
				Attributes[name] = value;
			}
		}

		public bool RemoveAttribute(string name)
		{
			return Attributes.Remove(name);
		}

		protected async Task CompileAttributesAsync(CompilationContext context)
		{
			foreach (KeyValuePair<string, IDotAttribute> attributePair in Attributes)
			{
				await context.WriteIndentationAsync();
				await context.WriteAsync("\"" + attributePair.Key + "\"=");
				await attributePair.Value.CompileAsync(context);
				await context.WriteLineAsync();
			}
		}

		public abstract Task CompileAsync(CompilationContext context);
	}
	internal class DotGraph : DotBaseGraph
	{
		public bool Strict { get; set; }

		public bool Directed { get; set; }

		public override async Task CompileAsync(CompilationContext context)
		{
			context.DirectedGraph = Directed;
			await context.WriteIndentationAsync();
			if (Strict)
			{
				await context.WriteAsync("strict ");
			}
			await context.WriteAsync(Directed ? "digraph " : "graph ");
			await CompileBodyAsync(context);
		}
	}
	internal class DotIdentifier : IDotElement, IEquatable<DotIdentifier>
	{
		private static readonly Regex NoQuotesRequiredRegex = new Regex("^([a-zA-Z\\200-\\377_][a-zA-Z\\200-\\3770-9_]*|[-]?(.[0-9]+|[0-9]+(.[0-9]+)?))$");

		private static readonly string[] ReservedWords = new string[6] { "graph", "digraph", "subgraph", "strict", "node", "edge" };

		public string Value { get; set; }

		public bool IsHtml { get; set; }

		public DotIdentifier(string value, bool isHtml = false)
		{
			Value = value;
			IsHtml = isHtml;
		}

		public async Task CompileAsync(CompilationContext context)
		{
			if (IsHtml)
			{
				await context.TextWriter.WriteAsync("<" + Value + ">");
				return;
			}
			string text = (context.Options.AutomaticEscapedCharactersFormat ? Value.FormatGraphvizEscapedCharacters() : Value);
			if (RequiresDoubleQuotes(text))
			{
				await context.TextWriter.WriteAsync("\"" + text + "\"");
			}
			else
			{
				await context.TextWriter.WriteAsync(text ?? "");
			}
		}

		private static bool RequiresDoubleQuotes(string value)
		{
			if (!ReservedWords.Contains(value))
			{
				return !NoQuotesRequiredRegex.IsMatch(value);
			}
			return true;
		}

		public bool Equals(DotIdentifier other)
		{
			if ((object)other == null)
			{
				return false;
			}
			if ((object)this == other)
			{
				return true;
			}
			if (Value == other.Value)
			{
				return IsHtml == other.IsHtml;
			}
			return false;
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (obj.GetType() != GetType())
			{
				return false;
			}
			return Equals((DotIdentifier)obj);
		}

		public override int GetHashCode()
		{
			return (((Value != null) ? Value.GetHashCode() : 0) * 397) ^ IsHtml.GetHashCode();
		}

		public static bool operator ==(DotIdentifier identifier1, DotIdentifier identifier2)
		{
			return identifier1?.Equals(identifier2) ?? ((object)identifier2 == null);
		}

		public static bool operator !=(DotIdentifier identifier1, DotIdentifier identifier2)
		{
			return !(identifier1 == identifier2);
		}
	}
	internal class DotNode : DotElement
	{
		public DotIdentifier Identifier { get; set; }

		public DotColorAttribute Color
		{
			get
			{
				return GetAttributeOrDefault<DotColorAttribute>("color");
			}
			set
			{
				SetAttribute("color", value);
			}
		}

		public DotColorAttribute FillColor
		{
			get
			{
				return GetAttributeOrDefault<DotColorAttribute>("fillcolor");
			}
			set
			{
				SetAttribute("fillcolor", value);
			}
		}

		public DotNodeShapeAttribute Shape
		{
			get
			{
				return GetAttributeOrDefault<DotNodeShapeAttribute>("shape");
			}
			set
			{
				SetAttribute("shape", value);
			}
		}

		public DotNodeStyleAttribute Style
		{
			get
			{
				return GetAttributeOrDefault<DotNodeStyleAttribute>("style");
			}
			set
			{
				SetAttribute("style", value);
			}
		}

		public DotDoubleAttribute Width
		{
			get
			{
				return GetAttribute<DotDoubleAttribute>("width");
			}
			set
			{
				SetAttribute("width", value);
			}
		}

		public DotDoubleAttribute Height
		{
			get
			{
				return GetAttribute<DotDoubleAttribute>("height");
			}
			set
			{
				SetAttribute("height", value);
			}
		}

		public DotDoubleAttribute PenWidth
		{
			get
			{
				return GetAttribute<DotDoubleAttribute>("penwidth");
			}
			set
			{
				SetAttribute("penwidth", value);
			}
		}

		public DotPointAttribute Pos
		{
			get
			{
				return GetAttribute<DotPointAttribute>("pos");
			}
			set
			{
				SetAttribute("pos", value);
			}
		}

		public override async Task CompileAsync(CompilationContext context)
		{
			await context.WriteIndentationAsync();
			await Identifier.CompileAsync(context);
			if (Attributes.Any())
			{
				await context.WriteLineAsync(" [");
				context.IndentationLevel++;
				await CompileAttributesAsync(context);
				context.IndentationLevel--;
				await context.WriteIndentationAsync();
				await context.WriteLineAsync("]");
			}
			else
			{
				await context.WriteLineAsync();
			}
		}
	}
	internal enum DotNodeShape
	{
		Box,
		Polygon,
		Ellipse,
		Oval,
		Circle,
		Point,
		Egg,
		Triangle,
		PlainText,
		Plain,
		Diamond,
		Trapezium,
		Parallelogram,
		House,
		Pentagon,
		Hexagon,
		Septagon,
		Octagon,
		DoubleCircle,
		DoubleOctagon,
		TripleOctagon,
		InvTriangle,
		InvTrapezium,
		InvHouse,
		MDiamond,
		MSquare,
		MCircle,
		Rect,
		Rectangle,
		Square,
		Star,
		None,
		Underline,
		Cylinder,
		Note,
		Tab,
		Folder,
		Box3D,
		Component,
		Promoter,
		CDS,
		Terminator,
		UTR,
		PrimerSite,
		RestrictionSite,
		FivePOverHang,
		ThreePOveHang,
		NOverHang,
		Assembly,
		Signature,
		Insulator,
		Ribosite,
		RNasTab,
		ProteaseSite,
		ProteinsTab,
		RPromoter,
		RArrow,
		LArrow,
		LPromoter
	}
	[Flags]
	internal enum DotNodeStyle
	{
		Solid = 1,
		Dashed = 2,
		Dotted = 4,
		Bold = 8,
		Rounded = 0x10,
		Diagonals = 0x20,
		Filled = 0x40,
		Striped = 0x80,
		Wedged = 0x100,
		Invis = 0x200
	}
	internal struct DotPoint
	{
		public int X;

		public int Y;

		public int? Z;

		public bool Fixed;

		public DotPoint(int x, int y, bool @fixed = false)
		{
			X = x;
			Y = y;
			Z = null;
			Fixed = @fixed;
		}

		public DotPoint(int x, int y, int z, bool @fixed = false)
		{
			X = x;
			Y = y;
			Z = z;
			Fixed = @fixed;
		}

		public override string ToString()
		{
			string text = $"{X},{Y}";
			if (Z.HasValue)
			{
				text += $",{Z}";
			}
			if (Fixed)
			{
				text += "!";
			}
			return text;
		}
	}
	internal enum DotRankDir
	{
		TB,
		BT,
		LR,
		RL
	}
	internal class DotSubgraph : DotBaseGraph
	{
		public DotColorAttribute Color
		{
			get
			{
				return GetAttributeOrDefault<DotColorAttribute>("color");
			}
			set
			{
				SetAttribute("color", value);
			}
		}

		public DotSubgraphStyleAttribute Style
		{
			get
			{
				return GetAttributeOrDefault<DotSubgraphStyleAttribute>("style");
			}
			set
			{
				SetAttribute("style", value);
			}
		}

		public override async Task CompileAsync(CompilationContext context)
		{
			await context.WriteIndentationAsync();
			await context.WriteAsync("subgraph ");
			await CompileBodyAsync(context);
		}
	}
	[Flags]
	internal enum DotSubgraphStyle
	{
		Solid = 1,
		Dashed = 2,
		Dotted = 4,
		Bold = 8,
		Rounded = 0x10,
		Filled = 0x20,
		Striped = 0x40,
		Invis = 0x80
	}
	internal interface IDotElement
	{
		Task CompileAsync(CompilationContext context);
	}
}
namespace DotNetGraph.Compilation
{
	internal class CompilationContext
	{
		public TextWriter TextWriter { get; }

		public CompilationOptions Options { get; }

		public int IndentationLevel { get; set; }

		public bool DirectedGraph { get; set; }

		public CompilationContext(TextWriter textWriter, CompilationOptions options)
		{
			TextWriter = textWriter;
			Options = options;
			IndentationLevel = 0;
			DirectedGraph = false;
		}

		public async Task WriteIndentationAsync()
		{
			if (Options.Indented)
			{
				for (int i = 0; i < IndentationLevel; i++)
				{
					await TextWriter.WriteAsync("\t");
				}
			}
		}

		public async Task WriteAsync(string value)
		{
			await TextWriter.WriteAsync(value);
		}

		public async Task WriteLineAsync(string value = null)
		{
			await TextWriter.WriteAsync(value);
			await TextWriter.WriteAsync(Options.Indented ? '\n' : ' ');
		}
	}
	internal class CompilationOptions
	{
		public bool AutomaticEscapedCharactersFormat { get; set; } = true;


		public bool Indented { get; set; } = true;

	}
}
namespace DotNetGraph.Attributes
{
	internal class DotAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotAttribute(string value)
		{
			Value = value;
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync(Value);
		}
	}
	internal class DotColorAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotColorAttribute(DotColor color)
		{
			Value = color.ToHexString();
		}

		public DotColorAttribute(string value)
		{
			Value = value;
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotColorAttribute(DotColor value)
		{
			return new DotColorAttribute(value);
		}

		public static implicit operator DotColorAttribute(string value)
		{
			return new DotColorAttribute(value);
		}
	}
	internal class DotDoubleAttribute : IDotAttribute, IDotElement
	{
		public double Value { get; set; }

		public string Format { get; set; }

		public DotDoubleAttribute(double value, string format = "F2")
		{
			Value = value;
			Format = format;
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync(Value.ToString(Format, NumberFormatInfo.InvariantInfo));
		}

		public static implicit operator DotDoubleAttribute(double value)
		{
			return new DotDoubleAttribute(value);
		}
	}
	internal class DotEdgeArrowTypeAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotEdgeArrowTypeAttribute(string value)
		{
			Value = value;
		}

		public DotEdgeArrowTypeAttribute(DotEdgeArrowType type)
		{
			Value = type.ToString().ToLowerInvariant();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotEdgeArrowTypeAttribute(DotEdgeArrowType value)
		{
			return new DotEdgeArrowTypeAttribute(value);
		}

		public static implicit operator DotEdgeArrowTypeAttribute(string value)
		{
			return new DotEdgeArrowTypeAttribute(value);
		}
	}
	internal class DotEdgeStyleAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotEdgeStyleAttribute(string value)
		{
			Value = value;
		}

		public DotEdgeStyleAttribute(DotEdgeStyle style)
		{
			Value = style.FlagsToString();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotEdgeStyleAttribute(DotEdgeStyle value)
		{
			return new DotEdgeStyleAttribute(value);
		}

		public static implicit operator DotEdgeStyleAttribute(string value)
		{
			return new DotEdgeStyleAttribute(value);
		}
	}
	internal class DotLabelAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public bool IsHtml { get; set; }

		public DotLabelAttribute(string value, bool isHtml = false)
		{
			Value = value;
			IsHtml = isHtml;
		}

		public async Task CompileAsync(CompilationContext context)
		{
			if (IsHtml)
			{
				await context.TextWriter.WriteAsync("<" + Value + ">");
				return;
			}
			string text = (context.Options.AutomaticEscapedCharactersFormat ? Value.FormatGraphvizEscapedCharacters() : Value);
			await context.TextWriter.WriteAsync("\"" + text + "\"");
		}

		public static implicit operator DotLabelAttribute(string value)
		{
			return new DotLabelAttribute(value);
		}
	}
	internal class DotNodeShapeAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotNodeShapeAttribute(string value)
		{
			Value = value;
		}

		public DotNodeShapeAttribute(DotNodeShape shape)
		{
			Value = shape.ToString().ToLowerInvariant();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotNodeShapeAttribute(DotNodeShape value)
		{
			return new DotNodeShapeAttribute(value);
		}

		public static implicit operator DotNodeShapeAttribute(string value)
		{
			return new DotNodeShapeAttribute(value);
		}
	}
	internal class DotNodeStyleAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotNodeStyleAttribute(string value)
		{
			Value = value;
		}

		public DotNodeStyleAttribute(DotNodeStyle style)
		{
			Value = style.FlagsToString();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotNodeStyleAttribute(DotNodeStyle value)
		{
			return new DotNodeStyleAttribute(value);
		}

		public static implicit operator DotNodeStyleAttribute(string value)
		{
			return new DotNodeStyleAttribute(value);
		}
	}
	internal class DotPointAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotPointAttribute(string value)
		{
			Value = value;
		}

		public DotPointAttribute(DotPoint point)
		{
			Value = point.ToString();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync(Value);
		}

		public static implicit operator DotPointAttribute(DotPoint value)
		{
			return new DotPointAttribute(value);
		}

		public static implicit operator DotPointAttribute(string value)
		{
			return new DotPointAttribute(value);
		}
	}
	internal class DotRankDirAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotRankDirAttribute(string value)
		{
			Value = value;
		}

		public DotRankDirAttribute(DotRankDir rankDir)
		{
			Value = rankDir.ToString();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotRankDirAttribute(DotRankDir value)
		{
			return new DotRankDirAttribute(value);
		}

		public static implicit operator DotRankDirAttribute(string value)
		{
			return new DotRankDirAttribute(value);
		}
	}
	internal class DotSubgraphStyleAttribute : IDotAttribute, IDotElement
	{
		public string Value { get; set; }

		public DotSubgraphStyleAttribute(string value)
		{
			Value = value;
		}

		public DotSubgraphStyleAttribute(DotSubgraphStyle style)
		{
			Value = style.FlagsToString();
		}

		public async Task CompileAsync(CompilationContext context)
		{
			await context.WriteAsync("\"" + Value + "\"");
		}

		public static implicit operator DotSubgraphStyleAttribute(DotSubgraphStyle value)
		{
			return new DotSubgraphStyleAttribute(value);
		}

		public static implicit operator DotSubgraphStyleAttribute(string value)
		{
			return new DotSubgraphStyleAttribute(value);
		}
	}
	internal interface IDotAttribute : IDotElement
	{
	}
}