// Copyright Epic Games, Inc. All Rights Reserved.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using UnrealBuildTool;
using System.Diagnostics;
using EpicGames.Core;
using System.Reflection;
using UnrealBuildBase;
using System.Runtime.Serialization;
using System.Collections;
using Microsoft.Extensions.Logging;

using static AutomationTool.CommandUtils;

namespace AutomationTool
{
	public class SingleTargetProperties
	{
		public string TargetName;
		public string TargetClassName;
		public TargetRules Rules;
	}

	/// <summary>
	/// Autodetected project properties.
	/// </summary>
	public class ProjectProperties
	{
		/// <summary>
		/// Full Project path. Must be a .uproject file
		/// </summary>
		public FileReference RawProjectPath;

		/// <summary>
		/// True if the uproject contains source code.
		/// </summary>
		public bool bIsCodeBasedProject;

		/// <summary>
		/// List of all targets detected for this project.
		/// </summary>
		public List<SingleTargetProperties> Targets = new List<SingleTargetProperties>();

		/// <summary>
		/// List of all scripts that were compiled to create the list of Targets
		/// </summary>
		public List<FileReference> TargetScripts = new List<FileReference>();

		/// <summary>
		/// List of all Engine ini files for this project
		/// </summary>
		public Dictionary<UnrealTargetPlatform, ConfigHierarchy> EngineConfigs = new Dictionary<UnrealTargetPlatform,ConfigHierarchy>();

		/// <summary>
		/// List of all Game ini files for this project
		/// </summary>
		public Dictionary<UnrealTargetPlatform, ConfigHierarchy> GameConfigs = new Dictionary<UnrealTargetPlatform, ConfigHierarchy>();

		/// <summary>
		/// List of all programs detected for this project.
		/// </summary>
		public List<SingleTargetProperties> Programs = new List<SingleTargetProperties>();

		/// <summary>
		/// Specifies if the target files were generated
		/// </summary>
		public bool bWasGenerated = false;

		internal ProjectProperties()
		{
		}
	}

	/// <summary>
	/// Project related utility functions.
	/// </summary>
	public class ProjectUtils
	{

		/// <summary>
		/// Struct that acts as a key for the project property cache. Based on these attributes 
		/// DetectProjectProperties may return different answers, e.g. Some platforms require a 
		///  codebased project for targets
		/// </summary>
		struct PropertyCacheKey : IEquatable<PropertyCacheKey>
		{
			string ProjectName;

			UnrealTargetPlatform[] TargetPlatforms;

			UnrealTargetConfiguration[] TargetConfigurations;

			public PropertyCacheKey(string InProjectName, IEnumerable<UnrealTargetPlatform> InTargetPlatforms, IEnumerable<UnrealTargetConfiguration> InTargetConfigurations)
			{
				ProjectName = InProjectName.ToLower();
				TargetPlatforms = InTargetPlatforms != null ? InTargetPlatforms.ToArray() : new UnrealTargetPlatform[0];
				TargetConfigurations = InTargetConfigurations != null ? InTargetConfigurations.ToArray() : new UnrealTargetConfiguration[0];
			}

			public bool Equals(PropertyCacheKey Other)
			{
				return ProjectName == Other.ProjectName &&
						StructuralComparisons.StructuralEqualityComparer.Equals(TargetPlatforms, Other.TargetPlatforms) &&
						StructuralComparisons.StructuralEqualityComparer.Equals(TargetConfigurations, Other.TargetConfigurations);
			}

			public override bool Equals(object Other)
			{
				return Other is PropertyCacheKey OtherKey && Equals(OtherKey);
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(
					ProjectName.GetHashCode(),
					StructuralComparisons.StructuralEqualityComparer.GetHashCode(TargetPlatforms),
					StructuralComparisons.StructuralEqualityComparer.GetHashCode(TargetConfigurations));
			}

			public static bool operator==(PropertyCacheKey A, PropertyCacheKey B)
			{
				return A.Equals(B);
			}

