using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using Sharpmake;

namespace JustDance.Engine
{
    #region Engine Base Classes

    [Generate]
    internal abstract class EngineProject : BaseCppProject
    {
        protected EngineProject()
        {
            Name = GetType().Name.ReplaceFirst("_", ".");
            RootPath = SourcePath;
            SourceRootPath = @"[project.RootPath]";
            SourceFilesExtensions.Remove(".c");
        }
        
        protected override void ConfigureIncludes(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureIncludes(conf, target);
            conf.IncludePaths.Add(SourcePath);
            conf.IncludePaths.Add(ExternPath);
        }
    }
    
    [Generate]
    public class EngineSolution : BaseCppSolution
    {
        public EngineSolution()
        {
            Name = "Engine";
        }

        private bool IncludeEngineProject(BaseCppTarget target, Type type)
        {
            if (type == typeof(UAF_CSharpGenerator) || type == typeof(UAF_EngineWrapper) || type == typeof(UAF_EngineWrapper_Test))
            {
                return target.Platform.IsWindows() && target.Optimization != Optimization.Retail;
            }
            if (typeof(UnitTests_Project).IsAssignableFrom(type))
            {
                return target.Optimization != Optimization.Retail && 
                    (target.Platform.IsWindows()
                    || target.Platform == Platform.nx
                    || target.Platform == Platform.orbis
                    );
            }
            return true;
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterProjectsOfType<EngineProject>(target, type => IncludeEngineProject(target, type));
            if (target.Platform.IsWindows())
            {
                conf.AddProject<PleoExt>(target);
                conf.AddProject<PleoNet>(target);
            }
            conf.AddProject<Soundwich>(target);

            // gmock is only available on PC, Orbis, and NX in Debug & Release only
            if (        (target.Platform == Platform.win32 || target.Platform == Platform.win64 ||
                         target.Platform == Platform.orbis || target.Platform == Platform.nx)
                    &&  (target.Optimization == Optimization.Debug || target.Optimization == Optimization.Release) )
            {
                conf.AddProject<gmock>(target);    
            }
            
            
            Utilities.CreateShortcut(conf.SolutionFileName + ".sln", ResolveString(RootPath), ResolveString(conf.SolutionPath + "/"+conf.SolutionFileName + ".sln", conf, target));
        }
    }

    public static class EngineExtensions
    {
        public static void AddExternDependency<T>(this Project.Configuration configuration, ITarget target) where T: EngineExternProject
        {
            configuration.AddPrivateDependency<T>(target);
        }

        public static void IgnoreLibrary(this Project.Configuration configuration, params string[] libraries)
        {
            configuration.Options.Add(new Options.Vc.Linker.IgnoreSpecificLibraryNames(libraries));
        }
    }

    #endregion

    #region Core

    [Generate]
    internal class UAF_Core : EngineProject
    {
        public UAF_Core()
        {
            RootPath = SourcePath + "core";
            PrecompileHeader = "precompiled_core";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";

            conf.AddExternDependency<LuaLib>(target);
            conf.AddExternDependency<PugiXml>(target);
            conf.AddExternDependency<Mongoose>(target);

            conf.IncludePaths.Add(ExternPath + "/gear4");
            conf.IncludePaths.Add(ExternPath + "/gear4/eal/sources");
            conf.IncludePaths.Add(ExternPath + "/rapidjson/include");
            
            conf.If(!conf.Platform.IsUsingClang()).Options.Add(Options.Vc.Compiler.DefineCPlusPlus.Default);
        }
    }

    #endregion

    #region Engine

    [Generate]
    internal class UAF_Engine : EngineProject
    {
        public UAF_Engine()
        {
            RootPath = SourcePath + "engine";
            PrecompileHeader = "precompiled_engine";
            SourceFilesBlobExcludeRegex.Add("FriezeBuilder_InArchi.cpp", "FriezeBuilder_InArchiSimple.cpp", "FriezeBuilder_InPipe.cpp", "FriezeBuilder_InPipePatchSimple.cpp", "FriezeBuilder_InFrame.cpp", "Animation3D.cpp", "Animation3DInfo.cpp", "Animation3Dlist.cpp", "actor.cpp", "animLightComponent.cpp", "mesh3DComponent.cpp");
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";

            conf.AddPublicDependency<Raki>(target);
            conf.AddPublicDependency<Soundwich>(target);
            conf.AddPublicDependency<Pleo>(target);
            conf.AddPublicDependency<LibOgg>(target);
            conf.AddPublicDependency<LibVorbis>(target);
            conf.If(Platform.win32 | Platform.win64).AddExternDependency<Bloomberg>(target);
            conf.AddExternDependency<CaptureJpeg>(target);

            conf.If(Platform.win32 | Platform.win64).AddPublicDependency<GoTop>(target);

            conf.IncludePaths.Add(  ExternPath + "EDGE/edge_1_2_0/cell/host-common/include",
                                    ExternPath + "EDGE/edge_1_2_0/cell/target/common/include",
                                    ExternPath + "EDGE/edge_1_2_0/cell/target/ppu/include",
                                    ExternPath + "EDGE/edge_1_2_0/cell/target/spu/include",
                                    ExternPath + "UbiServices/custom/client-sdk/public",
                                    ExternPath + "UbiServices/custom/external/harbourcommon/libraries/harboureal/api/sources");

            if (target.Platform == Platform.durango)
            {
                conf.AdditionalLinkerOptions.Add("/ignore:4264,4221");
                conf.Options.Add(Options.Vc.Compiler.CompileAsWinRT.Enable);
            }

            conf.IncludePaths.Add(ExternPath + "/gear4");
            conf.IncludePaths.Add(ExternPath + "/gear4/eal/sources");

            conf.If(!conf.Platform.IsUsingClang()).Options.Add(Options.Vc.Compiler.DefineCPlusPlus.Default);
        }

        protected override void ConfigurePlatformFilters(Configuration conf, BaseCppTarget target)
        {
            if (conf.Platform.IsWindows())
            {
                base.ConfigurePlatformFilters(conf, target);
                //Special case because /x360/ZPadX360_common.cpp needs to be include on pc
                conf.SourceFilesBuildExcludeRegex.Remove(@"\\X360\\");
            }
            else
            {
                base.ConfigurePlatformFilters(conf, target);
            }
            
        }
    }

    #endregion

    #region Editor

