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

using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Linq;
using EpicGames.Core;
using Microsoft.Extensions.Logging;
using UnrealBuildBase;

namespace UnrealBuildTool
{
	class CodeLiteProject : ProjectFile
	{
		FileReference? OnlyGameProject;

		public CodeLiteProject(FileReference InitFilePath, DirectoryReference BaseDir, FileReference? InOnlyGameProject) : base(InitFilePath, BaseDir)
		{
			OnlyGameProject = InOnlyGameProject;
		}

		// Check if the XElement is empty.
		bool IsEmpty(IEnumerable<XElement> en)
		{
			foreach (XElement c in en)
			{
				return false;
			}
			return true;
		}

		string GetPathRelativeTo(string BasePath, string ToPath)
		{
			Uri path1 = new Uri(BasePath);
			Uri path2 = new Uri(ToPath);
			Uri diff = path1.MakeRelativeUri(path2);
			return diff.ToString();
		}

		public override bool WriteProjectFile(List<UnrealTargetPlatform> InPlatforms, List<UnrealTargetConfiguration> InConfigurations, PlatformProjectGeneratorCollection PlatformProjectGenerators, ILogger Logger)
		{
			bool bSuccess = false;
			string ProjectNameRaw = ProjectFilePath.GetFileNameWithoutExtension();
			//string ProjectPath = ProjectFilePath.FullName;
			string ProjectExtension = ProjectFilePath.GetExtension();
			string ProjectPlatformName = BuildHostPlatform.Current.Platform.ToString();

			// Get the output directory
			string EngineRootDirectory = Unreal.EngineDirectory.FullName;

			//
			// Build the working directory of the Game executable.
			//

			string GameWorkingDirectory = "";
			if (OnlyGameProject != null)
			{
				GameWorkingDirectory = Path.Combine(Path.GetDirectoryName(OnlyGameProject.FullName)!, "Binaries", ProjectPlatformName);
			}
			//
			// Build the working directory of the UnrealEditor executable.
			//
			string UnrealEngineEditorWorkingDirectory = Path.Combine(EngineRootDirectory, "Binaries", ProjectPlatformName);

			//
			// Create the folder where the project files goes if it does not exist
			//
			string FilePath = Path.GetDirectoryName(ProjectFilePath.FullName)!;
			if ((FilePath.Length > 0) && !Directory.Exists(FilePath))
			{
				Directory.CreateDirectory(FilePath);
			}

			string GameProjectFile = "";
			if (OnlyGameProject != null)
			{
				GameProjectFile = OnlyGameProject.FullName;
			}

			//
			// Write all targets which will be separate projects.
			//
			foreach (Project target in ProjectTargets)
			{
				string[] tmp = target.ToString()!.Split('.');
				string ProjectTargetFileName = Path.GetDirectoryName(ProjectFilePath.FullName) + "/" + tmp[0] + ProjectExtension;
				string TargetName = tmp[0];
				TargetType ProjectTargetType = target.TargetRules!.Type;

				//
				// Create the CodeLites root element.
				//
				XElement CodeLiteProject = new XElement("CodeLite_Project");
				XAttribute CodeLiteProjectAttributeName = new XAttribute("Name", TargetName);
				CodeLiteProject.Add(CodeLiteProjectAttributeName);

				//
				// Select only files we want to add.
				// TODO Maybe skipping those files directly in the following foreach loop is faster?
				//
				List<SourceFile> FilterSourceFile = SourceFiles.FindAll(s => (
					s.Reference.HasExtension(".h")
					|| s.Reference.HasExtension(".cpp")
					|| s.Reference.HasExtension(".c")
					|| s.Reference.HasExtension(".cs")
					|| s.Reference.HasExtension(".uproject")
					|| s.Reference.HasExtension(".uplugin")
					|| s.Reference.HasExtension(".ini")
					|| s.Reference.HasExtension(".usf")
					|| s.Reference.HasExtension(".ush")
				));

				//
				// Find/Create the correct virtual folder and place the file into it.
				//
				foreach (SourceFile CurrentFile in FilterSourceFile)
				{
					//
					// Try to get the correct relative folder representation for the project.
					//
					string CurrentFilePath = "";
					// TODO It seems that the full pathname doesn't work for some files like .ini, .usf, .ush
					if ((ProjectTargetType == TargetType.Client) ||
						(ProjectTargetType == TargetType.Editor) ||
						(ProjectTargetType == TargetType.Game) ||
						(ProjectTargetType == TargetType.Server))
					{
						if (TargetName.Equals("UnrealClient") ||
							TargetName.Equals("UnrealServer") ||
							TargetName.Equals("UnrealGame") ||
							TargetName.Equals("UnrealEditor"))
						{
							int Idx = Unreal.EngineDirectory.FullName.Length;
							CurrentFilePath = Path.GetDirectoryName(Path.GetFullPath(CurrentFile.Reference.FullName))!.Substring(Idx);
						}
						else
						{
							int Idx = Path.GetDirectoryName(CurrentFile.Reference.FullName)!.IndexOf(ProjectNameRaw) + ProjectNameRaw.Length;
							CurrentFilePath = Path.GetDirectoryName(CurrentFile.Reference.FullName)!.Substring(Idx);
						}
					}
					else if (ProjectTargetType == TargetType.Program)
					{
						//
						// We do not need all the editors subfolders to show the content. Find the correct programs subfolder.
						//
						int Idx = Path.GetDirectoryName(CurrentFile.Reference.FullName)!.IndexOf(TargetName) + TargetName.Length;
						CurrentFilePath = Path.GetDirectoryName(CurrentFile.Reference.FullName)!.Substring(Idx);
					}

					char[] Delimiters = new char[] { '/', '\\' };
					string[] SplitFolders = CurrentFilePath.Split(Delimiters, StringSplitOptions.RemoveEmptyEntries);
					//
					// Set the CodeLite root folder again.
					//
					XElement root = CodeLiteProject;

					//
					// Iterate through all XElement virtual folders until we find the right place to put the file.
					// TODO this looks more like a hack to me.
					//
					foreach (string FolderName in SplitFolders)
					{
						if (String.IsNullOrEmpty(FolderName))
						{
							continue;
						}

						//
						// Let's look if there is a virtual folder withint the current XElement.
						//
						IEnumerable<XElement> tests = root.Elements("VirtualDirectory");
						if (IsEmpty(tests))
						{
							//
							// No, then we have to create.
							//
							XElement vf = new XElement("VirtualDirectory");
							XAttribute vfn = new XAttribute("Name", FolderName);
							vf.Add(vfn);
							root.Add(vf);
							root = vf;
						}
						else
						{
							//
							// Yes, then let's find the correct sub XElement.
							//
							bool notfound = true;

							//
							// We have some virtual directories let's find the correct one.
							//
							foreach (XElement element in tests)
							{
								//
								// Look the the following folder
								XAttribute? attribute = element.Attribute("Name");
								if (attribute?.Value == FolderName)
								{
									// Ok, we found the folder as subfolder, let's use it.
									root = element;
									notfound = false;
									break;
								}
							}
							//
							// If we are here we didn't find any XElement with that subfolder, then we have to create.
							//
							if (notfound)
							{
								XElement vf = new XElement("VirtualDirectory");
								XAttribute vfn = new XAttribute("Name", FolderName);
								vf.Add(vfn);
								root.Add(vf);
								root = vf;
							}
						}
					}

					//
					// If we are at this point we found the correct XElement folder
					//
					XElement file = new XElement("File");
					XAttribute fileAttribute = new XAttribute("Name", CurrentFile.Reference.FullName);
					file.Add(fileAttribute);
					root.Add(file);
				}

				XElement CodeLiteSettings = new XElement("Settings");
				CodeLiteProject.Add(CodeLiteSettings);

				XElement CodeLiteGlobalSettings = new XElement("GlobalSettings");
				CodeLiteProject.Add(CodeLiteGlobalSettings);

				foreach (UnrealTargetConfiguration CurConf in InConfigurations)
				{
					XElement CodeLiteConfiguration = new XElement("Configuration");
					XAttribute CodeLiteConfigurationName = new XAttribute("Name", CurConf.ToString());
					CodeLiteConfiguration.Add(CodeLiteConfigurationName);

					//
					// Create Configuration General part. 
					//
					XElement CodeLiteConfigurationGeneral = new XElement("General");

					//
					// Create the executable filename.
					//
					string ExecutableToRun = "";
					string PlatformConfiguration = "-" + ProjectPlatformName + "-" + CurConf.ToString();
					if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Linux)
					{
						ExecutableToRun = "./" + TargetName;
						if ((ProjectTargetType == TargetType.Game) ||
							(ProjectTargetType == TargetType.Program))
						{
							if (CurConf != UnrealTargetConfiguration.Development)
							{
								ExecutableToRun += PlatformConfiguration;
							}
						}
						else if (ProjectTargetType == TargetType.Editor)
						{
							ExecutableToRun = "./UnrealEditor";
							if ((CurConf == UnrealTargetConfiguration.Debug) ||
								(CurConf == UnrealTargetConfiguration.Shipping) ||
								(CurConf == UnrealTargetConfiguration.Test))
							{
								ExecutableToRun += PlatformConfiguration;
							}
						}
					}
					else if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Mac)
					{
						ExecutableToRun = "./" + TargetName;
						if ((ProjectTargetType == TargetType.Game) || (ProjectTargetType == TargetType.Program))
						{
							if (CurConf != UnrealTargetConfiguration.Development)
							{
								ExecutableToRun += PlatformConfiguration;
							}
							ExecutableToRun += ".app/Contents/MacOS/" + TargetName;
							if (CurConf != UnrealTargetConfiguration.Development)
							{
								ExecutableToRun += PlatformConfiguration;
							}
						}
						else if (ProjectTargetType == TargetType.Editor)
						{
							ExecutableToRun = "./UnrealEditor";
							if ((CurConf == UnrealTargetConfiguration.Debug) ||
								(CurConf == UnrealTargetConfiguration.Shipping) ||
								(CurConf == UnrealTargetConfiguration.Test))
							{
								ExecutableToRun += PlatformConfiguration;
							}
							ExecutableToRun += ".app/Contents/MacOS/UnrealEditor";
							if ((CurConf != UnrealTargetConfiguration.Development) && (CurConf != UnrealTargetConfiguration.DebugGame))
							{
								ExecutableToRun += PlatformConfiguration;
							}
						}
					}
					else if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Win64)
					{
						ExecutableToRun = TargetName;
						if ((ProjectTargetType == TargetType.Game) || (ProjectTargetType == TargetType.Program))
						{
							if (CurConf != UnrealTargetConfiguration.Development)
							{
								ExecutableToRun += PlatformConfiguration;
							}
						}
						else if (ProjectTargetType == TargetType.Editor)
						{
							ExecutableToRun = "UnrealEditor";
							if ((CurConf == UnrealTargetConfiguration.Debug) ||
								(CurConf == UnrealTargetConfiguration.Shipping) ||
								(CurConf == UnrealTargetConfiguration.Test))
							{
								ExecutableToRun += PlatformConfiguration;
							}
						}

						ExecutableToRun += ".exe";

					}
					else
					{
						throw new BuildException("Unsupported platform.");
					}