			public static bool operator!=(PropertyCacheKey A, PropertyCacheKey B)
			{
				return !(A == B);
			}
		}

		private static ILogger Logger => Log.Logger;
		private static Dictionary<PropertyCacheKey, ProjectProperties> PropertiesCache = new Dictionary<PropertyCacheKey, ProjectProperties>();

		/// <summary>
		/// Gets a short project name (QAGame, Elemental, etc)
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <returns>Short project name</returns>
		public static string GetShortProjectName(FileReference RawProjectPath)
		{
			return CommandUtils.GetFilenameWithoutAnyExtensions(RawProjectPath.FullName);
		}

		/// <summary>
		/// Gets a short alphanumeric identifier for the project path.
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <returns>Project path identifier</returns>
		public static string GetProjectPathId(FileReference RawProjectPath)
		{
			string UniformProjectPath = FileReference.FindCorrectCase(RawProjectPath).ToNormalizedPath();
			string ProjectPathHash = ContentHash.MD5(Encoding.UTF8.GetBytes(UniformProjectPath)).ToString();
			return String.Format("{0}.{1}", GetShortProjectName(RawProjectPath), ProjectPathHash.Substring(0, 8));
		}

		/// <summary>
		/// Gets project properties.
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <param name="ClientTargetPlatforms"></param>
		/// <param name="ClientTargetConfigurations"></param>
		/// <param name="AssetNativizationRequested"></param>
		/// <returns>Properties of the project.</returns>
		public static ProjectProperties GetProjectProperties(FileReference RawProjectPath, List<UnrealTargetPlatform> ClientTargetPlatforms = null, List<UnrealTargetConfiguration> ClientTargetConfigurations = null, bool AssetNativizationRequested = false)
		{
			string ProjectKey = "UE4";
			if (RawProjectPath != null)
			{
				ProjectKey = CommandUtils.ConvertSeparators(PathSeparator.Slash, RawProjectPath.FullName);
			}
			ProjectProperties Properties;
			PropertyCacheKey PropertyKey = new PropertyCacheKey(ProjectKey, ClientTargetPlatforms, ClientTargetConfigurations);

			if (PropertiesCache.TryGetValue(PropertyKey, out Properties) == false)
			{
                Properties = DetectProjectProperties(RawProjectPath, ClientTargetPlatforms, ClientTargetConfigurations, AssetNativizationRequested);
				PropertiesCache.Add(PropertyKey, Properties);
			}
			return Properties;
		}

		/// <summary>
		/// Checks if the project is a UProject file with source code.
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <param name="ClientTargetPlatforms"></param>
		/// <param name="ClientTargetConfigurations"></param>
		/// <returns>True if the project is a UProject file with source code.</returns>
		public static bool IsCodeBasedUProjectFile(FileReference RawProjectPath, List<UnrealTargetPlatform> ClientTargetPlatforms = null, List < UnrealTargetConfiguration> ClientTargetConfigurations = null)
		{
			return GetProjectProperties(RawProjectPath, ClientTargetPlatforms, ClientTargetConfigurations).bIsCodeBasedProject;
		}

		/// <summary>
		/// Checks if the project is a UProject file with source code.
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <param name="ClientTargetPlatform"></param>
		/// <param name="ClientTargetConfigurations"></param>
		/// <returns>True if the project is a UProject file with source code.</returns>
		public static bool IsCodeBasedUProjectFile(FileReference RawProjectPath, UnrealTargetPlatform ClientTargetPlatform, List<UnrealTargetConfiguration> ClientTargetConfigurations = null)
		{
			return GetProjectProperties(RawProjectPath, new List<UnrealTargetPlatform>() { ClientTargetPlatform }, ClientTargetConfigurations).bIsCodeBasedProject;
		}

		/// <summary>
		/// Returns a path to the client binaries folder.
		/// </summary>
		/// <param name="ProjectClientBinariesPath"></param>
		/// <param name="Platform">Platform type.</param>
		/// <returns>Path to the binaries folder.</returns>
		public static DirectoryReference GetProjectClientBinariesFolder(DirectoryReference ProjectClientBinariesPath, UnrealTargetPlatform Platform)
		{
			ProjectClientBinariesPath = DirectoryReference.Combine(ProjectClientBinariesPath, Platform.ToString());
			return ProjectClientBinariesPath;
		}

