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

namespace JustDance.Engine
{
    #region UnitTests project base class

    internal abstract class UnitTests_Project : EngineProject
    {
        protected UnitTests_Project()
        {
            Name = GetType().Name.Replace("_", ".");

        }

        public override void ConfigureAll(Project.Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);

            // UnitTests projects use gmock
            conf.IncludePaths.Add(ExternPath + @"gmock\googlemock\include");
            conf.IncludePaths.Add(ExternPath + @"gmock\googletest\include");
            conf.IncludePaths.Add(ExternPath + "rapidjson/include");

            if (conf.Platform == Platform.nx || conf.Platform == Platform.orbis)
            {
                // Suppress warning "binding dereferenced null pointer to reference has undefined behavior"
                // Due to function template <typename T> inline T Invalid();
                // in extern\gmock\include\gmock\internal\gmock-internal-utils.h
                conf.AdditionalCompilerOptions.Add("-Wno-null-dereference");
            }
			
			// 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);
                }
            }

            if (conf.Platform == Platform.orbis)
            {
                conf.AdditionalCompilerOptions.Add("-std=c++14");
            }
        }
    }

    #endregion

    #region UAF

    #region UAF Adapters Test

    [Generate]
    internal class UAF_Adapters_Test : UnitTests_Project
    {
        public UAF_Adapters_Test()
        {
            RootPath = UnitTestsPath + "adapters";
            PrecompileHeader = "precompiled_unittests_adapters";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);

            conf.SolutionFolder = "/UAF";

            conf.IncludePaths.Add(ExternPath + @"GLEW");
            conf.IncludePaths.Add(ExternPath + @"Raki/Source");
            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.IncludePaths.Add(ExternPath + @"UbiServices/custom/client-sdk/public",
                                  ExternPath + @"UbiServices/custom/external/harbourcommon/libraries/harboureal/api/sources");

            //Misc
            conf.If(Platform.orbis).IncludePaths.Add("$(IISU_SDK_DIR)/include/iisu");
        }
    }

    #endregion

    #region UAF Core Test

    [Generate]
    internal class UAF_Core_Test : UnitTests_Project
    {
        public UAF_Core_Test()
        {
            RootPath = UnitTestsPath + "core";
            PrecompileHeader = "precompiled_unittests_core";
        }

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

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);
        }
    }

    #endregion

    #region UAF Editor Test

    [Generate]
    internal class UAF_Editor_Test : UnitTests_Project
    {
        public UAF_Editor_Test()
        {
            RootPath = UnitTestsPath + "editor";
            PrecompileHeader = "precompiled_unittests_editor";
        }

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

    #endregion

    #region UAF Engine Test

    [Generate]
    internal class UAF_Engine_Test : UnitTests_Project
    {
        public UAF_Engine_Test()
        {
            RootPath = UnitTestsPath + "engine";
            PrecompileHeader = "precompiled_unittests_engine";
        }

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

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);

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

    #endregion

    #region UAF EngineWrapper Test

    [Generate]
    internal class UAF_EngineWrapper_Test : UnitTests_Project
    {
        public UAF_EngineWrapper_Test()
        {
            RootPath = UnitTestsPath + "engineWrapper";
            PrecompileHeader = "precompiled_unittests_engineWrapper";
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "/UAF";
            conf.IfNot(Platform.win32 | Platform.win64).SourceFilesBuildExcludeRegex.Add(".cpp");

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);
        }
    }

    #endregion

    #region UAF Gameplay Test

    [Generate]
    internal class UAF_Gameplay_Test : UnitTests_Project
    {
        public UAF_Gameplay_Test()
        {
            RootPath = UnitTestsPath + "gameplay";
            PrecompileHeader = "precompiled_unittests_gameplay";
        }

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

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);
        }
    }

    #endregion

    #region UAF InitFactory Test

    [Generate]
    internal class UAF_InitFactory_Test : UnitTests_Project
    {
        public UAF_InitFactory_Test()
        {
            RootPath = UnitTestsPath + "initFactory";
            PrecompileHeader = "precompiled_unittests_initFactory";
        }

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

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);
        }
    }

    #endregion

    #endregion

    #region JD

    #region JD Editor Test

    [Generate]
    internal class JD_Editor_Test : UnitTests_Project
    {
        public JD_Editor_Test()
        {
            RootPath = UnitTestsPath + "JD/editor";
            PrecompileHeader = "JD_precompiled_unittests_editor";
        }

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

    #endregion

    #region JD Gameplay Test

    [Generate]
    internal class JD_Gameplay_Test : UnitTests_Project
    {
        public JD_Gameplay_Test()
        {
            RootPath = UnitTestsPath + "JD/gameplay";
            PrecompileHeader = "JD_precompiled_unittests_gameplay";
        }

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

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

            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);
        }
    }

    #endregion

    #endregion

    #region UA_unittests

    [Generate]
    internal class UA_Unittests : UnitTests_Project
    {
        public UA_Unittests()
        {
            RootPath = UnitTestsPath + "ua_unittests";
            OutputType = Configuration.OutputType.Exe;
            Name = "ua_unittests";
            DeployProject = true;
            
        }

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

            conf.Options.Add(Options.Vc.Linker.SubSystem.Console);
            conf.Options.Add(Options.Vc.Linker.UseLibraryDependencyInputs.Enable);
            conf.Options.Add(Options.Vc.Linker.LinkLibraryDependencies.Enable);

            conf.AddPublicDependency<UAF_Adapters_Test>(target);
            conf.AddPublicDependency<UAF_Core_Test>(target);
            conf.AddPublicDependency<UAF_Engine_Test>(target);
            conf.If(Platform.win32 | Platform.win64).AddPublicDependency<UAF_EngineWrapper_Test>(target);
            conf.IfNot(Platform.win32 | Platform.win64).AddPublicDependency<UAF_EngineWrapper_Test>(target, DependencySetting.DefaultWithoutLinking);
            conf.AddPublicDependency<UAF_Gameplay_Test>(target);
            conf.AddPublicDependency<UAF_InitFactory_Test>(target);
            conf.AddPublicDependency<JD_Gameplay_Test>(target);
            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.AddExternDependency<LuaLib>(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<GoTop>(target, DependencySetting.DefaultWithoutLinking);
            
            conf.IfNot(Optimization.Retail).AddPublicDependency<Plugins>(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);

            ConfigureGmock(conf, target);

            switch (conf.Platform)
            {
                case Platform.win32:
                case Platform.win64: ConfigurePC(conf, target);
                    break;
                case Platform.orbis: ConfigureOrbis(conf, target);
                    break;
                case Platform.durango: ConfigureDurango(conf, target);
                    break;
                case Platform.nx: ConfigureNX(conf, target);
                    break;
                // case Ggp.SharpmakePlatform: ConfigureGGP(conf, target);
                //     break;
                // case Prospero.SharpmakePlatform: ConfigureProspero(conf, target);
                //     break;
            }
        }

        private static void ConfigureGmock(Configuration conf, BaseCppTarget target)
        {
            conf.If(Platform.win32 | Platform.win64 | Platform.orbis | Platform.nx).AddExternDependency<gmock>(target);
        }

        private void ConfigurePC(Configuration conf, BaseCppTarget target)
        {
            Debug.Assert(conf.Platform == Platform.win32 || conf.Platform == Platform.win64);

            conf.Defines.Add("_CONSOLE"); 
            conf.IgnoreLibrary("LIBCMT.lib", "LIBCMTd.lib");
            conf.If(Optimization.Debug).IgnoreLibrary("msvcrt.lib");

            if (target.ApplicationType == ApplicationType.Editor)
            {
                conf.AddPrivateDependency<UAF_Editor_Test>(target);
                conf.AddPrivateDependency<JD_Editor_Test>(target);

                conf.AddPublicDependency<UAF_Editor>(target);
                conf.AddPublicDependency<JD_Editor>(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 + "UbiServices/custom/external/dependencies/uplaypc/lib/",
                                    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";

            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.LibraryFiles.Add("mf.lib", "mfplat.lib", "mfreadwrite.lib", "mfuuid.lib", "shlwapi.lib", "wmcodecdspuuid.lib");

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

            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");

            // UbiServices
            conf.LibraryFiles.Add("libcurl.lib", "openSSL.lib", "ubiservices.lib", "uszlib.lib", "uplay_r2_loader64.lib", "nghttp2.lib", "crypt32.lib");
            conf.AddPostBuildCopy(Path.Combine(ExternPath + "UbiServices/custom/lib/SdkClient/" + ubiservicesArch + "_" + target.DevEnv.GetDevEnvString() + "/" + target.Optimization + "/" + "uplay_r2_loader64.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.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"));
            if (conf.Platform.IsWindows())
            {
                if (target.ApplicationType == ApplicationType.Editor)
                {
                    conf.AddPostBuildCopy(ResolveString(DeploymentFilesPath + "win32", conf));
                }
                if (target.ApplicationType == ApplicationType.Standalone)
                {
                    conf.AddPostBuildCopy(ResolveString(DeploymentFilesPath + "pc", conf));
                    conf.LibraryFiles.Add(ExternPath + "UplaySDK/lib/" + "uplay_r1_loader.lib");
                    conf.LibraryFiles.Add(ExternPath + "SteamSDK/redistributable_bin/" + "steam_api.lib");
                }
            }
            
            conf.AddPostBuildCopy(Path.Combine(BranchRoot, "tools/extern/AudioEncode/AdpcmEncode.exe"));

            // execute ua_unittests.exe in the post-build : each time the project is compiled, it executes unit tests
            if (!target.IsPcStandalone())
            {
                conf.If(Optimization.Debug | Optimization.Release).EventPostBuild.Add(@"$(OutputFile)");
                conf.If(Optimization.Debug | Optimization.Release).EventPostBuild.Add(@"IF %ERRORLEVEL% NEQ 0 ECHO Unit Tests didn't finish successfully && EXIT 1");
            }
        }

        private void ConfigureOrbis(Configuration conf, BaseCppTarget target)
        {
            string vsVersion = (target.DevEnv == DevEnv.vs2012 ? "vs11" : (target.DevEnv == DevEnv.vs2015 ? "vs14" : "vs15"));

            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(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(ResolveString(DeploymentFilesPath + "orbis", conf));
        }

        private void ConfigureDurango(Configuration conf, BaseCppTarget target)
        {
            string vsVersion = (target.DevEnv == DevEnv.vs2012 ? "vs11" : (target.DevEnv == DevEnv.vs2015 ? "vs14" : "vs15"));

            conf.IgnoreLibrary("winmm.lib", "%(IgnoreSpecificDefaultLibraries)");
            conf.If(Optimization.Debug).IgnoreLibrary("libcmtd.lib");
            conf.If(Optimization.Release | Optimization.Retail).IgnoreLibrary("libcmt.lib");

            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");

            conf.If(Optimization.Debug).LibraryFiles.Add("d3dcompiler.lib", "d3d11_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", "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", "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");

            // UbiServices
            conf.LibraryFiles.Add("ubiservices.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
            List<string> files = Directory.GetFiles(ResolveString(SourcePath + "/appFramework"), "*.appxManifest", SearchOption.AllDirectories).ToList();
            if (files.Count > 0)
            {
                conf.AppxManifestFilePath = files.First();
            }

            conf.ConsumeWinRTExtensions.Add("Live");

            conf.AddPostBuildCopy(ResolveString(DeploymentFilesPath + "durango", conf));            
        }

        private void ConfigureNX(Configuration conf, BaseCppTarget target)
        {
            conf.If(Optimization.Debug | Optimization.Release).LibraryFiles.Add("libnn_profiler.a");

            // 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");

            // 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.LibraryFiles.Add("openSSL"); // in NX SDK, not Ubiservices
            conf.LibraryFiles.Add("curl");    // 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";
        }

        private void ConfigureGGP(Configuration conf, BaseCppTarget target)
        {
        }

        private void ConfigureProspero(Configuration conf, BaseCppTarget target)
        {
        }
    }

    #endregion
}