					// Is this project a Game type?
					XAttribute GeneralExecutableToRun = new XAttribute("Command", ExecutableToRun);
					if (ProjectTargetType == TargetType.Game)
					{
						if (CurConf.ToString().Contains("Debug"))
						{
							string commandArguments = " -debug";
							XAttribute GeneralExecutableToRunArguments = new XAttribute("CommandArguments", commandArguments);
							CodeLiteConfigurationGeneral.Add(GeneralExecutableToRunArguments);
						}
						if (TargetName.Equals("UnrealGame"))
						{
							XAttribute GeneralExecutableWorkingDirectory = new XAttribute("WorkingDirectory", UnrealEngineEditorWorkingDirectory);
							CodeLiteConfigurationGeneral.Add(GeneralExecutableWorkingDirectory);
						}
						else
						{
							XAttribute GeneralExecutableWorkingDirectory = new XAttribute("WorkingDirectory", GameWorkingDirectory);
							CodeLiteConfigurationGeneral.Add(GeneralExecutableWorkingDirectory);
						}
					}
					else if (ProjectTargetType == TargetType.Editor)
					{
						if (TargetName != "UnrealEditor" && !String.IsNullOrEmpty(GameProjectFile))
						{
							string commandArguments = "\"" + GameProjectFile + "\"" + " -game";
							XAttribute CommandArguments = new XAttribute("CommandArguments", commandArguments);
							CodeLiteConfigurationGeneral.Add(CommandArguments);
						}
						XAttribute WorkingDirectory = new XAttribute("WorkingDirectory", UnrealEngineEditorWorkingDirectory);
						CodeLiteConfigurationGeneral.Add(WorkingDirectory);
					}
					else if (ProjectTargetType == TargetType.Program)
					{
						XAttribute WorkingDirectory = new XAttribute("WorkingDirectory", UnrealEngineEditorWorkingDirectory);
						CodeLiteConfigurationGeneral.Add(WorkingDirectory);
					}
					else if (ProjectTargetType == TargetType.Client)
					{
						XAttribute WorkingDirectory = new XAttribute("WorkingDirectory", UnrealEngineEditorWorkingDirectory);
						CodeLiteConfigurationGeneral.Add(WorkingDirectory);
					}
					else if (ProjectTargetType == TargetType.Server)
					{
						XAttribute WorkingDirectory = new XAttribute("WorkingDirectory", UnrealEngineEditorWorkingDirectory);
						CodeLiteConfigurationGeneral.Add(WorkingDirectory);
					}
					CodeLiteConfigurationGeneral.Add(GeneralExecutableToRun);