		/// <summary>
		/// Attempts to autodetect project properties.
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <param name="ClientTargetPlatforms"></param>
		/// <param name="ClientTargetConfigurations"></param>
		/// <param name="AssetNativizationRequested"></param>
		/// <returns>Project properties.</returns>
		private static ProjectProperties DetectProjectProperties(FileReference RawProjectPath, List<UnrealTargetPlatform> ClientTargetPlatforms, List<UnrealTargetConfiguration> ClientTargetConfigurations, bool AssetNativizationRequested)
		{
			ProjectProperties Properties = new ProjectProperties();
			Properties.RawProjectPath = RawProjectPath;

			// detect if the project is content only, but has non-default build settings
			List<string> ExtraSearchPaths = new();
			if (RawProjectPath != null)
			{
				// no Target file, now check to see if build settings have changed
				List<UnrealTargetPlatform> TargetPlatforms = ClientTargetPlatforms;
				if (ClientTargetPlatforms == null || ClientTargetPlatforms.Count < 1)
				{
					// No client target platforms, add all in
					TargetPlatforms = new List<UnrealTargetPlatform>();
					foreach (UnrealTargetPlatform TargetPlatformType in UnrealTargetPlatform.GetValidPlatforms())
					{
						TargetPlatforms.Add(TargetPlatformType);
					}
				}

				List<UnrealTargetConfiguration> TargetConfigurations = ClientTargetConfigurations;
				if (TargetConfigurations == null || TargetConfigurations.Count < 1)
				{
					// No client target configurations, add all in
					TargetConfigurations = new List<UnrealTargetConfiguration>();
					foreach (UnrealTargetConfiguration TargetConfigurationType in Enum.GetValues(typeof(UnrealTargetConfiguration)))
					{
						if (TargetConfigurationType != UnrealTargetConfiguration.Unknown)
						{
							TargetConfigurations.Add(TargetConfigurationType);
						}
					}
				}

				if (NativeProjects.ConditionalMakeTempTargetForHybridProject(RawProjectPath, Logger))
				{
					Properties.bWasGenerated = true;
					string TempTargetDir = CommandUtils.CombinePaths(Path.GetDirectoryName(RawProjectPath.FullName), "Intermediate", "Source");
					ExtraSearchPaths.Add(TempTargetDir);
				}
            }

			if (CommandUtils.CmdEnv.HasCapabilityToCompile)
			{
				DetectTargetsForProject(Properties, ExtraSearchPaths);
				Properties.bIsCodeBasedProject = !CommandUtils.IsNullOrEmpty(Properties.Targets) || !CommandUtils.IsNullOrEmpty(Properties.Programs);
			}
			else
			{
				// should never ask for engine targets if we can't compile
				if (RawProjectPath == null)
				{
					throw new AutomationException("Cannot determine engine targets if we can't compile.");
				}

				Properties.bIsCodeBasedProject = Properties.bWasGenerated;
				// if there's a Source directory with source code in it, then mark us as having source code
				string SourceDir = CommandUtils.CombinePaths(Path.GetDirectoryName(RawProjectPath.FullName), "Source");
				if (Directory.Exists(SourceDir))
				{
					string[] CppFiles = Directory.GetFiles(SourceDir, "*.cpp", SearchOption.AllDirectories);
					string[] HFiles = Directory.GetFiles(SourceDir, "*.h", SearchOption.AllDirectories);
					Properties.bIsCodeBasedProject |= (CppFiles.Length > 0 || HFiles.Length > 0);
				}
			}

			// check to see if the uproject loads modules, only if we haven't already determined it is a code based project
			if (!Properties.bIsCodeBasedProject && RawProjectPath != null)
			{
				string uprojectStr = File.ReadAllText(RawProjectPath.FullName);
				Properties.bIsCodeBasedProject = uprojectStr.Contains("\"Modules\"");
			}

			// Get all ini files
			if (RawProjectPath != null)
			{
				Logger.LogDebug("Loading ini files for {RawProjectPath}", RawProjectPath);

				foreach (UnrealTargetPlatform TargetPlatformType in UnrealTargetPlatform.GetValidPlatforms())
				{
					ConfigHierarchy EngineConfig = ConfigCache.ReadHierarchy(ConfigHierarchyType.Engine, RawProjectPath.Directory, TargetPlatformType);
					Properties.EngineConfigs.Add(TargetPlatformType, EngineConfig);

					ConfigHierarchy GameConfig = ConfigCache.ReadHierarchy(ConfigHierarchyType.Game, RawProjectPath.Directory, TargetPlatformType);
					Properties.GameConfigs.Add(TargetPlatformType, GameConfig);
				}
			}

			return Properties;
		}


