/**
  *	Get the extension to use for the given binary type
  *
  *	@param	InBinaryType		The binrary type being built
  *
  *	@return	string				The binary extenstion (ie 'exe' or 'dll')
  */
 public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
 {
     if (GetActiveArchitecture() == "-win32")
     {
         switch (InBinaryType)
         {
             case UEBuildBinaryType.DynamicLinkLibrary:
                 return ".dll";
             case UEBuildBinaryType.Executable:
                 return ".exe";
             case UEBuildBinaryType.StaticLibrary:
                 return ".lib";
         }
         return base.GetBinaryExtension(InBinaryType);
     }
     else
     {
         if (InBinaryType == UEBuildBinaryType.StaticLibrary)
         {
             return ".bc";
         }
         else
         {
             return ".js";
         }
     }
 }

 /**
  *	Get the extension to use for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The binary extension (i.e. 'exe' or 'dll')
  */
 public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
 {
     switch (InBinaryType)
     {
         case UEBuildBinaryType.DynamicLinkLibrary:
             return ".dll";
         case UEBuildBinaryType.Executable:
             return ".exe";
         case UEBuildBinaryType.StaticLibrary:
             return ".lib";
     }
     return base.GetBinaryExtension(InBinaryType);
 }

 /**
  *	Get the extension to use for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The binary extension (i.e. 'exe' or 'dll')
  */
 public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
 {
     switch (InBinaryType)
     {
         case UEBuildBinaryType.DynamicLinkLibrary:
             return ".dll";
         case UEBuildBinaryType.Executable:
             return ".exe";
         case UEBuildBinaryType.StaticLibrary:
             return ".lib";
         case UEBuildBinaryType.Object:
             return ".obj";
         case UEBuildBinaryType.PrecompiledHeader:
             return ".pch";
     }
     return base.GetBinaryExtension(InBinaryType);
 }

        bool IsBuildingLibrary(UEBuildBinaryType Type)
        {
            if (BuildConfiguration.bRunUnrealCodeAnalyzer)
            {
                return false;
            }

            return Type == UEBuildBinaryType.StaticLibrary;
        }

		/**
		 *	Get the extension to use for debug info for the given binary type
		 *	
		 *	@param	InBinaryType		The binary type being built
		 *	
		 *	@return	string				The debug info extension (i.e. 'pdb')
		 */
		public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
		{
			switch (InBinaryType)
			{
				case UEBuildBinaryType.DynamicLinkLibrary:
					return BuildConfiguration.bGeneratedSYMFile || BuildConfiguration.bUsePDBFiles ? ".dsym" : "";
				case UEBuildBinaryType.Executable:
					return BuildConfiguration.bGeneratedSYMFile || BuildConfiguration.bUsePDBFiles ? ".dsym" : "";
				case UEBuildBinaryType.StaticLibrary:
					return "";
				case UEBuildBinaryType.Object:
					return "";
				case UEBuildBinaryType.PrecompiledHeader:
					return "";
				default:
					return "";
			}
		}

        /// <summary>
        /// The configuration class for a binary build.
        /// </summary>
        /// <param name="InType"></param>
        /// <param name="InOutputFilePath"></param>
        /// <param name="bInAllowExports"></param>
        /// <param name="bInCreateImportLibrarySeparately"></param>
        /// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
        /// <param name="InProjectFilePath"></param>
        /// <param name="InModuleNames"></param>
        public UEBuildBinaryConfiguration(
				UEBuildBinaryType InType,
				string[] InOutputFilePaths = null,
				string InIntermediateDirectory = null,
				bool bInAllowExports = false,
				bool bInCreateImportLibrarySeparately = false,
				bool bInIncludeDependentLibrariesInLibrary = false,
				bool bInAllowCompilation = true,
				bool bInHasModuleRules = true,
                bool bInIsCrossTarget = false,
				string InProjectFilePath = "",
				List<string> InModuleNames = null
			)
        {
            Type = InType;
            OutputFilePaths = InOutputFilePaths != null ? (string[])InOutputFilePaths.Clone() : null;
            IntermediateDirectory = InIntermediateDirectory;
            bAllowExports = bInAllowExports;
            bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
            bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
            bAllowCompilation = bInAllowCompilation;
            bHasModuleRules = bInHasModuleRules;
            bIsCrossTarget = bInIsCrossTarget;
            ProjectFilePath = InProjectFilePath;
            if(InModuleNames != null)
            {
                ModuleNames.AddRange(InModuleNames);
            }
        }

		public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
		{
			if(BuildConfiguration.bGeneratedSYMFile)
			{
				return ".dSYM";
			}

			if(BuildConfiguration.bGeneratedSYMBundle)
			{
				return ".dSYM.zip";
			}

			return "";
		}

 /**
  *	Get the extension to use for debug info for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The debug info extension (i.e. 'pdb')
  */
 public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
 {
     if (GetActiveArchitecture() == "-win32")
     {
         switch (InBinaryType)
         {
             case UEBuildBinaryType.DynamicLinkLibrary:
                 return ".pdb";
             case UEBuildBinaryType.Executable:
                 return ".pdb";
         }
         return "";
     }
     else
     {
         return "";
     }
 }

        /**
         *	Get the extension to use for the given binary type
         *	
         *	@param	InBinaryType		The binrary type being built
         *	
         *	@return	string				The binary extenstion (ie 'exe' or 'dll')
         */
        public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
        {
            switch (InBinaryType)
            {
                case UEBuildBinaryType.DynamicLinkLibrary: 
                    return ".dll";
                case UEBuildBinaryType.Executable:
                    return ".exe";
                case UEBuildBinaryType.StaticLibrary:
                    return ".lib";
                case UEBuildBinaryType.Object:
					if (!BuildConfiguration.bRunUnrealCodeAnalyzer)
					{
						return ".obj";
					}
					else
					{
						return @".includes";
					}
                case UEBuildBinaryType.PrecompiledHeader:
                    return ".pch";
            }
            return base.GetBinaryExtension(InBinaryType);
        }

		/// <summary>
		/// Get the extension to use for the given binary type
		/// </summary>
		/// <param name="InBinaryType"> The binary type being built</param>
		/// <returns>string    The binary extension (ie 'exe' or 'dll')</returns>
		public override string GetBinaryExtension(UEBuildBinaryType InBinaryType)
		{
			if (HTML5Architecture == "-win32")
			{
				switch (InBinaryType)
				{
					case UEBuildBinaryType.DynamicLinkLibrary:
						return ".dll";
					case UEBuildBinaryType.Executable:
						return ".exe";
					case UEBuildBinaryType.StaticLibrary:
						return ".lib";
					case UEBuildBinaryType.Object:
						return ".o";
					case UEBuildBinaryType.PrecompiledHeader:
						return ".gch";
				}
				return base.GetBinaryExtension(InBinaryType);
			}
			else
			{
				switch (InBinaryType)
				{
					case UEBuildBinaryType.DynamicLinkLibrary:
						return ".js";
					case UEBuildBinaryType.Executable:
						return ".js";
					case UEBuildBinaryType.StaticLibrary:
						return ".bc";
					case UEBuildBinaryType.Object:
						return ".bc";
					case UEBuildBinaryType.PrecompiledHeader:
						return ".gch";
				}

				return base.GetBinaryExtension(InBinaryType);
			}
		}

		/// <summary>
		/// The configuration class for a binary build.
		/// </summary>
		/// <param name="InType"></param>
		/// <param name="InOutputFilePath"></param>
		/// <param name="bInAllowExports"></param>
		/// <param name="bInCreateImportLibrarySeparately"></param>
		/// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
		/// <param name="InProjectFilePath"></param>
		/// <param name="InModuleNames"></param>
		public UEBuildBinaryConfiguration(
				UEBuildBinaryType InType,
				IEnumerable<FileReference> InOutputFilePaths = null,
				DirectoryReference InIntermediateDirectory = null,
				bool bInAllowExports = false,
				bool bInCreateImportLibrarySeparately = false,
				bool bInIncludeDependentLibrariesInLibrary = false,
				bool bInAllowCompilation = true,
				bool bInHasModuleRules = true,
				bool bInIsCrossTarget = false,
				FileReference InProjectFilePath = null,
				IEnumerable<string> InModuleNames = null
			)
		{
			Type = InType;
			if (InOutputFilePaths != null)
			{
				OutputFilePaths.AddRange(InOutputFilePaths);
			}
			IntermediateDirectory = InIntermediateDirectory;
			bAllowExports = bInAllowExports;
			bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
			bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
			bAllowCompilation = bInAllowCompilation;
			bHasModuleRules = bInHasModuleRules;
			bIsCrossTarget = bInIsCrossTarget;
			ProjectFilePath = InProjectFilePath;
			if (InModuleNames != null)
			{
				ModuleNames.AddRange(InModuleNames);
			}
		}

 /**
  *	Get the extension to use for debug info for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The debug info extension (i.e. 'pdb')
  */
 public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
 {
     return ".pdb";
 }

        /// <summary>
        /// The configuration class for a binary build.
        /// </summary>
        /// <param name="InType"></param>
        /// <param name="InOutputFilePath"></param>
        /// <param name="bInAllowExports"></param>
        /// <param name="bInCreateImportLibrarySeparately"></param>
        /// <param name="bInIsCrossTarget">For most binaries, this is false. If this is a cross-platform binary build for a specific platform (for example XB1 DLL for a windows editor) this will be true.</param>
        /// <param name="InProjectFilePath"></param>
        /// <param name="InModuleNames"></param>
        public UEBuildBinaryConfiguration(
				UEBuildBinaryType InType,
				string InOutputFilePath = null,
				string InIntermediateDirectory = null,
				bool bInAllowExports = false,
				bool bInCreateImportLibrarySeparately = false,
				bool bInIncludeDependentLibrariesInLibrary = false,
				bool bInAllowCompilation = true,
                bool bInIsCrossTarget = false,
                bool bInCompileMonolithic = false,
				UnrealTargetConfiguration InTargetConfiguration = UnrealTargetConfiguration.Development,
				string InTargetName = "",
				string InProjectFilePath = "",
				List<string> InModuleNames = null
			)
        {
            Type = InType;
            OutputFilePath = InOutputFilePath;
            IntermediateDirectory = InIntermediateDirectory;
            bAllowExports = bInAllowExports;
            bCreateImportLibrarySeparately = bInCreateImportLibrarySeparately;
            bIncludeDependentLibrariesInLibrary = bInIncludeDependentLibrariesInLibrary;
            bAllowCompilation = bInAllowCompilation;
            bIsCrossTarget = bInIsCrossTarget;
            bCompileMonolithic = bInCompileMonolithic;
            TargetConfiguration = InTargetConfiguration;
            TargetName = InTargetName;
            ProjectFilePath = InProjectFilePath;
            ModuleNames = InModuleNames;
        }

        /// <summary>
        /// Makes a filename (without path) for a compiled binary (e.g. "Core-Win64-Debug.lib") */
        /// </summary>
        /// <param name="BinaryName">The name of this binary</param>
        /// <param name="Platform">The platform being built for</param>
        /// <param name="Configuration">The configuration being built</param>
        /// <param name="UndecoratedConfiguration">The target configuration which doesn't require a platform and configuration suffix. Development by default.</param>
        /// <param name="BinaryType">Type of binary</param>
        /// <returns>Name of the binary</returns>
        public static string MakeBinaryFileName(string BinaryName, UnrealTargetPlatform Platform, UnrealTargetConfiguration Configuration, UnrealTargetConfiguration UndecoratedConfiguration, UEBuildBinaryType BinaryType)
        {
            StringBuilder Result = new StringBuilder();

            if (Platform == UnrealTargetPlatform.Linux && (BinaryType == UEBuildBinaryType.DynamicLinkLibrary || BinaryType == UEBuildBinaryType.StaticLibrary))
            {
                Result.Append("lib");
            }

            Result.Append(BinaryName);

            if(Configuration != UndecoratedConfiguration)
            {
                Result.AppendFormat("-{0}-{1}", Platform.ToString(), Configuration.ToString());
            }

            IUEBuildPlatform BuildPlatform = UEBuildPlatform.GetBuildPlatform(Platform);
            Result.Append(BuildPlatform.ApplyArchitectureName(""));

            if (BuildConfiguration.bRunUnrealCodeAnalyzer)
            {
                Result.AppendFormat("-{0}.analysis", BuildConfiguration.UCAModuleToAnalyze);
            }
            else
            {
                Result.Append(BuildPlatform.GetBinaryExtension(BinaryType));
            }

            return Result.ToString();
        }

        /// <summary>
        /// Adds a binary for the given module. Does not check whether a binary already exists, or whether a binary should be created for this build configuration.
        /// </summary>
        /// <param name="ModuleName">Name of the binary</param>
        /// <param name="BinaryType">Type of binary to be created</param>
        /// <param name="bAllowCompilation">Whether this binary can be compiled. The function will check whether plugin binaries can be compiled.</param>
        /// <param name="bIsCrossTarget">True if module is for supporting a different target-platform</param>
        /// <returns>The new binary</returns>
        private UEBuildBinaryCPP AddBinaryForModule(string ModuleName, UEBuildBinaryType BinaryType, bool bAllowCompilation, bool bIsCrossTarget)
        {
            // Get the plugin info for this module
            PluginInfo Plugin = FindPluginForModule(ModuleName);

            // Get the root output directory and base name (target name/app name) for this binary
            string BaseOutputDirectory;
            if(Plugin != null)
            {
                BaseOutputDirectory = Path.GetFullPath(Plugin.Directory);
            }
            else if(RulesCompiler.IsGameModule(ModuleName) || !bUseSharedBuildEnvironment)
            {
                BaseOutputDirectory = Path.GetFullPath(ProjectDirectory);
            }
            else
            {
                BaseOutputDirectory = Path.GetFullPath(BuildConfiguration.RelativeEnginePath);
            }

            // Get the configuration that this module will be built in. Engine modules compiled in DebugGame will use Development.
            UnrealTargetConfiguration ModuleConfiguration = Configuration;
            if(Configuration == UnrealTargetConfiguration.DebugGame && !RulesCompiler.IsGameModule(ModuleName))
            {
                ModuleConfiguration = UnrealTargetConfiguration.Development;
            }

            // Get the output and intermediate directories for this module
            string OutputDirectory = Path.Combine(BaseOutputDirectory, "Binaries", Platform.ToString());
             			string IntermediateDirectory = Path.Combine(BaseOutputDirectory, BuildConfiguration.PlatformIntermediateFolder, AppName, ModuleConfiguration.ToString());

            // Append a subdirectory if the module rules specifies one
            ModuleRules ModuleRules;
            if(RulesCompiler.TryCreateModuleRules(ModuleName, TargetInfo, out ModuleRules) && !String.IsNullOrEmpty(ModuleRules.BinariesSubFolder))
            {
                OutputDirectory = Path.Combine(OutputDirectory, ModuleRules.BinariesSubFolder);
                IntermediateDirectory = Path.Combine(IntermediateDirectory, ModuleRules.BinariesSubFolder);
            }

            // Get the output filenames
            string BaseBinaryPath = Path.Combine(OutputDirectory, MakeBinaryFileName(AppName + "-" + ModuleName, Platform, ModuleConfiguration, Rules.UndecoratedConfiguration, BinaryType));
            string[] OutputFilePaths = UEBuildPlatform.GetBuildPlatform(Platform).FinalizeBinaryPaths(BaseBinaryPath);

            // Prepare the configuration object
            UEBuildBinaryConfiguration Config = new UEBuildBinaryConfiguration(BinaryType);
            Config.OutputFilePaths = OutputFilePaths;
            Config.IntermediateDirectory = IntermediateDirectory;
            Config.bHasModuleRules = (ModuleRules != null);
            Config.bAllowExports = (BinaryType == UEBuildBinaryType.DynamicLinkLibrary);
            Config.bAllowCompilation = bAllowCompilation;
            Config.bIsCrossTarget = bIsCrossTarget;
            Config.ModuleNames.Add(ModuleName);

            // Create the new binary
            UEBuildBinaryCPP Binary = new UEBuildBinaryCPP(this, Config);
            AppBinaries.Add(Binary);
            return Binary;
        }

        /** Given a UBT-built binary name (e.g. "Core"), returns a relative path to the binary for the current build configuration (e.g. "../Binaries/Win64/Core-Win64-Debug.lib") */
        public static string[] MakeBinaryPaths(string ModuleName, string BinaryName, UnrealTargetPlatform Platform, 
			UnrealTargetConfiguration Configuration, UEBuildBinaryType BinaryType, TargetRules.TargetType? TargetType, PluginInfo PluginInfo, string AppName, bool bForceNameAsForDevelopment = false, string ExeBinariesSubFolder = null)
        {
            // Determine the binary extension for the platform and binary type.
            var BuildPlatform = UEBuildPlatform.GetBuildPlatform(Platform);
            string BinaryExtension = BuildPlatform.GetBinaryExtension(BinaryType);

            UnrealTargetConfiguration LocalConfig = Configuration;
            if(Configuration == UnrealTargetConfiguration.DebugGame && !String.IsNullOrEmpty(ModuleName) && !RulesCompiler.IsGameModule(ModuleName))
            {
                LocalConfig = UnrealTargetConfiguration.Development;
            }

            string ModuleBinariesSubDir = "";
            if (BinaryType == UEBuildBinaryType.DynamicLinkLibrary && (string.IsNullOrEmpty(ModuleName) == false))
            {
                // Allow for modules to specify sub-folders in the Binaries folder
                var RulesFilename = RulesCompiler.GetModuleFilename(ModuleName);
                // Plugins can be binary-only and can have no rules object
                if (PluginInfo == null || !String.IsNullOrEmpty(RulesFilename))
                {
                    ModuleRules ModuleRulesObj = RulesCompiler.CreateModuleRules(ModuleName, new TargetInfo(Platform, Configuration, TargetType), out RulesFilename);
                    if (ModuleRulesObj != null)
                    {
                        ModuleBinariesSubDir = ModuleRulesObj.BinariesSubFolder;
                    }
                }
            }
            else if ( BinaryType == UEBuildBinaryType.Executable && string.IsNullOrEmpty(ExeBinariesSubFolder) == false )
            {
                ModuleBinariesSubDir = ExeBinariesSubFolder;
            }

            //@todo.Rocket: This just happens to work since exp and lib files go into intermediate...

            // Build base directory string ("../Binaries/<Platform>/")
            string BinariesDirName;
            if(TargetType.HasValue && TargetType.Value == TargetRules.TargetType.Program && UnrealBuildTool.HasUProjectFile() && !ProjectFileGenerator.bGenerateProjectFiles)
            {
                BinariesDirName = Path.Combine( UnrealBuildTool.GetUProjectPath(), "Binaries" );
            }
            else if( PluginInfo != null )
            {
                BinariesDirName = Path.Combine( PluginInfo.Directory, "Binaries" );
            }
            else
            {
                BinariesDirName = Path.Combine( "..", "Binaries" );
            }
            var BaseDirectory = Path.Combine( BinariesDirName, Platform.ToString());
            if (ModuleBinariesSubDir.Length > 0)
            {
                BaseDirectory = Path.Combine(BaseDirectory, ModuleBinariesSubDir);
            }

            string BinarySuffix = "";
            if ((PluginInfo != null) && (BinaryType != UEBuildBinaryType.DynamicLinkLibrary))
            {
                BinarySuffix = "-Static";
            }

            // append the architecture to the end of the binary name
            BinarySuffix = BuildPlatform.ApplyArchitectureName(BinarySuffix);

            string OutBinaryPath = "";
            // Append binary file name
            string Prefix = "";
            if (Platform == UnrealTargetPlatform.Linux && (BinaryType == UEBuildBinaryType.DynamicLinkLibrary || BinaryType == UEBuildBinaryType.StaticLibrary))
            {
                Prefix = "lib";
            }
            if (LocalConfig == UnrealTargetConfiguration.Development || bForceNameAsForDevelopment)
            {
                OutBinaryPath = Path.Combine(BaseDirectory, String.Format("{3}{0}{1}{2}", BinaryName, BinarySuffix, BinaryExtension, Prefix));
            }
            else
            {
                OutBinaryPath = Path.Combine(BaseDirectory, String.Format("{5}{0}-{1}-{2}{3}{4}",
                    BinaryName, Platform.ToString(), LocalConfig.ToString(), BinarySuffix, BinaryExtension, Prefix));
            }

            return BuildPlatform.FinalizeBinaryPaths(OutBinaryPath);
        }

 /**
  *	Get the extension to use for debug info for the given binary type
  *
  *	@param	InBinaryType		The binary type being built
  *
  *	@return	string				The debug info extension (i.e. 'pdb')
  */
 public virtual string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
 {
     throw new BuildException("GetDebugInfoExtension for {0} not handled in {1}", InBinaryType.ToString(), this.ToString());
 }

 public override string GetDebugInfoExtension(UEBuildBinaryType InBinaryType)
 {
     return BuildConfiguration.bGeneratedSYMFile ? ".dSYM" : "";
 }

 /**
  *	Get the extension to use for debug info for the given binary type
  *	
  *	@param	InBinaryType		The binary type being built
  *	
  *	@return	string				The debug info extension (i.e. 'pdb')
  */
 public override string GetDebugInfoExtension( UEBuildBinaryType InBinaryType )
 {
     switch (InBinaryType)
     {
         case UEBuildBinaryType.DynamicLinkLibrary:
         case UEBuildBinaryType.Executable:
             return ".pdb";
     }
     return "";
 }

        public static string GetPluginSubfolderName(UEBuildBinaryType InBinaryType, string InTargetName)
        {
            string SubFolderName = Path.Combine("Dynamic", InTargetName);
            if (InBinaryType != UEBuildBinaryType.DynamicLinkLibrary)
            {
                SubFolderName = Path.Combine("Static", InTargetName);
            }

            return SubFolderName;
        }