					CodeLiteConfiguration.Add(CodeLiteConfigurationGeneral);

					//
					// End of Create Configuration General part. 
					//

					//
					// Create Configuration Custom Build part. 
					//
					XElement CodeLiteConfigurationCustomBuild = new XElement("CustomBuild");
					CodeLiteConfiguration.Add(CodeLiteConfigurationGeneral);
					XAttribute CodeLiteConfigurationCustomBuildEnabled = new XAttribute("Enabled", "yes");
					CodeLiteConfigurationCustomBuild.Add(CodeLiteConfigurationCustomBuildEnabled);

					//
					// Add the working directory for the custom build commands.
					//
					XElement CustomBuildWorkingDirectory = new XElement("WorkingDirectory");
					XText CustuomBuildWorkingDirectory = new XText(Unreal.UnrealBuildToolDllPath.Directory.FullName);
					CustomBuildWorkingDirectory.Add(CustuomBuildWorkingDirectory);
					CodeLiteConfigurationCustomBuild.Add(CustomBuildWorkingDirectory);

					//
					// End of Add the working directory for the custom build commands.
					//

					//
					// Make Build Target.
					//
					XElement CustomBuildCommand = new XElement("BuildCommand");
					CodeLiteConfigurationCustomBuild.Add(CustomBuildCommand);