		/// <summary>
		/// Gets the project's root binaries folder.
		/// </summary>
		/// <param name="RawProjectPath">Full project path.</param>
		/// <param name="TargetType">Target type.</param>
		/// <param name="bIsCodeBasedProject">True if a code based project.</param>
		/// <returns>Binaries path.</returns>
		public static DirectoryReference GetClientProjectBinariesRootPath(FileReference RawProjectPath, TargetType TargetType, bool bIsCodeBasedProject)
		{
			DirectoryReference BinPath = null;
			switch (TargetType)
			{
				case TargetType.Program:
					BinPath = DirectoryReference.Combine(Unreal.RootDirectory, "Engine", "Binaries");
					break;
				case TargetType.Client:
				case TargetType.Game:
					if (!bIsCodeBasedProject)
					{
						BinPath = DirectoryReference.Combine(Unreal.RootDirectory, "Engine", "Binaries");
					}
					else
					{
						BinPath = DirectoryReference.Combine(RawProjectPath.Directory, "Binaries");
					}
					break;
			}
			return BinPath;
		}

		/// <summary>
		/// Gets the location where all rules assemblies should go
		/// </summary>
		private static string GetRulesAssemblyFolder()
		{
			string RulesFolder;
			if (Unreal.IsEngineInstalled())
			{
				RulesFolder = CommandUtils.CombinePaths(Path.GetTempPath(), "UAT", CommandUtils.EscapePath(CommandUtils.CmdEnv.LocalRoot), "Rules"); 
			}
			else
			{
				RulesFolder = CommandUtils.CombinePaths(CommandUtils.CmdEnv.EngineSavedFolder, "Rules");
			}
			return RulesFolder;
		}