    [Generate]
    internal class UAF_Editor : EngineProject
    {
        public UAF_Editor()
        {
            RootPath = SourcePath + "editor";
            PrecompileHeader = "precompiled_editor";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";
            conf.AddPrivateDependency<Raki>(target);

            conf.IncludePaths.Add(ExternPath + "EDGE/edge_1_2_0/cell/host-common/include",
                                  ExternPath + "EDGE/edge_1_2_0/cell/target/common/include",
                                  ExternPath + "EDGE/edge_1_2_0/cell/target/ppu/include",
                                  ExternPath + "EDGE/edge_1_2_0/cell/target/spu/include");

            conf.If(Platform.win32 | Platform.win64).IgnoreLibrary("LIBCMTD.lib");

            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add(".cpp");
            conf.If(Optimization.Retail).SourceFilesBuildExcludeRegex.Add(".cpp");
        }
    }

    #endregion

    #region Gameplay

    [Generate]
    internal class UAF_Gameplay : EngineProject
    {
        public UAF_Gameplay()
        {
            RootPath = SourcePath + "gameplay";
            PrecompileHeader = "precompiled_gameplay";
            SourceFilesBlobExcludeRegex.Add("GameInterface.cpp", "GameInterface_RegisterEngine.cpp", "GameInterface_RegisterEvent.cpp", "GameInterface_RegisterGameplay.cpp", "GameInterface_RegisterIA.cpp", "GameInterface_RegisterMisc.cpp", "GameInterface_RegisterTree.cpp");
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";

            conf.If(Platform.durango).Options.Add(Options.Vc.Compiler.CompileAsWinRT.Enable);

            conf.IncludePaths.Add(ExternPath + "EDGE/edge_1_2_0/cell/host-common/include",
                                  ExternPath + "EDGE/edge_1_2_0/cell/target/common/include",
                                  ExternPath + "EDGE/edge_1_2_0/cell/target/ppu/include",
                                  ExternPath + "EDGE/edge_1_2_0/cell/target/spu/include",
                                  ExternPath + "UbiServices/custom/client-sdk/public",
                                  ExternPath + "UbiServices/custom/external/harbourcommon/libraries/harboureal/api/sources",
                                  ExternPath + "rapidjson/include");
        }
    }

    #endregion
    
    #region InitFactory

    [Generate]
    internal class UAF_InitFactory : EngineProject
    {
        public UAF_InitFactory()
        {
            RootPath = SourcePath + "initfactory";
            PrecompileHeader = "precompiled_initfactory";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";
            conf.If(Platform.durango).Options.Add(Options.Vc.Compiler.CompileAsWinRT.Enable);

            conf.IncludePaths.Add(ExternPath + "UbiServices/custom/client-sdk/public",
                                  ExternPath + "UbiServices/custom/external/harbourcommon/libraries/harboureal/api/sources");
        }
    }

    #endregion

    #region Test

    [Generate]
    internal class UAF_Test : EngineProject
    {
        public UAF_Test()
        {
            RootPath = SourcePath + "test";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";
            conf.AddPrivateDependency<Raki>(target);
            conf.If(Optimization.Retail, Platform.win32 | Platform.win64).IgnoreLibrary("win32_UAF_Editor_f.lib");

            if (conf.Platform == Platform.orbis)
            {
                if (target.Optimization == Optimization.Debug || target.Optimization == Optimization.Release)
                {
                    conf.LibraryFiles.Add("SceMat_stub_weak", 10);
                }
            }
        }
    }

    #endregion

    #region Jobs