					string BuildTarget = TargetName + " " + ProjectPlatformName + " " + CurConf.ToString();
					if (BuildHostPlatform.Current.Platform != UnrealTargetPlatform.Win64)
					{
						string PlatformName = "Linux";
						if (BuildHostPlatform.Current.Platform == UnrealTargetPlatform.Mac)
						{
							PlatformName = "Mac";
						}

						BuildTarget = Path.Combine(Unreal.EngineDirectory.FullName, "Build/BatchFiles", PlatformName, "Build.sh") + " " + BuildTarget;
					}
					else
					{
						BuildTarget = $"{Unreal.DotnetPath} \"{Unreal.UnrealBuildToolDllPath}\" {BuildTarget}";
					}

					if (GameProjectFile.Length > 0)
					{
						BuildTarget += " -project=" + "\"" + GameProjectFile + "\"";
					}

					XText commandLine = new XText(BuildTarget);
					CustomBuildCommand.Add(commandLine);

					//
					// End of Make Build Target
					//

					//
					// Clean Build Target.
					//
					XElement CustomCleanCommand = new XElement("CleanCommand");
					CodeLiteConfigurationCustomBuild.Add(CustomCleanCommand);

					string CleanTarget = BuildTarget + " -clean";
					XText CleanCommandLine = new XText(CleanTarget);