		/// <summary>
		/// Finds all targets for the project.
		/// </summary>
		/// <param name="Properties">Project properties.</param>
		/// <param name="ExtraSearchPaths">Additional search paths.</param>
		private static void DetectTargetsForProject(ProjectProperties Properties, List<string> ExtraSearchPaths = null)
		{
			Properties.Targets = new List<SingleTargetProperties>();
			FileReference TargetsDllFilename;
			string FullProjectPath = null;

			List<DirectoryReference> GameFolders = new List<DirectoryReference>();
			DirectoryReference RulesFolder = new DirectoryReference(GetRulesAssemblyFolder());
			List<DirectoryReference> ExtraSearchDirectories = (ExtraSearchPaths == null) ? null : ExtraSearchPaths.Select(x => new DirectoryReference(x)).ToList();
			if (Properties.RawProjectPath != null)
			{
				Logger.LogDebug("Looking for targets for project {Arg0}", Properties.RawProjectPath);

				TargetsDllFilename = FileReference.Combine(RulesFolder, String.Format("UATRules-{0}.dll", ContentHash.MD5(Properties.RawProjectPath.FullName.ToUpperInvariant()).ToString()));

				FullProjectPath = CommandUtils.GetDirectoryName(Properties.RawProjectPath.FullName).Replace("\\", "/");

				// Extra search root uproject folder if we have /tests/
				if (FullProjectPath.Contains("/Tests/"))
				{
					ExtraSearchDirectories.Add(new DirectoryReference(FullProjectPath));
				}

				// there is a special case of Programs, where the uproject doesn't align with the Source directory, so we redirect to where
				// the program's target.cs file(s) are
				if (FullProjectPath.Contains("/Programs/"))
				{
					FullProjectPath = FullProjectPath.Replace("/Programs/", "/Source/Programs/");
				}

				GameFolders.Add(new DirectoryReference(FullProjectPath));
				Logger.LogDebug("Searching for target rule files in {FullProjectPath}", FullProjectPath);
			}
			else
			{
				TargetsDllFilename = FileReference.Combine(RulesFolder, String.Format("UATRules{0}.dll", "_BaseEngine_"));
			}

			// the UBT code assumes a certain CWD, but artists don't have this CWD.
			string SourceDir = CommandUtils.CombinePaths(CommandUtils.CmdEnv.LocalRoot, "Engine", "Source");
			bool DirPushed = false;
			if (CommandUtils.DirectoryExists_NoExceptions(SourceDir))
			{
				CommandUtils.PushDir(SourceDir);
				DirPushed = true;
			}

			List<FileReference> TargetScripts = Rules.FindAllRulesSourceFiles(Rules.RulesFileType.Target, GameFolders: GameFolders, ForeignPlugins: null, AdditionalSearchPaths: ExtraSearchDirectories);
			if (DirPushed)
			{
				CommandUtils.PopDir();
			}

			if (!CommandUtils.IsNullOrEmpty(TargetScripts))
			{
				// We only care about project target script so filter out any scripts not in the project folder, or take them all if we are just doing engine stuff
				List<FileReference> ProjectTargetScripts = new List<FileReference>();
				foreach (FileReference TargetScript in TargetScripts)
				{
					if (FullProjectPath == null || TargetScript.IsUnderDirectory(new DirectoryReference(FullProjectPath)))
					{
						// skip target rules that are platform extension or platform group specializations (don't treat _<Platform> targets as extensions if not under a <Platform> directory)
						string[] TargetPathSplit = TargetScript.GetFileNameWithoutAnyExtensions().Split(new char[]{'_'}, StringSplitOptions.RemoveEmptyEntries );
						if (TargetPathSplit.Length > 1 && 
							(UnrealTargetPlatform.IsValidName(TargetPathSplit.Last()) || UnrealPlatformGroup.IsValidName(TargetPathSplit.Last())) &&
							// platform extension targets will always be under a directory of that platform/group name
							TargetScript.ContainsName(TargetPathSplit.Last(), 0))
						{
							continue;
						}

						ProjectTargetScripts.Add(TargetScript);
					}
				}
				TargetScripts = ProjectTargetScripts;
			}

			if (!CommandUtils.IsNullOrEmpty(TargetScripts))
			{
				Logger.LogDebug("Found {Arg0} target rule files:", TargetScripts.Count);
				foreach (FileReference Filename in TargetScripts)
				{
					Logger.LogDebug("  {Filename}", Filename);
				}

				// Check if the scripts require compilation
				bool DoNotCompile = false;

				if (!CommandUtils.IsBuildMachine && !CheckIfScriptAssemblyIsOutOfDate(TargetsDllFilename, TargetScripts))
				{
					Logger.LogDebug("Targets DLL {Filename} is up to date.", TargetsDllFilename);
					DoNotCompile = true;
				}
				if (!DoNotCompile && CommandUtils.FileExists_NoExceptions(TargetsDllFilename.FullName))
				{
					if (!CommandUtils.DeleteFile_NoExceptions(TargetsDllFilename.FullName, true))
					{
						DoNotCompile = true;
						Logger.LogDebug("Could not delete {TargetsDllFilename} assuming it is up to date and reusable for a recursive UAT call.", TargetsDllFilename);
					}
				}

				CompileAndLoadTargetsAssembly(Properties, TargetsDllFilename, DoNotCompile, TargetScripts);
			}
		}