    internal abstract class UAF_Job : EngineProject
    {
        protected Configuration.OutputType JobType { get; set; }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            OutputType = Configuration.OutputType.Lib;
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF/Jobs";
        }
    }
    
    [Generate]
    internal class Job_EdgeAnim : UAF_Job
    {
        public Job_EdgeAnim()
        {
            JobType = Configuration.OutputType.Exe;
            RootPath = SourcePath + "Jobs/EdgeAnim";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.IncludePaths.Add( ExternPath + "EDGE/edge_1_2_0/cell/host-common/include",
                                                    ExternPath + "EDGE/edge_1_2_0/cell/target/common/include",
                                                    ExternPath + "EDGE/edge_1_2_0/cell/target/spu/include");
        }
    }

    #endregion

    #region Adapters

    [Generate]
    internal class UAF_Adapters : EngineProject
    {
        public UAF_Adapters()
        {
            RootPath = SourcePath + "adapters";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";

            conf.AddPrivateDependency<Raki>(target);
            conf.If(conf.Platform.IsMicrosoft()).Options.Add(new Options.Vc.Compiler.DisableSpecificWarnings(new[] { "4005" }));

            conf.IncludePaths.Add(ExternPath + "UbiServices/custom/client-sdk/public",
                                  ExternPath + "UbiServices/custom/external/harbourcommon/libraries/harboureal/api/sources",
                                  ExternPath + "rapidjson/include");

            if (conf.Platform == Platform.nx)
            {
                // not Using ubiservices openssl anymore, starting from NX SDK 11.2.0
            }
            else if (conf.Platform == Platform.durango)
            {
                conf.IncludePaths.Add(ExternPath + "openssl_x1/custom/include");
            }
            else if (conf.Platform == Platform.orbis)
            {
                conf.IncludePaths.Add(ExternPath + "UbiServices/custom/external/harbourcommon/libraries/openssl_deprecated/include");
            }
            else
            {
                conf.IncludePaths.Add(ExternPath + "UbiServices/custom/external/harbourcommon/libraries/openssl/include");
            }

            conf.IncludePaths.Add(SourcePath, ExternPath + "GLEW");

            //GFX
            conf.SourceFilesBuildExcludeRegex.Add("GFXAdapter_Vk");
            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add("GFXAdapter_Cooker");
            conf.IfNot(Platform.win32 | Platform.win64 | Platform.orbis | Platform.durango).SourceFilesBuildExcludeRegex.Add("GFXAdapter_DirectX11");
            conf.IfNot(Platform.durango).SourceFilesBuildExcludeRegex.Add("GFXAdapter_DirectX12");
            conf.SourceFilesBuildExcludeRegex.Add("GFXAdapter_Prospero");
            
            //SoundAdapter
            conf.If(!conf.Platform.IsMicrosoft()).SourceFilesBuildExcludeRegex.Add("SoundAdapter_XAudio");

            //Gesture
            conf.IfNot(Platform.durango | Platform.orbis | Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add("Adapter_Gesture_KinectGesture");
            conf.If(Platform.durango | Platform.orbis | Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add("Adapter_Kinect_fake");

            //Misc
            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add("InputAdapter_DirectInput", "SystemAdapter_w32Directx");
            conf.If(Platform.durango | Platform.orbis | Platform.nx).SourceFilesBuildExcludeRegex.Add("Adapter_Speech_Recognition_fake");
            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add("Adapter_SourceControl_Perforce");

            // We will exclude CryptoAdapter_Fake, but we will keep it around for future platforms without OpenSSL support.
            conf.SourceFilesBuildExcludeRegex.Add("CryptoAdapter_Fake");

            conf.If(Platform.win32 | Platform.win64).AdditionalLinkerOptions.Add("/ignore:4006");
            conf.If(Platform.durango).Options.Add(Options.Vc.Compiler.CompileAsWinRT.Enable);

            //uplay
            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add("UplayAdapter_WinCafe");
        }
    }

    #endregion
    
    #region EngineWrapper
    
    [Generate]
    internal class UAF_EngineWrapper : EngineProject
    {
        public static string DllPath = OutputPath + @"lib\EngineWrapper.dll";

        public UAF_EngineWrapper()
        {
            OutputType = Configuration.OutputType.DotNetClassLibrary;
            RootPath = SourcePath + "engineWrapper";
            SourceFilesBuildExcludeRegex.Add("utils.cpp");
		}

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";

            conf.TargetPath = OutputPath + @"\lib\";
            conf.TargetFileName = "EngineWrapper" + (target.Platform == Platform.win32 ? "32" : "");

            conf.AddPublicDependency<UAF_Adapters>(target);
            conf.AddPublicDependency<UAF_Core>(target);
            conf.AddPublicDependency<UAF_Engine>(target);
            conf.AddPublicDependency<UAF_Gameplay>(target);
            conf.AddPublicDependency<UAF_InitFactory>(target);
            conf.AddPublicDependency<UAF_Test>(target);
            conf.AddPublicDependency<JD_Test>(target);
            conf.AddExternDependency<ZLib>(target);
            conf.If(Platform.win32 | Platform.win64).AddExternDependency<Bloomberg>(target);
            conf.AddExternDependency<CaptureJpeg>(target);
            conf.AddExternDependency<LibOgg>(target);
            conf.AddExternDependency<LibVorbis>(target);
            conf.AddExternDependency<LibVpx>(target);
            conf.AddExternDependency<LibWebm>(target);
            conf.AddExternDependency<LibPng>(target);
            conf.AddPublicDependency<PluginGateway>(target);
            conf.AddPublicDependency<JD_Gameplay>(target);
            conf.AddPublicDependency<Plugins>(target);
            conf.AddPublicDependency<UAF_Editor>(target);
            conf.AddPublicDependency<JD_Editor>(target);
            conf.AddExternDependency<FreeImage>(target);
            conf.AddExternDependency<WiiYourself>(target);
            conf.AddPublicDependency<Job_EdgeAnim>(target);
            conf.AddExternDependency<MoveSpace>(target);
            conf.AddExternDependency<Squish>(target);
            conf.AddExternDependency<Scry>(target);
			
			// For DTEST
			if (target.Optimization == Optimization.Debug || target.Optimization == Optimization.Release)
            {
                if ((conf.Platform == Platform.win64 && target.ApplicationType == ApplicationType.Editor)
					|| conf.Platform == Platform.durango
					|| conf.Platform == Platform.nx
					|| conf.Platform == Platform.orbis)
                {
					conf.AddPublicDependency<JD_DTest>(target);
                }
            }

            string vsVersion = (target.DevEnv == DevEnv.vs2012 ? "vs11" : (target.DevEnv == DevEnv.vs2015 ? "vs14" : "vs15"));
            string procArch = (target.DevEnv == DevEnv.vs2015 || target.DevEnv == DevEnv.vs2017) ? (conf.Platform == Platform.win32 ? "x86/" : "x64/") : "";
            string plainArch = conf.Platform == Platform.win64 ? "64" : "32";
            string winArch = "win" + plainArch;
            string P4Arch = procArch;
            string ubiservicesArch = winArch;
            string edgeArch = conf.Platform == Platform.win64 ? "x64" : "Win32";
            string kinectArch = conf.Platform == Platform.win64 ? "amd64" : "x86";
            string wiiYourselfArch = conf.Platform == Platform.win64 ? "/x64" : "";

            conf.If(Optimization.Debug | Optimization.Release).LibraryPaths.Add(ExternPath + "p4/lib/" + vsVersion + "/" + P4Arch + target.Optimization);
            conf.LibraryPaths.Add(  /*ExternPath + "UbiServices/custom/lib/SdkClient/win64_2015/" + target.Optimization,*/
                                    ExternPath + "UbiServices/custom/lib/SdkClient/" + ubiservicesArch + "_" + target.DevEnv.GetDevEnvString() + "/" + target.Optimization,
                                    ExternPath + "WiiYourself_1.15/miniDDK/lib" + wiiYourselfArch,
                                    ExternPath + "EDGE/edge_1_2_0/lib/" + edgeArch +"/VS" + target.DevEnv.GetDevEnvString(),
                                    ExternPath + "KinectPC_Sdk/v1.8/Lib/" + kinectArch,
                                    ExternPath + "KinectGesture/Lib");

            if (conf.Platform == Platform.durango)
            {
                conf.LibraryPaths.Add(ExternPath + "openssl_x1/custom/libs");
            }

            string libNvttArch = target.DevEnv == DevEnv.vs2012 ? "32" :
                                 target.DevEnv == DevEnv.vs2015 ? plainArch :
                                 target.DevEnv == DevEnv.vs2017 ? plainArch :
                                                                  "32";

            string libNvttSuffix = target.DevEnv == DevEnv.vs2012 ? "_vs12" :
                                   target.DevEnv == DevEnv.vs2015 ? "_vs15" :
                                   target.DevEnv == DevEnv.vs2017 ? "_vs17" :
                                                                    "";

            string libNvttName = "nvtt" + libNvttArch + libNvttSuffix + ".lib";

            string kinectGestureArch = ((target.DevEnv == DevEnv.vs2015 || target.DevEnv == DevEnv.vs2017) && conf.Platform == Platform.win64) ? "x64" : "PC";

            conf.LibraryFiles.Add("edgeanim_" + winArch + "_r.lib");
            conf.If(Optimization.Debug).LibraryFiles.Add("Version.lib", "xapobased.lib", "nvcore.lib", "nvimage.lib", "nvmath.lib", libNvttName, "dxguid.lib", "xaudio2_8.lib", "d3d9.lib", "winmm.lib", "d3d11.lib", "dxgi.lib", "dinput8.lib", "XInput.lib", "winmm.lib", "IpHlpApi.lib", "Wininet.lib", "ws2_32.lib", "dsound.lib");
            conf.If(Optimization.Release).LibraryFiles.Add("xapobase.lib");
            conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("libclient.lib", "libsupp.lib", "librpc.lib", "libp4api.lib", "libp4script.lib", "libp4script_c.lib", "libp4script_curl.lib", "libp4script_sqlite.lib");
            conf.If(Optimization.Release | Optimization.Retail).LibraryFiles.Add("Version.lib", "nvcore.lib", "nvimage.lib", "nvmath.lib", libNvttName, "dxguid.lib", "xaudio2_8.lib", "d3d9.lib", "winmm.lib", "dinput8.lib", "XInput.lib", "winmm.lib", "d3d11.lib", "dxgi.lib", "IpHlpApi.lib", "Wininet.lib", "ws2_32.lib", "dsound.lib");
            conf.AdditionalLinkerOptions.Add("/ignore:4204");
            conf.LibraryFiles.Add("psapi.lib");
            conf.If(Optimization.Debug).LibraryFiles.Add("KinectGesture_" + vsVersion + "_" + kinectGestureArch + "d.lib");
            conf.If(Optimization.Release | Optimization.Retail).LibraryFiles.Add("KinectGesture_" + vsVersion + "_" + kinectGestureArch + "r.lib");
            conf.LibraryFiles.Add("Kinect10.lib");
            conf.If(Optimization.Debug).IgnoreLibrary("LIBCMTD.lib");
            conf.IgnoreLibrary("LIBCMT.lib");

            // UbiServices
            conf.LibraryFiles.Add("libcurl.lib", "ubiservices.lib", "uszlib.lib", "nghttp2.lib", "crypt32.lib");

            if (conf.Platform == Platform.durango)
            {
                // For Durango, these are from extern/openssl_x1/custom
                // For Scarlett, these are from the Ubiservices libs directory
                conf.LibraryFiles.Add("libcrypto.lib", "libssl.lib");
            }
            else
            {
                // This is the one from Ubiservices, for all other platforms.
                conf.LibraryFiles.Add("openSSL.lib");
            }

            //Media Foundation
            if (conf.Platform.IsWindows())
            {
                conf.LibraryFiles.Add("mf.lib", "mfplat.lib", "mfreadwrite.lib", "mfuuid.lib", "shlwapi.lib", "wmcodecdspuuid.lib");
            }

            conf.Options.Add(Options.Vc.Linker.IgnoreImportLibrary.Enable);
            
            conf.ReferencesByName.Add("System");
            conf.ReferencesByName.Add("System.Core");
            conf.ReferencesByName.Add("System.Data");
            conf.ReferencesByName.Add("System.Windows.Forms");
            conf.ReferencesByName.Add("System.Xml");
        }

        protected override void ConfigureCompilerOptions(Project.Configuration conf, BaseCppTarget target)
        {
            conf.Options.Add(Options.Vc.General.CommonLanguageRuntimeSupport.ClrSupport);
            conf.Options.Add(Options.Vc.General.CharacterSet.Unicode);
            conf.Options.Add(Options.Vc.Compiler.RTTI.Disable);
            conf.Options.Add(Options.Vc.Compiler.Exceptions.EnableWithSEH);
            conf.Options.Add(Options.Vc.Compiler.RuntimeChecks.Default);
            conf.Options.Add(Options.Vc.Compiler.FloatingPointModel.Precise);
            conf.Options.Add(Options.Vc.Compiler.MinimalRebuild.Disable);
            conf.Options.Add(Options.Vc.General.WarningLevel.Level3);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
            conf.Options.Add(Options.Vc.General.WholeProgramOptimization.Disable);

            if (target.Optimization == Optimization.Debug)
                conf.Options.Add(Options.Vc.Compiler.Optimization.Disable);
            else if (target.Optimization == Optimization.Release)
                conf.Options.Add(Options.Vc.Compiler.Optimization.MaximizeSpeed);
            conf.Options.Add(Options.Vc.Compiler.Inline.Default);
            conf.Options.Add(Options.Vc.Compiler.Intrinsic.Disable);
            conf.Options.Add(Options.Vc.Compiler.FavorSizeOrSpeed.Neither);
            conf.Options.Add(Options.Vc.Compiler.OmitFramePointers.Disable);
            conf.Options.Add(Options.Vc.Compiler.FiberSafe.Disable);

            conf.If(Optimization.Debug).Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDebugDLL);
            conf.IfNot(Optimization.Debug).Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDLL);
        }

        protected override void ConfigureDefines(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("WRAPPER_C");
            conf.If(Optimization.Debug).Defines.Add("_DEBUG");
            conf.IfNot(Optimization.Debug).Defines.Add("NDEBUG", "_SECURE_SCL=0");
        }
    }

    #endregion
    
    #region UA_Engine

    [Generate]
    internal class UA_Engine : EngineProject
    {
        public UA_Engine()
        {
            RootPath = SourcePath + "appFramework";
            OutputType = Configuration.OutputType.Exe;
            Name = "ua_engine";
            PrecompileHeader = "precompiled_techno";
            DeployProject = true;

            Util.DirectoryGetFiles(ResolveString(DeploymentFilesPath + "/durango"), "*.png").ToList().ForEach(f => ResourceFiles.Add(f));
            Util.DirectoryGetFiles(ResolveString(SourcePath + "/appFramework/Durango"), "*.txt").ToList().ForEach(f => ResourceFiles.Add(f));
            ResourceFiles.Add(SourcePath + "/appFramework/Win32/itf_main_win32.rc");
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.If(target.Platform.IsWindows()).TargetFileName = Name + (target.Platform == Platform.win32 ? "32" : "");
            if (target.IsPcStandalone())
            {
                conf.TargetFileName = Globals.CurrentProjectName;
            }

            conf.Options.Add(Options.Vc.Linker.SubSystem.Application);

            conf.If(!conf.Platform.IsUsingClang()).Options.Add(Options.Vc.Compiler.DefineCPlusPlus.Default);

            conf.AddPublicDependency<UAF_Adapters>(target);
            conf.AddPublicDependency<UAF_Core>(target);
            conf.AddPublicDependency<UAF_Engine>(target);
            conf.AddPublicDependency<UAF_Gameplay>(target);
            conf.AddPublicDependency<UAF_InitFactory>(target);
            conf.AddPublicDependency<UAF_Test>(target);
            conf.AddPublicDependency<JD_Test>(target);
            conf.AddExternDependency<ZLib>(target);
            conf.If(Platform.win32 | Platform.win64).AddExternDependency<Bloomberg>(target);
            conf.AddExternDependency<CaptureJpeg>(target);
            conf.AddExternDependency<LibOgg>(target);
            conf.AddExternDependency<LibVorbis>(target);
            conf.AddExternDependency<LibVpx>(target);
            conf.AddExternDependency<LibWebm>(target);
            conf.AddExternDependency<LibPng>(target);
            conf.AddPublicDependency<PluginGateway>(target);
            conf.AddPublicDependency<JD_Gameplay>(target);
            conf.If(Platform.win32 | Platform.win64).AddPublicDependency<GoTop>(target);

            // For DTEST
            if (target.Optimization == Optimization.Debug || target.Optimization == Optimization.Release)
            {
                if ((conf.Platform == Platform.win64 && target.ApplicationType == ApplicationType.Editor)
					|| conf.Platform == Platform.durango
					|| conf.Platform == Platform.nx
					|| conf.Platform == Platform.orbis)
                {
					conf.AddPublicDependency<JD_DTest>(target);
                }
            }

            conf.IfNot(Optimization.Retail).AddPublicDependency<Plugins>(target);
            if (target.ApplicationType == ApplicationType.Editor)
            {
                conf.AddPublicDependency<UAF_Editor>(target);
                conf.AddPublicDependency<JD_Editor>(target);
                conf.AddExternDependency<FreeImage>(target);
                conf.AddExternDependency<WiiYourself>(target);
            }
            conf.AddPublicDependency<Job_EdgeAnim>(target);
            conf.If(Platform.win32 | Platform.win64 | Platform.orbis | Platform.durango | Platform.nx).AddExternDependency<MoveSpace>(target);
            conf.If(Platform.win32 | Platform.win64 | Platform.orbis | Platform.durango | Platform.nx).AddExternDependency<Squish>(target);
            conf.IfNot(Optimization.Retail)
                .If(Platform.win32 | Platform.win64 | Platform.orbis | Platform.durango | Platform.nx).AddExternDependency<Scry>(target);

            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExclude.Add(SourcePath + "/appFramework/Win32/itf_main_win32.rc");
            conf.If(Platform.durango).IgnoreLibrary("winmm.lib", "%(IgnoreSpecificDefaultLibraries)");
            conf.If(Optimization.Debug, Platform.durango).IgnoreLibrary("libcmtd.lib");
            conf.If(Optimization.Release | Optimization.Retail, Platform.durango).IgnoreLibrary("libcmt.lib");

            string vsVersion = (target.DevEnv == DevEnv.vs2012 ? "vs11" : (target.DevEnv == DevEnv.vs2015 ? "vs14" : "vs15"));

            if (conf.Platform.IsWindows())
            {
                string procArch = (target.DevEnv == DevEnv.vs2015 || target.DevEnv == DevEnv.vs2017) ? (conf.Platform == Platform.win32 ? "x86/" : "x64/") : "";
                string plainArch = conf.Platform == Platform.win64 ? "64" : "32";
                string winArch = "win" + plainArch;
                string P4Arch = procArch;
                string ubiservicesArch = winArch;
                string edgeArch = conf.Platform == Platform.win64 ? "x64" : "Win32";
                string kinectArch = conf.Platform == Platform.win64 ? "amd64" : "x86";
                string wiiYourselfArch = conf.Platform == Platform.win64 ? "/x64" : "";

                conf.Defines.Add("_CONSOLE");

                conf.IgnoreLibrary("LIBCMT.lib", "LIBCMTd.lib");
                conf.If(Optimization.Debug).IgnoreLibrary("msvcrt.lib");
                conf.If(Optimization.Retail).IgnoreLibrary(winArch + "_UAF_Editor_f.lib");

                conf.If(Optimization.Debug | Optimization.Release).LibraryPaths.Add(ExternPath + "p4/lib/" + vsVersion + "/" + P4Arch + target.Optimization);
                conf.LibraryPaths.Add(  /*ExternPath + "UbiServices/custom/lib/SdkClient/win64_2015/" + target.Optimization,*/
                                        ExternPath + "UbiServices/custom/lib/SdkClient/" + ubiservicesArch + "_" + target.DevEnv.GetDevEnvString() + "/" + target.Optimization,
                                        ExternPath + "WiiYourself_1.15/miniDDK/lib" + wiiYourselfArch,
                                        ExternPath + "EDGE/edge_1_2_0/lib/" + edgeArch + "/VS" + target.DevEnv.GetDevEnvString(),
                                        ExternPath + "KinectPC_Sdk/v1.8/Lib/" + kinectArch,
                                        ExternPath + "KinectGesture/Lib");

                string libNvttArch = target.DevEnv == DevEnv.vs2012 ? "32" :
                                     target.DevEnv == DevEnv.vs2015 ? plainArch :
                                     target.DevEnv == DevEnv.vs2017 ? plainArch :
                                                                      "32";

                string libNvttSuffix = target.DevEnv == DevEnv.vs2012 ? "_vs12" :
                                       target.DevEnv == DevEnv.vs2015 ? "_vs15" :
                                       target.DevEnv == DevEnv.vs2017 ? "_vs17" :
                                                                        "";

                string libNvttName = "nvtt" + libNvttArch + libNvttSuffix + ".lib";

                string kinectGestureArch = ((target.DevEnv == DevEnv.vs2015 || target.DevEnv == DevEnv.vs2017) && conf.Platform == Platform.win64) ? "x64" : "PC";

                conf.LibraryFiles.Add("edgeanim_" + winArch + "_r.lib");
                conf.If(Optimization.Debug).LibraryFiles.Add("Version.lib", "xapobased.lib", "nvcore.lib", "nvimage.lib", "nvmath.lib", libNvttName, "dxguid.lib", "xaudio2_8.lib", "d3d9.lib", "winmm.lib", "d3d11.lib", "dxgi.lib", "dinput8.lib", "XInput.lib", "winmm.lib", "IpHlpApi.lib", "Wininet.lib", "ws2_32.lib", "dsound.lib");
                conf.If(Optimization.Release).LibraryFiles.Add("xapobase.lib");
                conf.If(Optimization.Release).LibraryFiles.Add("nvcore.lib", "nvimage.lib", "nvmath.lib", libNvttName);
                conf.If(Optimization.Debug).LibraryFiles.Add("KinectGesture_" + vsVersion + "_" + kinectGestureArch + "d.lib");
                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("libclient.lib", "libsupp.lib", "librpc.lib", "libp4api.lib", "libp4script.lib", "libp4script_c.lib", "libp4script_curl.lib", "libp4script_sqlite.lib");
                conf.If(Optimization.Release | Optimization.Retail).LibraryFiles.Add("KinectGesture_" + vsVersion + "_" + kinectGestureArch + "r.lib");
                conf.LibraryFiles.Add("Kinect10.lib");
                conf.If(Optimization.Release | Optimization.Retail).LibraryFiles.Add("Version.lib", "dxguid.lib", "xaudio2_8.lib", "d3d9.lib", "winmm.lib", "dinput8.lib", "XInput.lib", "winmm.lib", "d3d11.lib", "dxgi.lib", "IpHlpApi.lib", "Wininet.lib", "ws2_32.lib", "dsound.lib");
                conf.LibraryFiles.Add("mf.lib", "mfplat.lib", "mfreadwrite.lib", "mfuuid.lib", "shlwapi.lib", "wmcodecdspuuid.lib", "Bcrypt.lib", "Rpcrt4.lib");
                conf.AdditionalLinkerOptions.Add("/ignore:4204");
                if (target.IsPcStandalone() && target.Optimization == Optimization.Retail)
                {
                    conf.AdditionalLinkerOptions.Add("/FIXED:NO");
                }
                conf.LibraryFiles.Add("psapi.lib");

                if (target.DevEnv == DevEnv.vs2015 || target.DevEnv == DevEnv.vs2017)
                {
                    conf.If(Optimization.Release | Optimization.Debug).LibraryFiles.Add("legacy_stdio_definitions.lib");
                }

                if (target.Optimization == Optimization.Debug || target.Optimization == Optimization.Release)
                {
                    // Recommended linker options for Recode builds
                    conf.Options.Add(Options.Vc.Linker.Incremental.Enable);
                    conf.Options.Add(Options.Vc.Linker.CreateHotPatchableImage.ItaniumImage);
                    conf.Options.Add(Options.Vc.Linker.EnableCOMDATFolding.DoNotRemoveRedundantCOMDATs); //Needed to enable Incremental linking on Release for Recode
                    conf.Options.Add(Options.Vc.Linker.Reference.KeepUnreferencedData);
                }

                // UbiServices
                conf.LibraryFiles.Add("libcurl.lib", "openSSL.lib", "ubiservices.lib", "uszlib.lib", "nghttp2.lib", "crypt32.lib"); // crypt32.lib is not provided by Ubiservices but is needed to link against newer versions of OpenSSL

                string cudartDllName = target.DevEnv == DevEnv.vs2012 ? "cudart32_65.dll" :
                                       target.DevEnv == DevEnv.vs2015 ? "cudart" + plainArch + "_80.dll" :
                                       target.DevEnv == DevEnv.vs2017 ? "cudart" + plainArch + "_101.dll" :
                                                                        "cudart" + plainArch + "_50_35.dll";


                conf.AddPostBuildCopy(Path.Combine(ExternPath, @"NVIDIA GPU Computing Toolkit/" + cudartDllName));
                conf.EventPreBuild.Add(string.Format(@"IF EXIST $(TargetDir)\Kinect10.dll DEL $(TargetDir)\Kinect10.dll"));
                conf.AddPostBuildCopy(Path.Combine(ExternPath, @"KinectPC_Sdk\v1.8\lib\" + kinectArch + @"\Kinect10.dll"));

                var nvttFolder = target.DevEnv == DevEnv.vs2012 ? "Release2012" :
                             target.DevEnv == DevEnv.vs2015 ? "Release2015" :
                             target.DevEnv == DevEnv.vs2017 ? "Release2017" :
                                                              "Release2010";
                if (conf.Platform == Platform.win64)
                    nvttFolder = nvttFolder + @"\" + "x64";

                var nvttArch = target.DevEnv == DevEnv.vs2012 ? "32" :
                                 target.DevEnv == DevEnv.vs2015 ? plainArch :
                                 target.DevEnv == DevEnv.vs2017 ? plainArch :
                                                                  "32";

                var nvttSuffix = target.DevEnv == DevEnv.vs2012 ? "_vs12" :
                                 target.DevEnv == DevEnv.vs2015 ? "_vs15" :
                                 target.DevEnv == DevEnv.vs2017 ? "_vs17" :
                                                                  "";

                var nvtDllName = nvttFolder + @"\" + "nvtt" + nvttArch + nvttSuffix + ".dll";

                conf.AddPostBuildCopy(Path.Combine(ExternPath, @"NVIDIA Texture Tools 2\lib", nvtDllName));

                if (target.IsPcStandalone())
                {
                    conf.AddPostBuildCopy(ResolveString(DeploymentFilesPath + "pc", conf));
                }
                else
                {
                    conf.AddPostBuildCopy(ResolveString(DeploymentFilesPath + "win32", conf));
                }
                conf.AddPostBuildCopy(Path.Combine(BranchRoot, "tools/extern/AudioEncode/AdpcmEncode.exe"));
               

                if (target.IsPcStandalone())
                {
                    conf.AddPostBuildCopy(Path.Combine(BranchRoot, "extern/UplaySDK/lib/uplay_r1_loader.dll"));
                    conf.AddPostBuildCopy(Path.Combine(BranchRoot, "extern/SteamSDK/redistributable_bin/steam_api.dll"));
                    conf.IncludePaths.Add(ExternPath + "UplaySDK/include");
                    conf.IncludePaths.Add(ExternPath + "SteamSDK/public");
                    conf.LibraryFiles.Add(ExternPath + "UplaySDK/lib/" + "uplay_r1_loader.lib");
                    conf.LibraryFiles.Add(ExternPath + "SteamSDK/redistributable_bin/" + "steam_api.lib");

                }
            }
            else if (conf.Platform == Platform.orbis)
            {
                conf.LibraryPaths.Add(  ExternPath + "EDGE/edge_1_2_0/lib/Orbis/VS" + target.DevEnv.GetDevEnvString(),
                                        ExternPath + "KinectGesture/Lib",
                                        ExternPath + "UbiServices/custom/lib/SdkClient/ps4_" + target.DevEnv.GetDevEnvString() + "/" + target.Optimization);

                conf.LibraryFiles.Add(
                    "SceJson2_stub_weak",
                    "SceSigninDialog_stub_weak",
                    "SceGameLiveStreaming_stub_weak",
                    "SceRandom_stub_weak",
                    "SceWebBrowserDialog_stub_weak",
                    "ScePlayGo_stub_weak",
                    "SceSaveDataDialog_stub_weak",
                    "SceSaveData_stub_weak",
                    "SceDepth_stub_03_weak",
                    "SceNpAuth_stub_weak",
                    "SceNpManager_stub_weak",
                    "SceAppContent_stub_weak",
                    "SceMove_stub_weak",
                    "SceSystemService_stub_weak",
                    "SceCommonDialog_stub_weak",
                    "ScePosix_stub_weak",
                    "SceMsgDialog_stub_weak",
                    "SceImeDialog_stub_weak",
                    "SceFios2_stub_weak",
                    "SceAudioOut_stub_weak",
                    "SceNgs2_stub_weak",
                    "ScePad_stub_weak",
                    "SceAudioIn_stub_weak",
                    "SceNet_stub_weak",
                    "SceNetCtl_stub_weak",
                    "SceGpuAddress",
                    "SceGnmDriver_stub_weak",
                    "SceShaderBinary",
                    "SceVideoOut_stub_weak",
                    "SceUlt_stub_weak",
                    "SceCes",
                    "SceHttp_stub_weak",
                    "SceSsl_stub_weak",
                    "SceNpCommon_stub_weak",
                    "SceRtc_stub_weak",
                    "SceUserService_stub_weak",
                    "SceCamera_stub_weak",
                    "SceSysmodule_stub_weak",
                    "SceNpMatching2_stub_weak",
                    "SceNpUtility_stub_weak",
                    "SceNpScore_stub_weak",
                    "SceNpTrophy_stub_weak",
                    "SceNpTus_stub_weak",
                    "SceNpWebApi_stub_weak",
                    "SceNpCommerce_stub_weak",
                    "SceInvitationDialog_stub_weak",
                    "SceNpProfileDialog_stub_weak",
                    "SceNpToolkit2_stub_weak",
                    "SceErrorDialog_stub_weak",
                    "SceScreenShot_stub_weak",
                    "SceVideoRecording_stub_weak",
                    "SceSecure",
                    ExternPath + "SK_iisu/PS4/Lib/libHumanTracking_stub_weak.a",
                    "SceSpeechRecognition");

                conf.If(Optimization.Debug).LibraryFiles.Add(
                    "SceGnm_debug",
                    "SceGnmx_debug",
                    "edgeanim_orbis_d",
                    "KinectGesture_" + vsVersion + "_ORBISd.a");

                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("SceDbg_stub_weak", 10);
                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("SceDbgException_stub_weak", 10);
                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("SceRazorCpu_stub_weak", 10);
                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("SceMat_stub_weak", 10);
                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add(ExternPath + "SK_iisu/Ps4/lib/libskv.a", 10);

                conf.If(Optimization.Release | Optimization.Retail).LibraryFiles.Add(
                    "SceGnm",
                    "SceGnmx",
                    "edgeanim_orbis_r",
                    "KinectGesture_" + vsVersion + "_ORBISr.a");

                //UbiServices
                conf.LibraryFiles.Add(
                    "ubiservices",
                    "openSSL",
                    "uszlib");
                
                conf.AddPostBuildCopy(new XCopyCommand(ResolveString(DeploymentFilesPath + "orbis", conf)));

            }
            else if (conf.Platform == Platform.durango)
            {
                conf.LibraryPaths.Add(  ExternPath + "EDGE/edge_1_2_0/lib/Durango/VS" + target.DevEnv.GetDevEnvString(),
                                        ExternPath + "UbiServices/custom/lib/SdkClient/xone_" + target.DevEnv.GetDevEnvString()  + "/" + target.Optimization,
                                        ExternPath + "KinectGesture/Lib",
                                        ExternPath + "openssl_x1/custom/libs");

                conf.If(Optimization.Debug).LibraryFiles.Add("d3dcompiler.lib", "d3d11_x.lib", "d3d12_x.lib", "combase.lib", "kernelx.lib", "dxguid.lib", "uuid.lib", "xaudio2.lib", "ws2_32.lib", "edgeanim_durango_d.lib", "KinectGesture_" + vsVersion + "_Durangod.lib", "acphal.lib", "xg_x.lib", "pixevt.lib", "Mmdevapi.lib", "EtwPlus.lib");
                conf.If(Optimization.Release).LibraryFiles.Add("d3dcompiler.lib", "d3d11_x.lib", "d3d12_x.lib", "combase.lib", "kernelx.lib", "dxguid.lib", "uuid.lib", "xaudio2.lib", "ws2_32.lib", "edgeanim_durango_r.lib", "KinectGesture_" + vsVersion + "_Durangor.lib", "acphal.lib", "xg_x.lib", "pixevt.lib", "Mmdevapi.lib", "EtwPlus.lib");
                conf.If(Optimization.Retail).LibraryFiles.Add("d3d11_x.lib", "d3d12_x.lib", "combase.lib", "kernelx.lib", "dxguid.lib", "uuid.lib", "xaudio2.lib", "ws2_32.lib", "edgeanim_durango_r.lib", "KinectGesture_" + vsVersion + "_Durangor.lib", "acphal.lib", "xg_x.lib", "Mmdevapi.lib", "EtwPlus.lib");
                conf.LibraryFiles.Add("consoleid.lib", "bcrypt.lib", "libcrypto.lib", "libssl.lib"); // libcrypto.lib and libssl.lib are from extern/openssl_x1/custom


                // UbiServices
                conf.LibraryFiles.Add("ubiservices.lib", "uszlib.lib");
                
                //Add winm search directory
                conf.AdditionalCompilerOptions.Add("/AI\"$(Console_SdkWindowsMetadataPath)\" /AI\"$(VCInstallDir)vcpackages\"");
                //Setup subsystem so we could use recommended from microsoft main signature
                conf.Options.Add(Options.Vc.Linker.SubSystem.Console);

                //Hack: clear AppxManifest.xml explicitly cause with our configs visual studio does not do it even when changing configurations
                conf.EventPreBuild.Add("del \"$(FinalAppxManifestName)\"");

                conf.Options.Add(Options.Vc.Compiler.CompileAsWinRT.Enable);
                conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);

                //Package_durango.appxmanifest
                conf.NeedsAppxManifestFile = true;

                List<string> files = Util.DirectoryGetFiles(ResolveString(SourcePath + "/appFramework"), "*.appxManifest", SearchOption.AllDirectories).ToList();
                if (files.Count > 0)
                {
                    conf.AppxManifestFilePath = files.First();
                }
                conf.ConsumeWinRTExtensions.Add("Live");

                conf.AddPostBuildCopy(new XCopyCommand(ResolveString(DeploymentFilesPath + "durango", conf)));
            }
            else if (conf.Platform == Platform.nx)
            {
                // forced to do this way, otherwise the $(NINTENDO_SDK_ROOT)\..\ path would remove the while $(NINTENDO_SDK_ROOT) path...
                string sdkRoot = Environment.GetEnvironmentVariable("NINTENDO_SDK_ROOT");
                conf.LibraryPaths.Add(ExternPath + "EDGE/edge_1_2_0/lib/NX64/VS" + target.DevEnv.GetDevEnvString(),
                                      ExternPath + "UbiServices/custom/lib/SdkClient/switch_" + target.DevEnv.GetDevEnvString() + "/" + target.Optimization,
                                      sdkRoot + @"\..\NvnGraphicsDebugger\target\nx-nvn-a64");

                conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("libnn_profiler.a");

                // Edge
                conf.If(Optimization.Debug).LibraryFiles.Add("edgeanim_nx_d");
                conf.If(Optimization.Release | Optimization.Retail).LibraryFiles.Add("edgeanim_nx_r");
                // UbiServices
                conf.LibraryFiles.Add("ubiservices", "uszlib");

                conf.AddPostBuildCopy(new XCopyCommand(ResolveString(DeploymentFilesPath + "nx", conf)));
                
                conf.LibraryFiles.Add("libopenssl.a");  // in NX SDK, not Ubiservices
                conf.LibraryFiles.Add("libcurl.a");     // in NX SDK, not Ubiservices
                conf.If(Optimization.Debug | Optimization.Release).AdditionalNSOFiles.Add("Nvidia_gfx_debugger.nso");
                conf.AdditionalNSOFiles.Add("multimedia.nso"); // to use hardware video decoding chipset
                // conf.MetadataSource = @"$(ProjectDir)..\..\..\gameroot\nx\JD.aarch64.lp64.meta";
            }
            /*
            else if (conf.Platform == Ggp.SharpmakePlatform) 
            {
...
            }
            */
        }

        protected override void ConfigureLinkerOptions(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureLinkerOptions(conf, target);
            // conf.If(Optimization.Debug | Optimization.Release, Platform.orbis).Options.Add(Orbis.Options.Linker.Addressing.NonASLR);
        }
    }

    #endregion

    #region CSharpGenerator

    [Generate]
    internal class UAF_CSharpGenerator : EngineProject
    {
        public UAF_CSharpGenerator()
        {
            OutputType = Configuration.OutputType.Exe;
            RootPath = SourcePath + "csharpGenerator";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "UAF";
            conf.TargetFileName = "CSharpGenerator";

            conf.AddPublicDependency<UAF_Core>(target);
            conf.AddPublicDependency<UAF_EngineWrapper>(target);
            conf.TargetPath = Path.Combine(conf.TargetPath, "Tools", conf.TargetFileName);
            var lockedEngineWrapperDllPath = UAF_EngineWrapper.DllPath + ".locked";

            var plainArch = conf.Platform == Platform.win64 ? "64" : "32";
            var kinectArch = conf.Platform == Platform.win64 ? "amd64" : "x86";

            var engineWrapperDllName = @"""EngineWrapper" + (conf.Platform == Platform.win32 ? "32" : "") + @".dll""";

            conf.EventPreBuild.Add(string.Format(@"IF EXIST {0} RENAME {0} {1}", lockedEngineWrapperDllPath, engineWrapperDllName));
            conf.EventPreBuild.Add(string.Format(@"IF EXIST $(TargetDir)\Kinect10.dll DEL $(TargetDir)\Kinect10.dll"));
            

            var nvttFolder = target.DevEnv == DevEnv.vs2012 ? "Release2012" :
                             target.DevEnv == DevEnv.vs2015 ? "Release2015" :
                             target.DevEnv == DevEnv.vs2017 ? "Release2017" :
                                                              "Release2010";
            if (conf.Platform == Platform.win64)
                nvttFolder = nvttFolder + @"\" + "x64";

            var nvttArch =   target.DevEnv == DevEnv.vs2012 ? "32" :
                             target.DevEnv == DevEnv.vs2015 ? plainArch :
                             target.DevEnv == DevEnv.vs2017 ? plainArch :
                                                              "32";

            var nvttSuffix = target.DevEnv == DevEnv.vs2012 ? "_vs12" :
                             target.DevEnv == DevEnv.vs2015 ? "_vs15" :
                             target.DevEnv == DevEnv.vs2017 ? "_vs17" :
                                                              "";

            var nvtDllName = nvttFolder + @"\" + "nvtt" + nvttArch + nvttSuffix + ".dll";

            var cudartDllName = target.DevEnv == DevEnv.vs2012 ? "cudart32_65.dll" :
                                target.DevEnv == DevEnv.vs2015 ? "cudart" + plainArch + "_80.dll" :
                                target.DevEnv == DevEnv.vs2017 ? "cudart" + plainArch + "_101.dll" :
                                                                 "cudart" + plainArch + "_50_35.dll";


            conf.TargetCopyFiles.Add(Path.Combine(ExternPath, @"NVIDIA GPU Computing Toolkit/" + cudartDllName));
            conf.TargetCopyFiles.Add(Path.Combine(ExternPath, @"NVIDIA Texture Tools 2\lib", nvtDllName));
            conf.TargetCopyFiles.Add(Path.Combine(ExternPath, @"KinectPC_Sdk\v1.8\lib\" + kinectArch + @"\Kinect10.dll"));
            conf.EventPostBuild.Add(string.Format(@"$(OutputFile) {0}", Path.Combine(BranchRoot, "tools", @"framework\JD.Serialization\uaf\")));
        }

        protected override void ConfigureCompilerOptions(Project.Configuration conf, BaseCppTarget target)
        {
            conf.Options.Add(Options.Vc.General.CommonLanguageRuntimeSupport.ClrSupport);
            conf.Options.Add(Options.Vc.General.CharacterSet.Unicode);
            conf.Options.Add(Options.Vc.Compiler.Exceptions.EnableWithSEH);
            conf.Options.Add(Options.Vc.Compiler.RuntimeChecks.Default);
            conf.Options.Add(Options.Vc.Compiler.FloatingPointModel.Precise);
            conf.Options.Add(Options.Vc.Compiler.MinimalRebuild.Disable);
            conf.Options.Add(Options.Vc.General.WarningLevel.Level3);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
            conf.Options.Add(Options.Vc.General.WholeProgramOptimization.Disable);

            if (target.Optimization == Optimization.Debug)
                conf.Options.Add(Options.Vc.Compiler.Optimization.Disable);
            else if (target.Optimization == Optimization.Release)
                conf.Options.Add(Options.Vc.Compiler.Optimization.MaximizeSpeed);
            conf.Options.Add(Options.Vc.Compiler.Inline.Default);
            conf.Options.Add(Options.Vc.Compiler.Intrinsic.Disable);
            conf.Options.Add(Options.Vc.Compiler.FavorSizeOrSpeed.Neither);
            conf.Options.Add(Options.Vc.Compiler.OmitFramePointers.Disable);
            conf.Options.Add(Options.Vc.Compiler.FiberSafe.Disable);

            conf.If(Optimization.Debug).Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDebugDLL);
            conf.IfNot(Optimization.Debug).Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDLL);

            conf.Options.Add(Options.Vc.Compiler.RTTI.Enable);
            conf.Options.Add(Options.Vc.Compiler.FloatingPointExceptions.Disable);
        }

        protected override void ConfigureDefines(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add(")WRAPPER_C");
            conf.If(Optimization.Debug).Defines.Add("_DEBUG");
            conf.IfNot(Optimization.Debug).Defines.Add("NDEBUG", "_SECURE_SCL=0");
        }
    }

    #endregion
}