					CustomCleanCommand.Add(CleanCommandLine);

					//
					// End of Clean Build Target.
					//

					//
					// Rebuild Build Target.
					//
					XElement CustomRebuildCommand = new XElement("RebuildCommand");
					CodeLiteConfigurationCustomBuild.Add(CustomRebuildCommand);

					string RebuildTarget = CleanTarget + "\n" + BuildTarget;
					XText RebuildCommandLine = new XText(RebuildTarget);

					CustomRebuildCommand.Add(RebuildCommandLine);

					//
					// End of Clean Build Target.
					//

					//
					// Some other fun Custom Targets.
					//
					if (ProjectTargetType == TargetType.Game)
					{
						string CookGameCommandLine = "dotnet AutomationTool.exe BuildCookRun ";

						// Projects filename
						if (OnlyGameProject != null)
						{
							CookGameCommandLine += "-project=\"" + OnlyGameProject.FullName + "\" ";
						}

						// Disables Perforce functionality 
						CookGameCommandLine += "-noP4 ";

						// Do not kill any spawned processes on exit
						CookGameCommandLine += "-nokill ";
						CookGameCommandLine += "-clientconfig=" + CurConf.ToString() + " ";
						CookGameCommandLine += "-serverconfig=" + CurConf.ToString() + " ";
						CookGameCommandLine += "-platform=" + ProjectPlatformName + " ";
						CookGameCommandLine += "-targetplatform=" + ProjectPlatformName + " "; // TODO Maybe I can add all the supported one.
						CookGameCommandLine += "-nocompile ";
						CookGameCommandLine += "-compressed -stage -deploy";

						//
						// Cook Game.
						//
						XElement CookGame = new XElement("Target");
						XAttribute CookGameName = new XAttribute("Name", "Cook Game");
						XText CookGameCommand = new XText(CookGameCommandLine + " -cook");
						CookGame.Add(CookGameName);
						CookGame.Add(CookGameCommand);
						CodeLiteConfigurationCustomBuild.Add(CookGame);

						XElement CookGameOnTheFly = new XElement("Target");
						XAttribute CookGameNameOnTheFlyName = new XAttribute("Name", "Cook Game on the fly");
						XText CookGameOnTheFlyCommand = new XText(CookGameCommandLine + " -cookonthefly");
						CookGameOnTheFly.Add(CookGameNameOnTheFlyName);
						CookGameOnTheFly.Add(CookGameOnTheFlyCommand);
						CodeLiteConfigurationCustomBuild.Add(CookGameOnTheFly);

						XElement SkipCook = new XElement("Target");
						XAttribute SkipCookName = new XAttribute("Name", "Skip Cook Game");
						XText SkipCookCommand = new XText(CookGameCommandLine + " -skipcook");
						SkipCook.Add(SkipCookName);
						SkipCook.Add(SkipCookCommand);
						CodeLiteConfigurationCustomBuild.Add(SkipCook);

					}
					//
					// End of Some other fun Custom Targets.
					//
					CodeLiteConfiguration.Add(CodeLiteConfigurationCustomBuild);

					//
					// End of Create Configuration Custom Build part. 
					//

					CodeLiteSettings.Add(CodeLiteConfiguration);
				}

				CodeLiteSettings.Add(CodeLiteGlobalSettings);

				//
				// Save the XML file.
				//
				CodeLiteProject.Save(ProjectTargetFileName);

				bSuccess = true;
			}
			return bSuccess;
		}
	}
}