		/// <summary>
		/// Optionally compiles and loads target rules assembly.
		/// </summary>
		/// <param name="Properties"></param>
		/// <param name="TargetsDllFilename"></param>
		/// <param name="DoNotCompile"></param>
		/// <param name="TargetScripts"></param>
		private static void CompileAndLoadTargetsAssembly(ProjectProperties Properties, FileReference TargetsDllFilename, bool DoNotCompile, List<FileReference> TargetScripts)
		{
			Properties.TargetScripts = new List<FileReference>(TargetScripts);

			Logger.LogDebug("Compiling targets DLL: {TargetsDllFilename}", TargetsDllFilename);

			List<string> ReferencedAssemblies = new List<string>() 
					{ 
						typeof(UnrealBuildTool.PlatformExports).Assembly.Location
					};
			List<string> PreprocessorDefinitions = RulesAssembly.GetPreprocessorDefinitions();
			Assembly TargetsDLL = DynamicCompilation.CompileAndLoadAssembly(TargetsDllFilename, new HashSet<FileReference>(TargetScripts), Log.Logger, ReferencedAssemblies, PreprocessorDefinitions, DoNotCompile);
			Type[] AllCompiledTypes = TargetsDLL.GetTypes();
			foreach (Type TargetType in AllCompiledTypes)
			{
				// Find TargetRules but skip all "UnrealEditor", "UnrealGame" targets.
				if (typeof(TargetRules).IsAssignableFrom(TargetType) && !TargetType.IsAbstract)
				{
					string TargetName = GetTargetName(TargetType);

					TargetInfo DummyTargetInfo = new TargetInfo(TargetName, BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, null, Properties.RawProjectPath, null);

					// Create an instance of this type
					Logger.LogDebug("Creating target rules object: {Arg0}", TargetType.Name);
					TargetRules Rules = TargetRules.Create(TargetType, DummyTargetInfo, null, null, null, null, Log.Logger);
					Logger.LogDebug("Adding target: {Arg0} ({Arg1})", TargetType.Name, Rules.Type);

					SingleTargetProperties TargetData = new SingleTargetProperties();
					TargetData.TargetName = GetTargetName(TargetType);
					TargetData.TargetClassName = TargetType.FullName;
					TargetData.Rules = Rules;
					if (Rules.Type == global::UnrealBuildTool.TargetType.Program)
					{
						Properties.Programs.Add(TargetData);
					}
					else
					{
						Properties.Targets.Add(TargetData);
					}
				}
			}
		}

		/// <summary>
		/// Checks if any of the script files in newer than the generated assembly.
		/// </summary>
		/// <param name="TargetsDllFilename"></param>
		/// <param name="TargetScripts"></param>
		/// <returns>True if the generated assembly is out of date.</returns>
		private static bool CheckIfScriptAssemblyIsOutOfDate(FileReference TargetsDllFilename, List<FileReference> TargetScripts)
		{
			bool bOutOfDate = false;
			FileInfo AssemblyInfo = new FileInfo(TargetsDllFilename.FullName);
			if (AssemblyInfo.Exists)
			{
				foreach (FileReference ScriptFilename in TargetScripts)
				{
					FileInfo ScriptInfo = new FileInfo(ScriptFilename.FullName);
					if (ScriptInfo.Exists && ScriptInfo.LastWriteTimeUtc > AssemblyInfo.LastWriteTimeUtc)
					{
						bOutOfDate = true;
						break;
					}
				}
			}
			else
			{
				bOutOfDate = true;
			}
			return bOutOfDate;
		}

		/// <summary>
		/// Converts class type name (usually ends with Target) to a target name (without the postfix).
		/// </summary>
		/// <param name="TargetRulesType">Tagert class.</param>
		/// <returns>Target name</returns>
		private static string GetTargetName(Type TargetRulesType)
		{
			const string TargetPostfix = "Target";
			string Name = TargetRulesType.Name;
			if (Name.EndsWith(TargetPostfix, StringComparison.InvariantCultureIgnoreCase))
			{
				Name = Name.Substring(0, Name.Length - TargetPostfix.Length);
			}
			return Name;
		}

		/// <summary>
		/// Performs initial cleanup of target rules folder
		/// </summary>
		public static void CleanupFolders()
		{
			Logger.LogDebug("Cleaning up project rules folder");
			string RulesFolder = GetRulesAssemblyFolder();
			if (CommandUtils.DirectoryExists(RulesFolder))
			{
				CommandUtils.DeleteDirectoryContents(RulesFolder);
			}
		}

		/// <summary>
		/// Takes a game name (e.g "ShooterGame") and tries to find the path to the project file
		/// </summary>
		/// <param name="GameName"></param>
		/// <returns></returns>
		public static FileReference FindProjectFileFromName(string GameName)
		{
			// if they passed in a path then easy.
			if (File.Exists(GameName))
			{
				return new FileReference(GameName);
			}

			// Start with the gamename regardless of what they passed in
			GameName = Path.GetFileNameWithoutExtension(GameName);

			// Turn Foo into Foo.uproject
			string ProjectFile = GameName;

			if (string.IsNullOrEmpty(Path.GetExtension(ProjectFile)))
			{
				// if project was specified but had no extension then just add it.
				ProjectFile = Path.ChangeExtension(GameName, ".uproject");
			}

			// Turn Foo.uproject into Foo/Foo.uproject
			ProjectFile = Path.Combine(GameName, ProjectFile);

			GameName = Path.GetFileNameWithoutExtension(GameName);

			// check for sibling to engine
			if (File.Exists(ProjectFile))
			{
				return new FileReference(ProjectFile);
			}

			// Search NativeProjects (sibling folders).
			IEnumerable<FileReference> Projects = NativeProjects.EnumerateProjectFiles(Log.Logger);

			FileReference ProjectPath = Projects.Where(R => string.Equals(R.GetFileName(), ProjectFile, StringComparison.OrdinalIgnoreCase)).FirstOrDefault();

			if (ProjectPath == null)
			{
				// read .uprojectdirs
				List<string> SearchPaths = new List<string>();
				SearchPaths.Add("");
				string ProjectDirsFile = Directory.EnumerateFiles(Environment.CurrentDirectory, "*.uprojectdirs").FirstOrDefault();
				if (ProjectDirsFile != null)
				{
					foreach (string FilePath in File.ReadAllLines(ProjectDirsFile))
					{
						string Trimmed = FilePath.Trim();
						if (!Trimmed.StartsWith("./", StringComparison.OrdinalIgnoreCase) &&
							!Trimmed.StartsWith(";", StringComparison.OrdinalIgnoreCase) &&
							Trimmed.IndexOfAny(Path.GetInvalidPathChars()) < 0)
						{
							SearchPaths.Add(Trimmed);
						}
					}

					string ResolvedFile = SearchPaths.Select(P => Path.Combine(P, ProjectFile))
											.Where(P => File.Exists(P))
											.FirstOrDefault();

					if (ResolvedFile != null)
					{
						ProjectPath = new FileReference(ResolvedFile);
					}
				}
			}
						
			// either valid or we're out of ideas...
			return ProjectPath;
		}

		/// <summary>
		/// Full path to the Project executable for the current platform.
		/// </summary>
		/// <param name="ProjectFile">Path to Project file</param>
		/// <param name="TargetType">Target type</param>
		/// <param name="TargetPlatform">Target platform</param>
		/// <param name="TargetConfiguration">Target build configuration</param>
		/// <param name="Cmd">Do you want the console subsystem/commandlet executable?</param>
		/// <returns></returns>
		public static FileSystemReference GetProjectTarget(FileReference ProjectFile, UnrealBuildTool.TargetType TargetType, UnrealBuildTool.UnrealTargetPlatform TargetPlatform, UnrealBuildTool.UnrealTargetConfiguration TargetConfiguration = UnrealBuildTool.UnrealTargetConfiguration.Development, bool Cmd = false)
		{
			ProjectProperties Properties = ProjectUtils.GetProjectProperties(ProjectFile);
			List<SingleTargetProperties> Targets = Properties.Targets.Where(x => x.Rules.Type == TargetType).ToList();
			string TargetName = null;
			switch (Targets.Count)
			{
				case 0:
					return null;
				case 1:
					TargetName = Targets.First().TargetName;
					break;
				default:
					Properties.EngineConfigs[TargetPlatform].GetString("/Script/BuildSettings.BuildSettings", "DefaultEditorTarget", out TargetName);
					break;
			}

			FileReference TargetReceiptFileName = UnrealBuildTool.TargetReceipt.GetDefaultPath(ProjectFile.Directory, TargetName, TargetPlatform, TargetConfiguration, null);
			UnrealBuildTool.TargetReceipt TargetReceipt = UnrealBuildTool.TargetReceipt.Read(TargetReceiptFileName);

			if (Cmd)
			{
				return TargetReceipt.LaunchCmd;
			}
			
			if (TargetPlatform == UnrealTargetPlatform.Mac)
			{
				// Remove trailing "/Contents/MacOS/UnrealEngine" to get back to .app directory
				return TargetReceipt.Launch.Directory.ParentDirectory.ParentDirectory;
			}
			
			return TargetReceipt.Launch;
		}

		// Helper function to get the editor executable to run for cooking, etc the given project
		public static FileSystemReference GetEditorForProject(FileReference ProjectFile)
		{
			FileSystemReference EditorExe = null;
			if (ProjectFile != null)
			{
				EditorExe = ProjectUtils.GetProjectTarget(ProjectFile, UnrealBuildTool.TargetType.Editor, BuildHostPlatform.Current.Platform, UnrealTargetConfiguration.Development, true);
			}

			// if we haven't gotten an editor yet, use the engine shared binary
			if (EditorExe == null)
			{
				EditorExe = new FileReference(HostPlatform.Current.GetUnrealExePath("UnrealEditor-Cmd.exe"));
			}

			return EditorExe;
		}
	}

    public class BranchInfo
    {
		[DebuggerDisplay("{GameName}")]
        public class BranchUProject
        {
            public string GameName;
            public FileReference FilePath;

			private ProjectProperties CachedProperties;
			
			public ProjectProperties Properties
			{
				get
				{
					if(CachedProperties == null)
					{
						CachedProperties = ProjectUtils.GetProjectProperties(FilePath);
					}
					return CachedProperties;
				}
			}

            public BranchUProject(FileReference ProjectFile)
            {
                GameName = ProjectFile.GetFileNameWithoutExtension();

                //not sure what the heck this path is relative to
                FilePath = ProjectFile;

                if (!CommandUtils.FileExists_NoExceptions(FilePath.FullName))
                {
                    throw new AutomationException("Could not resolve relative path corrctly {0} -> {1} which doesn't exist.", ProjectFile, FilePath);
                }
            }
        }

		public List<BranchUProject> AllProjects = new List<BranchUProject>();

        public BranchInfo()
        {
            IEnumerable<FileReference> ProjectFiles = UnrealBuildTool.NativeProjects.EnumerateProjectFiles(Log.Logger);
			foreach (FileReference InfoEntry in ProjectFiles)
			{
				AllProjects.Add(new BranchUProject(InfoEntry));
			}

			Logger.LogDebug("  {Arg0} projects:", AllProjects.Count);
			foreach (BranchUProject Proj in AllProjects)
			{
				Logger.LogDebug(" {Arg0}: {Arg1}", Proj.GameName, Proj.FilePath);
			}
        }

        public BranchUProject FindGame(string GameName)
        {
			foreach (BranchUProject Proj in AllProjects)
            {
                if (Proj.GameName.Equals(GameName, StringComparison.InvariantCultureIgnoreCase))
                {
                    return Proj;
                }
            }
            return null;
        }

		public BranchUProject FindGameChecked(string GameName)
		{
			BranchUProject Project = FindGame(GameName);
			if(Project == null)
			{
				throw new AutomationException("Cannot find project '{0}' in branch", GameName);
			}
			return Project;
		}
    }
}