using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using JustDance.Engine;
using Sharpmake;
using Ubisoft;
using Optimization = JustDance.Engine.Optimization;

namespace JustDance.Tools
{

    [Fragment, Flags]
    public enum ScoringToolsPlatform
    {
        None = 1 << 0,
        PS4 = 1 << 1,
        XOne = 1 << 2,
        X360 = 1 << 3,
        NX = 1 << 4,
    }

    public class ScoringToolsTarget : BaseCppTarget
    {
        public ScoringToolsPlatform ConsolePlatform = ScoringToolsPlatform.None;

        public ScoringToolsTarget() { }

        public ScoringToolsTarget(Platform platform, DevEnv devEnv, Engine.Optimization optimization,
            OutputType outputType, ScoringToolsPlatform consolePlatform = ScoringToolsPlatform.None)
            : base(platform, devEnv, optimization, outputType)
        {
            ConsolePlatform = consolePlatform;
        }

        public override string Name
        {
            get
            {
                var name = Optimization.ToString();
                if (ConsolePlatform != ScoringToolsPlatform.None)
                {
                    name += "_" + ConsolePlatform;
                }
                return name;
            }
        }

        public override bool Equals(object obj)
        {
            var target = (ScoringToolsTarget)obj;
            return Name == target.Name &&
                   ConsolePlatform == target.ConsolePlatform &&
                   ApplicationType == target.ApplicationType &&
                   DevEnv == target.DevEnv &&
                   Optimization == target.Optimization &&
                   Platform == target.Platform;
        }

        public override int GetHashCode()
        {
            return this.Name.GetHashCode();
        }
    }

    [Generate]
    public class ScoringToolsNativeApplication : BaseCppProjectGeneric<ScoringToolsTarget>
    {
        public static readonly string ScoringUtilitiesOutput = ToolsPath + @"\extern\ScoringUtilities\";

        public readonly string ReleasePlatformOutput = ScoringUtilitiesOutput + @"\bin\Release\Tools\ScoringTools\[project.Name]\";

        public readonly string DebugPlatformOutput = ScoringUtilitiesOutput + @"\bin\Debug\Tools\ScoringTools\[project.Name]\";

        protected string PlatformArchitecture { get; private set; }
        protected string ZLib { get; private set; }
        protected string ExampleLib { get; private set; }
        protected string TimeLineCacheLib { get; private set; }
        protected string LibraryEndingName { get; private set; }

        public ScoringToolsNativeApplication()
        {
            RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src");
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64,
                DevEnv.vs2015 | DevEnv.vs2017,
                Engine.Optimization.Debug | Engine.Optimization.Release,
                Sharpmake.OutputType.Lib));
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.ProjectFileName = "[project.Name].[target.DevEnv]";
            conf.IncludePaths.Add(Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "include"));
            conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
            SetCommonLibrariesPath(target);

            if (target.Optimization.GetLibrarySuffix() == LibrarySuffix.d)
            {
                conf.Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDebugDLL);
                conf.Options.Add(Options.Vc.Linker.Incremental.Enable);
            }

            if (target.Optimization.GetLibrarySuffix() == LibrarySuffix.r)
            {
                conf.Options.Add(Options.Vc.Compiler.RuntimeLibrary.MultiThreadedDLL);
                conf.Options.Add(Options.Vc.Linker.Incremental.Disable);
            }

            conf.Options.Add(Options.Vc.Compiler.EnhancedInstructionSet.Disable);
            conf.ProjectPath = SourceRootPath;
        }

        private void SetCommonLibrariesPath(ScoringToolsTarget target)
        {
            PlatformArchitecture = GetPlatformArchitecture(target);

            LibraryEndingName = PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix() + ".lib";
            ZLib = Path.Combine(ExternPath, "KinectGesture", "Dependencies", "zlibstatic" + LibraryEndingName);
            ExampleLib = Path.Combine(ScoringUtilitiesOutput, "lib", "tools", "ExamplesLib" + LibraryEndingName);
            TimeLineCacheLib = Path.Combine(ScoringUtilitiesOutput, "lib", "tools", "TimelineCacheLib" + LibraryEndingName);
        }

        public void AddPlatformSpecificTargetPath(Configuration conf, Platform platform)
        {
            if (platform == Platform.win64)
            {
                conf.TargetPath = Path.Combine(ScoringUtilitiesOutput, "lib", "tools", "x64");
            }
            else if (platform == Platform.win32)        // TODO :  better to remove the win32 as all our tools are in x64. NOTE: make sure the sdk and other helper libs compile in x64
            {
                conf.TargetPath = Path.Combine(ScoringUtilitiesOutput, "lib" , "tools", "x86");
            }
        }

        protected void SetConfigurationTargetPath(Configuration conf, ScoringToolsTarget target)
        {
            var librarySuffix = target.Optimization.GetLibrarySuffix();
            switch (librarySuffix)
            {
                case LibrarySuffix.d:
                    conf.TargetPath = Path.Combine(DebugPlatformOutput, target.ConsolePlatform.ToString());
                    break;
                case LibrarySuffix.r:
                    conf.TargetPath = Path.Combine(ReleasePlatformOutput, target.ConsolePlatform.ToString());
                    break;
            }
        }

        protected static string GetPlatformArchitecture(ITarget target)
        {
            switch (target.GetPlatform())
            {
                case Platform.win32: return "_x86";
                case Platform.win64: return "_x64";
                default: return string.Empty;
            }
        }

        protected virtual void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
        {
        }
    }

    public class ScoringToolLibrary : ScoringToolsNativeApplication
    {
        public ScoringToolLibrary()
        {
            OutputType = Configuration.OutputType.Lib;
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetPath = Path.Combine(ScoringUtilitiesOutput, "lib", "tools");
        }
    }

    public class ScoringToolAplication : ScoringToolsNativeApplication
    {
        protected ScoringToolAplication()
        {
            OutputType = Configuration.OutputType.Exe;
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.Options.Add(Options.Vc.General.DebugInformation.ProgramDatabase);
            conf.Options.Add(Options.Vc.Compiler.FloatingPointExceptions.Disable);
            conf.Options.Add(Options.Vc.Linker.EnableCOMDATFolding.DoNotRemoveRedundantCOMDATs);
            conf.Options.Add(Options.Vc.Linker.Reference.KeepUnreferencedData);
            conf.TargetPath = ScoringUtilitiesOutput + @"bin\[conf.Name]\Tools\ScoringTools\[project.Name]\[conf.Platform]\";
        }

        public void AddAdditioalDefines(Configuration conf, ScoringToolsTarget target)
        {
            if (target.ConsolePlatform == ScoringToolsPlatform.PS4)
            {
                conf.Defines.Add("TARGET_ORBIS");
            }

            if (target.ConsolePlatform == ScoringToolsPlatform.XOne)
            {
                conf.Defines.Add("TARGET_DURANGO");
            }

            if (target.ConsolePlatform == ScoringToolsPlatform.X360)
            {
                conf.Defines.Add("TARGET_X360");
            }
        }

        protected virtual void AddConsoleSpecificDependencies(Configuration conf, ScoringToolsPlatform console)
        {
        }
    }

    public class ScoringToolDynamicLib : ScoringToolsNativeApplication
    {
        protected ScoringToolDynamicLib()
        {
            OutputType = Configuration.OutputType.Dll;
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.Options.Add(Options.Vc.General.CommonLanguageRuntimeSupport.ClrSupport);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
            conf.Options.Add(Options.Vc.Compiler.Optimization.MaximizeSpeed);
            conf.Options.Add(Options.Vc.Compiler.Exceptions.EnableWithSEH);
            conf.Options.Add(Options.Vc.Compiler.RuntimeChecks.Default);
            conf.Options.Add(Options.Vc.Compiler.FloatingPointExceptions.Disable);
            conf.Options.Add(Options.Vc.Compiler.RTTI.Enable);
            conf.Options.Add(Options.Vc.SourceFile.PrecompiledHeader.CreatePrecompiledHeader);
            conf.TargetPath = ScoringUtilitiesOutput + @"lib\tools\";
        }
    }

    public class CommonScoringToolApplication : ScoringToolAplication
    {
        public CommonScoringToolApplication()
        {
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015 | DevEnv.vs2017,
                Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib,
                ScoringToolsPlatform.XOne | ScoringToolsPlatform.PS4));
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            AddConsoleSpecificDependencies(conf, target.ConsolePlatform);

            conf.TargetFileName = conf.ProjectName + "_" + target.ConsolePlatform + PlatformArchitecture;
            conf.DependenciesIncludePaths.Add(ExternPath, ExternPath + @"KinectGesture/Inc");

            var kinectGestureLib = Path.Combine(ExternPath, "KinectGesture", "Lib", "KinectGestureTrainer_" + target.ConsolePlatform + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix() + ".vs2017.lib");
            
            conf.AdditionalLinkerOptions.Add( ZLib, kinectGestureLib, ExampleLib);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
            SetConfigurationTargetPath(conf, target);
        }

        protected override void AddConsoleSpecificDependencies(Configuration conf, ScoringToolsPlatform console)
        {
            switch (console)
            {
                case ScoringToolsPlatform.PS4:
                    conf.DependenciesIncludePaths.Add("$(SCE_ORBIS_SDK_DIR)/target/include_common");
                    break;
                case ScoringToolsPlatform.XOne:
                    conf.DependenciesIncludePaths.Add("$(XboxOneXDKLatest)xdk/include/um", "$(XboxOneXDKLatest)xdk/include/shared");
                    break;
                case ScoringToolsPlatform.X360:
                    conf.DependenciesIncludePaths.Add("$(XEDK)/include/win32");
                    break;
            }
        }

        protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("GESTURE_TRAINER", "WIN64", "NDEBUG", "_CONSOLE");
            AddAdditioalDefines(conf, target);
        }
    }

    [Generate]
    public class ExamplesLib : ScoringToolLibrary
    {
        public ExamplesLib()
        {
            SourceRootPath = Path.Combine(RootPath, "ExamplesLib");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.ExportAdditionalLibrariesEvenForStaticLib = true;

            conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();

            conf.IncludePaths.Clear();
            conf.IncludePaths.Add(ToolsPath + "apps/ScoringTools/PostRecordingPipelineTools/include");
            conf.IncludePaths.Add(BranchRoot + "tools/legacy/ParseExampleTool/ParseExample");

            conf.DependenciesIncludePaths.Add(ExternPath + "SK_iisu",
                ExternPath + "ZLib",
                ExternPath + "KinectGesture/Inc",
                "$(windowssdk_includepath)",
                "$(XboxOneXDKLatest)xdk/Include/um",
                "$(XboxOneXDKLatest)xdk/Include/shared",
                @"$(DXSDK_DIR)\include",
                "$(DXSDK_DIR)/extras/directshow/include",
                "$(XEDK)/include/win32",
                "$(windowssdkdir)/common/include");
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
        }

        protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("EXAMPLES_LIB", "WIN32", "NDEBUG", "_LIB", "EXAMPLELIB_PC", "_UNICODE");
        }
    }

    [Generate]
    class ExamplesWrapper : ScoringToolDynamicLib
    {
        public ExamplesWrapper()
        {
            SourceRootPath = Path.Combine(RootPath, "Examples.Wrapper");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.ProjectName = "Examples.Wrapper";
            conf.TargetFileName = conf.ProjectName;

            PerformPlatformSpecificActions(conf, target);
            conf.AddPublicDependency<ExamplesLib>(target);
            conf.DependenciesIncludePaths.Add(@"$(DXSDK_DIR)\Include");
        }

        protected override void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
        {
            base.PerformPlatformSpecificActions(conf, target);
            if (conf.Platform == Platform.win32)
            {
                conf.AdditionalLinkerOptions.Clear();
            }
            else if (conf.Platform == Platform.win64)
            {
                conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
                conf.Options.Add(Options.Vc.General.CommonLanguageRuntimeSupport.ClrSupport);
                conf.Options.Add(Options.Vc.General.WholeProgramOptimization.LinkTime);
                conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
                conf.Options.Add(Options.Vc.Compiler.Optimization.Disable);
                conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
                conf.Defines.Add("EXAMPLESLIB_MANAGED", "EXAMPLELIB_PC", "NDEBUG");
                conf.AdditionalLinkerOptions.Add(ZLib);
            }
        }

        protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("EXAMPLELIB_ORBIS", "EXAMPLELIB_PC");
        }
    }

    [Generate]
    class ExampleTransformer : ScoringToolAplication
    {
        public ExampleTransformer()
        {
            SourceRootPath = Path.Combine(RootPath, "ExampleTransformer");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            PerformPlatformSpecificActions(conf, target);
            conf.AddPublicDependency<ExamplesLib>(target);
        }

        protected override void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
        {
            if (conf.Platform == Platform.win32)
            {
                conf.TargetFileName = conf.ProjectName + PlatformArchitecture;
            }
            else if (conf.Platform == Platform.win64)
            {
                conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
                conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
                conf.AdditionalLinkerOptions.Add(ZLib);
            }
        }
    }

    [Generate]
    class ExamplesFileViewer : ScoringToolAplication
    {
        public ExamplesFileViewer()
        {
            SourceRootPath = Path.Combine(RootPath, "ExamplesLibUnitTest");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = conf.ProjectName;
            conf.DependenciesOtherLibraryFiles.Add("dxerr.lib",
                "d2d1.lib",
                "dwrite.lib",
                "windowscodecs.lib",
                "dxgi.lib",
                "d3d10_1.lib");
            conf.Options.Add(Options.Vc.Linker.SubSystem.Application);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
            PerformPlatformSpecificActions(conf, target);
            conf.AddPublicDependency<ExamplesLib>(target);
            conf.IncludePaths.Clear();
            conf.IncludePaths.Add(Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "include"));
        }

        protected override void PerformPlatformSpecificActions(Configuration conf, ScoringToolsTarget target)
        {
            conf.TargetFileName = conf.ProjectName + PlatformArchitecture;

            if (conf.Platform == Platform.win64)
            {
                conf.AdditionalLinkerOptions.Add(ZLib);
                conf.LibraryPaths.Clear();
                conf.LibraryPaths.Add("$(DXSDK_DIR)/lib/x64");
                conf.Options.Add(Options.Vc.Linker.GenerateDebugInformation.Disable);
            }
        }
    }

    [Generate]
    class GenerateExamples : ScoringToolAplication
    {
        public GenerateExamples()
        {
            SourceRootPath = Path.Combine(RootPath, "GenerateExamples");
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015 | DevEnv.vs2017,
                Engine.Optimization.Debug | Engine.Optimization.Release,
                Sharpmake.OutputType.Lib, ScoringToolsPlatform.XOne | ScoringToolsPlatform.PS4));
        }

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

            AddConsoleSpecificDependencies(conf, target.ConsolePlatform);

            conf.TargetFileName = conf.ProjectName + "_" + target.ConsolePlatform + PlatformArchitecture;
            conf.DependenciesIncludePaths.Add(ExternPath, ExternPath + @"KinectGesture/Inc");

            conf.AddPublicDependency<ExamplesLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
            conf.AddPublicDependency<TimelineCacheLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));

            AddAditionalLinkerLibraries(conf);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
            SetConfigurationTargetPath(conf, target);
        }

        private void AddAditionalLinkerLibraries(Configuration conf)
        {
            conf.AdditionalLinkerOptions.Clear();
            conf.AdditionalLinkerOptions.Add( ZLib, ExampleLib, TimeLineCacheLib);
        }

        protected override void AddConsoleSpecificDependencies(Configuration conf, ScoringToolsPlatform console)
        {
            if (console == ScoringToolsPlatform.XOne)
            {
                conf.LibraryPaths.Add("$(DurangoXDK)PC/lib/amd64");
                conf.IncludePaths.Add("$(DurangoXDK)PC/include");
                conf.IncludePaths.Add("$(XboxOneXDKLatest)xdk/include/um");
                conf.IncludePaths.Add("$(XboxOneXDKLatest)PC/include");
                conf.LibraryPaths.Add("$(XboxOneXDKLatest)PC/lib/amd64");
                conf.LibraryPaths.Add("$(XboxOneXDKLatest)xdk/lib/amd64");
                conf.LibraryFiles.Add("xstudioservice.lib");
                var delayLoadDlLs = new Options.Vc.Linker.DelayLoadDLLs("xstudioservice.dll");
                conf.Options.Add(delayLoadDlLs);
            }
            else if (console == ScoringToolsPlatform.PS4)
            {
                conf.IncludePaths.Add(Path.Combine(ExternPath, @"SK_iisu\include"));
                var skLibsPath = Path.Combine(ExternPath, @"SK_iisu\Win64");
                conf.LibraryPaths.Add(skLibsPath);
                conf.LibraryFiles.Add("skv.lib");
                conf.EventPreBuild.Add(string.Format(@"IF NOT EXIST ""$(OutputPath)skv.dll"" xcopy {0}\skv.dll ""$(OutputPath)""", skLibsPath));
            }
        }

        protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("NDEBUG", "_CONSOLE");
            if (target.Platform == Platform.win32)
            {
                conf.Defines.Add("WIN32");
            }

            if (target.Platform == Platform.win64)
            {
                conf.Defines.Add("WIN64");
            }

            if (target.ConsolePlatform == ScoringToolsPlatform.PS4)
            {
                conf.Defines.Add("TARGET_PS4");
                conf.Defines.Add("FORMAT_SKV");
            }

            if (target.ConsolePlatform == ScoringToolsPlatform.XOne)
            {
                conf.Defines.Add("TARGET_XONE");
            }

            if (target.ConsolePlatform == ScoringToolsPlatform.X360)
            {
                conf.Defines.Add("TARGET_X360");
            }
        }
    }

    /// <summary>
    /// The generate labeled examples.
    /// </summary>
    [Generate]
    public class GenerateLabeledExamples : CommonScoringToolApplication
    {
        public GenerateLabeledExamples()
        {
            SourceRootPath = Path.Combine(RootPath, "GenerateLabeledExamples");
        }

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

            conf.AddPublicDependency<ExamplesLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
        }
    }

    [Generate]
    class MicrosoftDirectXControls : ScoringToolDynamicLib
    {
        public MicrosoftDirectXControls()
        {
            SourceRootPath = Path.Combine(RootPath , "DirectX.Wrapper", "DirectX.Controls");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.ProjectName = "Microsoft.DirectX.Controls";
            conf.TargetFileName = conf.ProjectName;
            conf.AdditionalLinkerOptions.Add("gdi32.lib",
                "user32.lib");

            conf.ReferencesByName.Add("PresentationCore.dll",
                "PresentationFramework.dll",
                "System.dll",
                "System.Drawing.dll",
                "System.Windows.Forms.dll",
                "WindowsBase.dll");
            AddPlatformSpecificTargetPath(conf, target.Platform);
        }
    }

    [Generate]
    class MicrosoftDirectXWrapper : ScoringToolDynamicLib
    {
        public MicrosoftDirectXWrapper()
        {
            SourceRootPath = Path.Combine(RootPath, "DirectX.Wrapper", "DirectX.Wrapper");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.ProjectName = "Microsoft.DirectX.Wrapper";
            conf.TargetFileName = conf.ProjectName;
            conf.AdditionalLinkerOptions.Add("gdi32.lib",
                "user32.lib");
            conf.IncludePaths.Clear();
            conf.IncludePaths.Add(SourceRootPath);
            conf.ForcedIncludes.Add("CodeAnalysis/SourceAnnotations.h");
            AddPlatformSpecificTargetPath(conf, target.Platform);
        }
    }

    [Generate]
    class TimelineCacheWrapper : ScoringToolDynamicLib
    {
        public TimelineCacheWrapper()
        {
            SourceRootPath = Path.Combine(RootPath, "TimelineCacheWrapper");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = conf.ProjectName;
            conf.AddPublicDependency<TimelineCacheLib>(target);
        }
    }

    [Generate]
    class Ps4TcpServer : ScoringToolDynamicLib
    {
        public Ps4TcpServer()
        {
            SourceRootPath = Path.Combine(RootPath, "PS4TCPServer");
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.orbis, DevEnv.vs2015 | DevEnv.vs2017,
                Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = conf.ProjectName;
            conf.AdditionalLinkerOptions.Add("-lScePosix_stub_weak", "-lSceNet_stub_weak", "-lSceNetCtl_stub_weak", "-lSceRtc_stub_weak");
        }

        protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("PS4TCPSRV", "NDEBUG");
        }
    }

    [Generate]
    class TimelineCacheLib : ScoringToolLibrary
    {
        public TimelineCacheLib()
        {
            SourceRootPath = Path.Combine(RootPath, "TimelineCacheLib");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = conf.ProjectName + PlatformArchitecture + "_" + target.Optimization.GetLibrarySuffix();
        }
    }

    [Generate]
    class SkeletonDumper : ScoringToolAplication
    {
        public SkeletonDumper()
        {
            SourceRootPath = Path.Combine(RootPath, "SkeletonDumper");
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015 | DevEnv.vs2017,
                Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib,
                ScoringToolsPlatform.XOne));
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = conf.ProjectName;

            if (target.ConsolePlatform == ScoringToolsPlatform.XOne)
            {
                conf.IncludePaths.Add("$(XboxOneXDKLatest)xdk/include/um");
                conf.IncludePaths.Add("$(XboxOneXDKLatest)PC/include");
                conf.LibraryFiles.Add("$(XboxOneXDKLatest)xdk/lib/amd64/xstudioclient.lib");
                conf.Options.Add(new Options.Vc.Linker.DelayLoadDLLs("xstudioclient.dll"));
            }

            conf.DependenciesIncludePaths.Add(ExternPath,
                ExternPath + @"KinectGesture/Inc"
            );
            SetConfigurationTargetPath(conf, target);
            conf.AdditionalLinkerOptions.Add( ZLib, ExampleLib, TimeLineCacheLib);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);
        }

        protected override void ConfigureDefines(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureDefines(conf, target);
            conf.Defines.Add("NDEBUG", "_CONSOLE", "TARGET_XONE", "WIN64");
        }
    }

    [Generate]
    internal class TrainGesture : CommonScoringToolApplication
    {
        public TrainGesture()
        {
            SourceRootPath = Path.Combine(RootPath, "TrainGesture");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            
            conf.AddPublicDependency<ExamplesLib>(new ScoringToolsTarget(Platform.win64, target.DevEnv, target.Optimization, Sharpmake.OutputType.Lib));
        }
    }

    /// <summary>
    /// The train gesture script writer.
    /// </summary>
    [Generate]
    class TrainGestureScriptWriter : ScoringToolAplication
    {
        public TrainGestureScriptWriter()
        {
            SourceRootPath = Path.Combine(RootPath, "TrainGestureScriptWriter");
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = "TrainGestureScriptWriter";
            conf.Options.Add(Options.Vc.General.CharacterSet.Default);
        }
    }

    [Generate]
    public class CoreFunctions : ScoringToolsDotNetApplication
    {
        public CoreFunctions() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {
            SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "Core.Functions");
            AssemblyName = "Core.Functions";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByName.Add("System.Configuration");
            conf.ReferencesByName.Add("System.Windows.Forms");
            conf.ReferencesByName.Add("System.Drawing");
        }
    }

    [Generate]
    internal class CoreFunctionsSolution : SingleProjectSolution<CoreFunctions>
    {
        public CoreFunctionsSolution()
        {
            ClearTargets();
            AddTargets(new Target(Platform.win64, DevEnv.vs2017,
                Sharpmake.Optimization.Debug | Sharpmake.Optimization.Release,
                Sharpmake.OutputType.Dll, framework: DotNetFramework.v4_7));
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFileName = "CoreFunctions";
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "Core.Functions");
        }
    }

    /// <summary>
    /// The solution that includes the C++ utilities for scoring tools
    /// </summary>
    [Generate]
    public class ScoringUtilitiesSolution : BaseCppSolutionGeneric<ScoringToolsTarget>
    {

        public ScoringUtilitiesSolution()
        {
            Name = "ScoringUtilities";
            ClearTargets();
            AddTargets(new ScoringToolsTarget( Platform.win64 | Platform.orbis, DevEnv.vs2015 | DevEnv.vs2017,
                    Engine.Optimization.Debug | Engine.Optimization.Release, OutputType.Lib,
                    ScoringToolsPlatform.None | ScoringToolsPlatform.XOne | ScoringToolsPlatform.PS4));
        }

        /// <summary>
        /// From a target, retrieve all possible values
        /// </summary>
        /// <param name="target">A target</param>
        /// <returns></returns>
        private IEnumerable<ITarget> GetPossibleValues(ITarget target)
        {
            var fields = target.GetType().GetFields();
            foreach (var fieldInfo in fields)
            {
                if (fieldInfo.FieldType.IsEnum)
                {
                    var flags = ((Enum)fieldInfo.GetValue(target)).GetFlags().Cast<Enum>().ToArray();
                    if (flags.Length > 1)
                    {
                        foreach (var flag in flags)
                        {
                            var newTarget = (ScoringToolsTarget)target.Clone();
                            fieldInfo.SetValue(newTarget, flag);
                            var possibleValues = GetPossibleValues(newTarget);
                            foreach (var possibleValue in possibleValues)
                            {
                                yield return possibleValue;
                            }
                        }
                    }
                }
            }

            if (fields.Where(f => f.FieldType.IsEnum).All(f => ((Enum)f.GetValue(target)).GetFlags().Count() == 1))
            {
                yield return target;
            }
        }

        private bool IsValidTargetForProject(ScoringToolsTarget target, Type type)
        {
            var project = Activator.CreateInstance(type) as ScoringToolsNativeApplication;
            var targetPossibilities = project.Targets.TargetPossibilities.SelectMany(x => GetPossibleValues(x)).Distinct();
            return targetPossibilities.Contains(target);
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterProjectsOfType<ScoringToolLibrary>(target, type => IsValidTargetForProject(target, type));
            conf.RegisterProjectsOfType<ScoringToolAplication>(target, type => IsValidTargetForProject(target, type));
            // we are not going to add the projects that are type of ScoringToolDynamicLib and are part of MARS tool.
            // TODO: Eventually all the C++ projects will be in one solution and then we will remove this additional check of 'IsNotMarsProject'
            conf.RegisterProjectsOfType<ScoringToolDynamicLib>(target, type => IsValidTargetForProject(target, type) && IsNotMarsProject(type));
            conf.SolutionPath = Path.Combine(RootPath, "tools", "apps", "ScoringTools");
        }

        private bool IsNotMarsProject(Type type)
        {
            bool include = !(type == typeof(MoveSpaceScoringTools) || type == typeof(MoveSpaceWrapper));

            return include;
        }
    }

    /// <summary>
    /// This class defines the template for scoring pipeline related .net application
    /// </summary>
    public abstract class ScoringToolsDotNetApplication : ApplicationProject
    {
        /// <summary>
        /// 
        /// </summary>
        /// <param name="sourceRootPath">Path to the folder containing the source code</param>
        /// <param name="outputType">valid value from the OutputType enum to indicate the type of application</param>
        public ScoringToolsDotNetApplication(
                string sourceRootPath,
                Configuration.OutputType outputType = Configuration.OutputType.DotNetConsoleApp,
                bool sourceInSubFolder = false) // TODO : we are not passing the parameters to base class and letting it behave as it wants for now 
        {

            if (outputType == Configuration.OutputType.DotNetClassLibrary)
            {
                ProjectType = "framework/scoring";
            }
            else
            {
                ProjectType = "apps/scoring";
            }

            // Assuming that all the .net windows application will have application icon.
            // if the project of type windows app does not have an application Icon. make sure to set this property to empty string in the constructor of the project
            if (outputType == Configuration.OutputType.DotNetWindowsApp)
                ApplicationIcon = @"Resources\[project.Name].ico";

            SourceRootPath = sourceRootPath + @"\[project.Name]\";
            OutputType = outputType;

            
        }

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

            // scoring tool related application project should go under the 'scoring' label when seen in solution
            if (OutputType == Configuration.OutputType.DotNetClassLibrary)
            {
                conf.SolutionFolder = "framework/scoring";
            }
            else
            {
                conf.SolutionFolder = "apps/scoring";
            }

            conf.ReferencesByName.Add("WindowsBase");
            conf.ReferencesByName.Add("PresentationCore");
            conf.ReferencesByName.Add("PresentationFramework");

            conf.TargetPath = OutputPath + @"\lib\Tools\ScoringToolLibs\";
        }
    }

    //************************************* LEGACY SCORING TOOL - BEGIN ***************************************************


    [Generate]
    class GenerateDanceCache : ScoringToolsDotNetApplication
    {
        public GenerateDanceCache() : base(ScoringTools_PostRecordingPipelineTools)
        {
            AssemblyName = "GenerateDanceCache";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Timeline>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
            conf.RegisterWinForms();
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftCore);
            conf.TargetPath = ScoringToolsOuptutPath;
            conf.AddPostBuildCopy(Externs.SandBar);
        }
    }

    [Generate]
    class GenerateDanceCacheSolution : SingleProjectSolution<GenerateDanceCache>
    {
        public GenerateDanceCacheSolution()
        {
        }

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

            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "GenerateDanceCache");
        }
    }

    [Generate]
    class GenerateTMLCache : ScoringToolsDotNetApplication
    {
        public GenerateTMLCache() : base(ScoringTools_PostRecordingPipelineTools) { }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Application>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class GestureBuildLib : ScoringToolsDotNetApplication
    {
        public GestureBuildLib() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {
            AssemblyName = "GestureBuildLib";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "framework/scoring";
            conf.Options.Add(Options.CSharp.TreatWarningsAsErrors.Disabled);
            conf.AddPublicDependency<JD_Perforce>(target);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class BuildGestureGUI : ScoringToolsDotNetApplication
    {
        public BuildGestureGUI() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp)
        {
            SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "BuildGesturesGUI", "BuildGesturesGUI");
            AssemblyName = "BuildGestureGUI";
            Name = GetType().Name;
            ResourcesPath = String.Empty;
            ApplicationIcon = String.Empty;
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Perforce>(target);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
            conf.AddPublicDependency<GestureBuildLib>(target);
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\Examples.Wrapper_x64_r.dll");
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class Examples_Viewer : ScoringToolsDotNetApplication
    {
        public Examples_Viewer() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp, false)
        {
            SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "Examples.Viewer");
            AssemblyName = "Examples.Viewer";
            Name = GetType().Name;
            ResourcesPath = String.Empty;
            ApplicationIcon = String.Empty;
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            (conf.Project as CSharpProject).RootNamespace = "Examples.Viewer";
            conf.AddPublicDependency<GestureBuildLib>(target);
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.AddPublicDependency<Examples_Controls>(target);
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class Examples_Controls : ScoringToolsDotNetApplication
    {
        public Examples_Controls() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, false)
        {
            SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "Examples.Controls");
            AssemblyName = "Examples.Controls";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "framework/scoring";
            (conf.Project as CSharpProject).RootNamespace = "Examples.Controls";
            conf.AddPublicDependency<GestureBuildLib>(target);
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\Examples.Wrapper_x64_r.dll");
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\x64\Microsoft.DirectX.Controls.dll");
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\x64\Microsoft.DirectX.Wrapper.dll");
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class ScoringDataBuildHelper : ScoringToolsDotNetApplication
    {
        public ScoringDataBuildHelper() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, false)
        {
            AssemblyName = "ScoringDataBuildHelper";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Perforce>(target);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
            conf.AddPublicDependency<GestureBuildLib>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class PS4Studio : ScoringToolsDotNetApplication
    {
        public PS4Studio() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp, false)
        {
            AssemblyName = "PS4Studio";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
            ApplicationIcon = "";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByPath.Add(Externs.OrtMapLib);
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class Timeline : ScoringToolsDotNetApplication
    {
        public Timeline() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, true)
        {
            AssemblyName = "Timeline";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "framework/scoring";
            (conf.Project as CSharpProject).RootNamespace = "TimelineUI";
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.RegisterWinForms();
            conf.AddPublicDependency<JD_Core>(target);
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class TimelineUnitTest : ScoringToolsDotNetApplication
    {
        public TimelineUnitTest() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary, false)
        {
            AssemblyName = "TimelineUnitTest";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<Timeline>(target);
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class SKVPlayer : ScoringToolsDotNetApplication
    {
        public SKVPlayer() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetConsoleApp, false)
        {
            AssemblyName = "SKVPlayer";
            Name = GetType().Name;
            ResourcesPath = SourceRootPath + @"\Resources\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<GestureBuildLib>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    // TODO : Rename this project to SnippingTool

    [Generate]
    class ScoringTool : ScoringToolsDotNetApplication
    {
        public ScoringTool() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp, false)
        {
            AssemblyName = "ScoringTool";
            Name = GetType().Name;
            ResourcesPath = String.Empty;
            ApplicationIcon = String.Empty;
            RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<CoreFunctions>(target);
            conf.AddPublicDependency<GestureBuildLib>(target);
            conf.AddPublicDependency<Timeline>(target);
            conf.AddPublicDependency<ScoringDataBuildHelper>(target);
            conf.AddPublicDependency<Examples_Controls>(target);
            conf.AddPublicDependency<JD_Core>(target);
            conf.AddPublicDependency<JD_Asset>(target);
            conf.AddPublicDependency<JD_Perforce>(target);
            conf.AddPublicDependency<JD_Serialization>(target);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\TimelineCacheWrapper.dll");
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\Examples.Wrapper_x64_r.dll");
            conf.ReferencesByPath.Add(Externs.NAudio);
            conf.RegisterWinForms();
            conf.TargetPath = ScoringToolsOuptutPath;

            conf.AddPostBuildDirectoryCopy(@"[project.RootPath]\script", Path.Combine(OutputPath + @"\bin\Release\Tools\ScoringTools\", "script"));
            conf.AddPostBuildDirectoryCopy(@"[project.RootPath]\script", Path.Combine(OutputPath + @"\bin\Debug\Tools\ScoringTools\", "script"));
        }
    }

    class GestureComparer : ScoringToolsDotNetApplication
    {
        protected Platform Platform { get; set; }

        public GestureComparer() : base(ScoringTools_PostRecordingPipelineTools, Configuration.OutputType.DotNetConsoleApp ,false)
        {
            // by default making it support XOne
            Platform = Platform.durango;
            SourceRootPath = Path.Combine(ScoringTools_PostRecordingPipelineTools, "GestureComparer");
            AssemblyName = "GestureComparer";
        }

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

            var fileName = @"\lib\tools\Examples.Wrapper_x64_r.dll";

            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + fileName);
            conf.ReferencesByPath.Add(Externs.KinectGestureTrainerWrapperPs4);
            conf.ReferencesByPath.Add(Externs.KinectGestureTrainerWrapperX360);
            conf.ReferencesByPath.Add(Externs.KinectGestureTrainerWrapperXOne);
            conf.ReferencesByPath.Add(Externs.CameraScoringFilesInfoProvider);

            var optimization = target.Optimization.ToString();
            var configuration = optimization.Contains("Debug", StringComparison.OrdinalIgnoreCase) ? "Debug" : "Release";

            string platform = string.Empty;

            if (Platform == Platform.durango)
                platform = "XOne";
            else if (Platform == Platform.orbis)
                platform = "Ps4";
            else if (Platform == Platform.x360)
                platform = "X360";

            conf.Defines.Clear();
            conf.Defines.Add("TARGET_" + platform);
            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.TargetPath = Path.Combine(OutputPath + @"\bin\[conf.Name]\Tools\ScoringTools\", "GestureComparer", platform.ToString());
            
        }
    }

    [Generate]
    class GestureComparerXOne : GestureComparer
    {
        public GestureComparerXOne()
        {
            Platform = Platform.durango;
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ProjectFileName = "GestureComparerXone";
        }
    }

    [Generate]
    internal class GestureComparerXOneSolution : SingleProjectSolution<GestureComparerXOne>
    {
        public GestureComparerXOneSolution()
        {
            
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFileName = "GestureComparerXOne";
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "GestureComparer");
        }
    }

    [Generate]
    class GestureComparerPs4 : GestureComparer
    {
        public GestureComparerPs4()
        {
            Platform = Platform.orbis;
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ProjectFileName = "GestureComparerPs4";
        }
    }

    [Generate]
    internal class GestureComparerPs4Solution : SingleProjectSolution<GestureComparerPs4>
    {
        public GestureComparerPs4Solution()
        {
            
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFileName = "GestureComparerPs4";
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "src", "GestureComparer");
        }
    }

    //************************************* LEGACY SCORING TOOL - END ***************************************************

    [Generate]
    class CafeCommand : ScoringToolsDotNetApplication
    {
        public CafeCommand() : base(ScoringTools_RecordingPipelineTools)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<WiiULauncherAPI>(target);
        }
    }

    [Generate]
    class CafeCommandSolution : SingleProjectSolution<CafeCommand>
    {
        public CafeCommandSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "CafeCommand");
        }
    }


    [Generate]
    class CaptureTool : ScoringToolsDotNetApplication
    {
        public CaptureTool() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<DKTPServer>(target);
        }
    }

    [Generate]
    class CaptureToolSolution : SingleProjectSolution<CaptureTool>
    {
        public CaptureToolSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "CaptureTool");
        }
    }


    [Generate]
    class DevkitRecorderInterface : ScoringToolsDotNetApplication
    {
        public DevkitRecorderInterface() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }
    }

    [Generate]
    class DevkitRecorderInterfaceSolution : SingleProjectSolution<DevkitRecorderInterface>
    {
        public DevkitRecorderInterfaceSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "DevkitRecorderInterface");
        }
    }

    [Generate]
    class DKTPServer : ScoringToolsDotNetApplication
    {
        public DKTPServer() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }
    }

    [Generate]
    class DKTPServerSolution : SingleProjectSolution<DKTPServer>
    {
        public DKTPServerSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "DKTPServer");
        }
    }

    [Generate]
    class GraphicTools : ScoringToolsDotNetApplication
    {
        public GraphicTools() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByName.Add("System.xaml");

            conf.AddPublicDependency<MSPMatrixVector>(target);
        }
    }

    [Generate]
    class GraphicToolsSolution : SingleProjectSolution<GraphicTools>
    {
        public GraphicToolsSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "GraphicTools");
        }
    }

    [Generate]
    class KinectRecorder : ScoringToolsDotNetApplication
    {
        public KinectRecorder() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByName.Add("System.Drawing");
            conf.ReferencesByName.Add("System.xaml");

            conf.AddPostBuildCopy("$(ProjectDir)\\Dependency\\xstudio.dll", "$(TargetDir)");
        }
    }

    [Generate]
    class KinectRecorderSolution : SingleProjectSolution<KinectRecorder>
    {
        public KinectRecorderSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRecorder");
        }
    }

    [Generate]
    class KinectRemoteHost : ScoringToolsDotNetApplication
    {
        public KinectRemoteHost() : base(ScoringTools_RecordingPipelineTools)
        {

        }

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

            var configFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteHost", "KinectRemoteHost.exe.config");

            var postBuildCopyCommand = "xcopy /Y \"" + configFilePath + "\" \"$(TargetDir)\"";

            conf.EventPostBuild.Add(postBuildCopyCommand);
        }
    }

    [Generate]
    class KinectRemoteHostSolution : SingleProjectSolution<KinectRemoteHost>
    {
        public KinectRemoteHostSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteHost");
        }
    }

    [Generate]
    class KinectRemoteType : ScoringToolsDotNetApplication
    {
        public KinectRemoteType() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            var xstudioManagedDll = Path.Combine(@"C:\Program Files (x86)\Microsoft Durango XDK", "bin", "XStudioManaged.dll");
            conf.ReferencesByPath.Add(xstudioManagedDll);

            var configFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MARS", "KinectRemoteType.config");

            var postBuildCopyCommand = "xcopy /Y \"" + configFilePath + "\" \"$(TargetDir)\"";

            conf.EventPostBuild.Add(postBuildCopyCommand);
        }
    }

    [Generate]
    class KinectRemoteTypeSolution : SingleProjectSolution<KinectRemoteType>
    {
        public KinectRemoteTypeSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteType");
        }
    }

    [Generate]
    class LuaMoveExtractor : ScoringToolsDotNetApplication
    {
        public LuaMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<MoveReaderInterface>(target);
        }
    }

    [Generate]
    class LuaMoveExtractorSolution : SingleProjectSolution<LuaMoveExtractor>
    {
        public LuaMoveExtractorSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "LuaMoveExtractor");
        }
    }


    [Generate]
    class Mars : ScoringToolsDotNetApplication
    {
        public Mars() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp)
        {
            StartupObject = "Mars.Program";
        }

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

            conf.ReferencesByName.Add("Microsoft.VisualBasic");
            conf.ReferencesByName.Add("System.Drawing");
            conf.ReferencesByName.Add("System.Runtime.Remoting");
            conf.ReferencesByName.Add("System.Windows.Forms");
            conf.ReferencesByName.Add("System.xaml");
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftCore);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
            conf.ReferencesByNuGetPackage.Add(Externs.NewtonsoftJsonNuget);
            conf.RegisterPerforce();

            var xstudioManagedDll =
                Path.Combine(@"C:\Program Files (x86)\Microsoft Durango XDK", "bin", "XStudioManaged.dll");
            conf.ReferencesByPath.Add(xstudioManagedDll);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\movespacewrapper.dll");

            conf.AddPublicDependency<WiiULauncherAPI>(target);

            conf.AddPublicDependency<JD_Core>(target);
            conf.AddPublicDependency<CaptureTool>(target);
            conf.AddPublicDependency<DKTPServer>(target);
            conf.AddPublicDependency<DevkitRecorderInterface>(target);
            conf.AddPublicDependency<GraphicTools>(target);
            conf.AddPublicDependency<KinectRecorder>(target);
            conf.AddPublicDependency<KinectRemoteHost>(target);
            conf.AddPublicDependency<KinectRemoteType>(target);
            conf.AddPublicDependency<MarsTools>(target);
            conf.AddPublicDependency<MarsRemotingInterfaces>(target);
            conf.AddPublicDependency<MoveSpaceTool>(target);
            conf.AddPublicDependency<MSPClassifier>(target);
            conf.AddPublicDependency<MarsInterfaces>(target);
            conf.AddPublicDependency<MSPStats>(target);
            conf.AddPublicDependency<MSPMatrixVector>(target);
            conf.AddPublicDependency<NotifyIconWpf>(target);
            conf.AddPublicDependency<PS4Recorder>(target);
            conf.AddPublicDependency<LuaMoveExtractor>(target);
            conf.AddPublicDependency<TmlDtapeMoveExtractor>(target);
            conf.AddPublicDependency<TmlMoveExtractor>(target);
            conf.AddPublicDependency<TplMoveExtractor>(target);
            conf.AddPublicDependency<WaveformView>(target);
            conf.AddPublicDependency<WebmPlayer>(target);

            // copy the project folder from solution folder to the output folder
            var projectConfigurationFiles = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars", "Projects");
            var ffmpegBinaries = Path.Combine(BranchRoot, "extern", "ffmpeg", "scoringToolRelated");
            var toolsFolder = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars", "Tools");

            // TODO: Need to figure out a neat way of doing the copy of .config files.
            var kinectRemoteTypeConfigFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MARS", "KinectRemoteType.config");
            var kinectRemoteHostConfigFilePath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "KinectRemoteHost", "KinectRemoteHost.exe.config");

            var postBuildEventCommand = "xcopy /E /Y /D \"" + projectConfigurationFiles + "\" \"$(TargetDir)Projects\\\"";
            var postBuildCommandToCopyFfmpegBinaries = "xcopy /E /Y /D \"" + ffmpegBinaries + "\" \"$(TargetDir)\"";
            var postBuildCommandToCopyToolsFolderToOutput = "xcopy /E /Y /D \"" + toolsFolder + "\" \"$(TargetDir)Tools\\\"";
            var postBuildCopyCommandToCopyKinectConfig = "xcopy /Y \"" + kinectRemoteTypeConfigFilePath + "\" \"$(TargetDir)\"";
            var postBuildCopyCommandToCopyKinectHostConfig = "xcopy /Y \"" + kinectRemoteHostConfigFilePath + "\" \"$(TargetDir)\"";

            conf.EventPostBuild.Add(postBuildEventCommand);
            conf.EventPostBuild.Add(postBuildCommandToCopyFfmpegBinaries);
            conf.EventPostBuild.Add(postBuildCommandToCopyToolsFolderToOutput);
            conf.EventPostBuild.Add(postBuildCopyCommandToCopyKinectConfig);
            conf.EventPostBuild.Add(postBuildCopyCommandToCopyKinectHostConfig);

            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class MarsSolution : SingleProjectSolution<Mars>
    {
        public MarsSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddProject<MarsServer>(target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars");

        }
    }

    [Generate]
    class MarsTools : ScoringToolsDotNetApplication
    {
        public MarsTools() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

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

            conf.ReferencesByName.Add("System.Management");

            conf.AddPublicDependency<MoveReaderInterface>(target);
            conf.AddPublicDependency<RecMoveExtractor>(target);
        }
    }

    [Generate]
    class MarsToolsSolution : SingleProjectSolution<MarsTools>
    {
        public MarsToolsSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsTools");
        }
    }

    [Generate]
    class MarsInterfaces : ScoringToolsDotNetApplication
    {
        public MarsInterfaces() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            // TODO: this needs to be fixed.. the interfaces should not depend on any MARS related projects
            conf.ReferencesByName.Add("System.Runtime.Remoting");
            conf.AddPublicDependency<RecTool>(target);
            conf.AddPublicDependency<MarsTools>(target);
            conf.AddPublicDependency<MSPClassifier>(target);
        }
    }

    [Generate]
    class MarsInterfacesSolution : SingleProjectSolution<MarsInterfaces>
    {
        public MarsInterfacesSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsInterfaces");
        }
    }

    [Generate]
    class MarsServer : ScoringToolsDotNetApplication
    {
        public MarsServer() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetWindowsApp)
        {
            StartupObject = "MarsServer.Program";
        }

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

            conf.ReferencesByName.Add("System.Drawing");
            conf.ReferencesByName.Add("System.Runtime.Remoting");
            conf.ReferencesByName.Add("System.Xaml");
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftCore);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);
            conf.RegisterPerforce();


            conf.AddPublicDependency<MarsTools>(target);
            conf.AddPublicDependency<MarsInterfaces>(target);
            conf.AddPublicDependency<MoveReaderInterface>(target);
            conf.AddPublicDependency<MarsRemotingInterfaces>(target);
            conf.AddPublicDependency<RecMoveExtractor>(target);
            conf.AddPublicDependency<TmlDtapeMoveExtractor>(target);
            conf.AddPublicDependency<TmlMoveExtractor>(target);
            conf.AddPublicDependency<TplMoveExtractor>(target);

            var projectConfigurationFiles = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "Mars", "Projects");
            var postBuildEventCommand = "xcopy /E /Y /D \"" + projectConfigurationFiles + "\" \"$(TargetDir)Projects\\\"";
            conf.EventPostBuild.Add(postBuildEventCommand);

            conf.TargetPath = ScoringToolsOuptutPath;
        }
    }

    [Generate]
    class MarsServerSolution : SingleProjectSolution<MarsServer>
    {
        public MarsServerSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsServer");
        }
    }

    [Generate]
    class MarsRemotingInterfaces : ScoringToolsDotNetApplication
    {
        public MarsRemotingInterfaces() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<MarsTools>(target);
        }
    }

    [Generate]
    class MarsRemotingInterfacesSolution : SingleProjectSolution<MarsRemotingInterfaces>
    {
        public MarsRemotingInterfacesSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MarsRemotingInterfaces");
        }
    }

    [Generate]
    class MoveSpaceTool : ScoringToolsDotNetApplication
    {
        public MoveSpaceTool() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\movespacewrapper.dll");
        }
    }

    [Generate]
    class MoveSpaceToolSolution : SingleProjectSolution<MoveSpaceTool>
    {
        public MoveSpaceToolSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveSpaceTool");
        }
    }

    [Generate]
    class MSPClassifier : ScoringToolsDotNetApplication
    {
        public MSPClassifier() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<MoveSpaceTool>(target);
            conf.ReferencesByPath.Add(ScoringUtilitiesOutput + @"\lib\tools\movespacewrapper.dll");
            conf.AddPublicDependency<MSPStats>(target);
            conf.AddPublicDependency<MSPMatrixVector>(target);
            conf.AddPublicDependency<RecMoveExtractor>(target);
        }
    }

    [Generate]
    class MSPClassifierSolution : SingleProjectSolution<MSPClassifier>
    {
        public MSPClassifierSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MSPClassifier");
        }
    }


    [Generate]
    class MoveReaderInterface : ScoringToolsDotNetApplication
    {
        public MoveReaderInterface() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }
    }

    [Generate]
    class MoveReaderInterfaceSolution : SingleProjectSolution<MoveReaderInterface>
    {
        public MoveReaderInterfaceSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveReaderInterface");
        }
    }

    [Generate]
    class MSPMatrixVector : ScoringToolsDotNetApplication
    {
        public MSPMatrixVector() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }
    }

    [Generate]
    class MSPMatrixVectorSolution : SingleProjectSolution<MSPMatrixVector>
    {
        public MSPMatrixVectorSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MSPMatrixVector");
        }
    }

    [Generate]
    class MSPStats : ScoringToolsDotNetApplication
    {
        public MSPStats() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<MSPMatrixVector>(target);
        }
    }

    [Generate]
    class MSPStatsSolution : SingleProjectSolution<MSPStats>
    {
        public MSPStatsSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MSPStats");
        }
    }


    [Generate]
    class RecTool : ScoringToolsDotNetApplication
    {
        public RecTool() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }
    }

    [Generate]
    class RecToolSolution : SingleProjectSolution<RecTool>
    {
        public RecToolSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "RecTool");
        }
    }

    [Generate]
    class RecMoveExtractor : ScoringToolsDotNetApplication
    {
        public RecMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<MoveReaderInterface>(target);
            conf.AddPublicDependency<RecTool>(target);
        }
    }

    [Generate]
    class RecMoveExtractorSolution : SingleProjectSolution<RecMoveExtractor>
    {
        public RecMoveExtractorSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "RecMoveExtractor");
        }
    }

    [Generate]
    class TmlDtapeMoveExtractor : ScoringToolsDotNetApplication
    {
        public TmlDtapeMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<LuaMoveExtractor>(target);
        }
    }

    [Generate]
    class TmlDtapeMoveExtractorSolution : SingleProjectSolution<TmlDtapeMoveExtractor>
    {
        public TmlDtapeMoveExtractorSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "TmlDtapeMoveExtractor");
        }
    }

    [Generate]
    class TmlMoveExtractor : ScoringToolsDotNetApplication
    {
        public TmlMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<MoveReaderInterface>(target);
        }
    }

    [Generate]
    class TmlMoveExtractorSolution : SingleProjectSolution<TmlMoveExtractor>
    {
        public TmlMoveExtractorSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "TmlMoveExtractor");
        }
    }

    [Generate]
    class TplMoveExtractor : ScoringToolsDotNetApplication
    {
        public TplMoveExtractor() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<LuaMoveExtractor>(target);
            conf.AddPublicDependency<MoveReaderInterface>(target);
        }
    }

    [Generate]
    class TplMoveExtractorSolution : SingleProjectSolution<TplMoveExtractor>
    {
        public TplMoveExtractorSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "TplMoveExtractor");
        }
    }


    [Generate]
    class WebmPlayer : ScoringToolsDotNetApplication
    {
        public WebmPlayer() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {
            OutputType = Configuration.OutputType.DotNetClassLibrary;
            ResourcesPath = SourceRootPath + @"\Resources\";
            ResourceFilesExtensions.Add(".exe");
        }

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

            conf.ReferencesByName.Add("System.xaml");

            conf.ReferencesByNuGetPackage.Add(Externs.FfmeWindows);
        }
    }

    [Generate]
    class WebmPlayerSolution : SingleProjectSolution<WebmPlayer>
    {
        public WebmPlayerSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "WebmPlayer");
        }
    }

    [Generate]
    class WiiULauncherAPI : ScoringToolsDotNetApplication
    {
        public WiiULauncherAPI() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }
    }

    [Generate]
    class WiiULauncherAPISolution : SingleProjectSolution<WiiULauncherAPI>
    {
        public WiiULauncherAPISolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "WiiULauncherAPI");
        }
    }

    [Generate]
    class NotifyIconWpf : ScoringToolsDotNetApplication
    {
        public NotifyIconWpf() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {
            OutputType = Configuration.OutputType.DotNetClassLibrary;
            ResourceFiles.Add("DefaultTrayIcon.ico");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByName.Add("System.Drawing");
            conf.ReferencesByName.Add("System.xaml");
        }
    }

    [Generate]
    class NotifyIconWpfSolution : SingleProjectSolution<NotifyIconWpf>
    {
        public NotifyIconWpfSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "NotifyIconWpf");
        }
    }

    [Generate]
    class PS4Recorder : ScoringToolsDotNetApplication
    {
        public PS4Recorder() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByPath.Add(@"C:\Program Files (x86)\SCE\ORBIS\Tools\Target Manager Server\bin\Interop.ORTMAPILib.dll");
            var PS4StudioDllPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "PostRecordingPipelineTools", "bin", "PS4Studio.dll");
            conf.ReferencesByPath.Add(PS4StudioDllPath);
        }
    }

    [Generate]
    class PS4RecorderSolution : SingleProjectSolution<PS4Recorder>
    {
        public PS4RecorderSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "PS4Recorder");
        }
    }


    [Generate]
    class WaveformView : ScoringToolsDotNetApplication
    {
        public WaveformView() : base(ScoringTools_RecordingPipelineTools, Configuration.OutputType.DotNetClassLibrary)
        {
            OutputType = Configuration.OutputType.DotNetClassLibrary;
        }

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

            conf.ReferencesByName.Add("System.Drawing");
            conf.ReferencesByName.Add("System.xaml");

            conf.ReferencesByPath.Add(Externs.NAudio);
            conf.ReferencesByPath.Add(Externs.NAudioWindowMediaFormat);
        }
    }

    [Generate]
    class WaveformViewSolution : SingleProjectSolution<WaveformView>
    {
        public WaveformViewSolution()
        {

        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "WaveformView");
        }
    }

    [Generate]
    class MoveSpaceScoringTools : ScoringToolLibrary
    {
        public MoveSpaceScoringTools()
        {
            RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveSpace");
            SourceRootPath = RootPath;
            SourceFilesExcludeRegex.Add(".cs");
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015,
                Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.Options.Remove(Options.Vc.General.TreatWarningsAsErrors.Enable);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);

            conf.If(Platform.orbis | Platform.nx).AdditionalCompilerOptions.Add(" -w");

            conf.IncludePaths.Add(RootPath + "/Includes");
            conf.IncludePaths.Add(RootPath);

            conf.SolutionFolder = "apps/Mars";
        }
    }


    [Generate]
    class MoveSpaceWrapper : ScoringToolDynamicLib
    {
        public MoveSpaceWrapper()
        {
            RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "MoveSpaceWrapper");
            SourceRootPath = RootPath;
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015,
                Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
        }

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

            conf.Options.Remove(Options.Vc.General.TreatWarningsAsErrors.Enable);
            conf.Options.Add(Options.Vc.General.TreatWarningsAsErrors.Disable);

            conf.If(Platform.orbis | Platform.nx).AdditionalCompilerOptions.Add(" -w");

            conf.IncludePaths.Add(RootPath + "/Includes");
            conf.IncludePaths.Add(RootPath);

            conf.AddPublicDependency<MoveSpaceScoringTools>(target);

            conf.SolutionFolder = "apps/Mars";
            conf.TargetFileName = conf.ProjectName;
        }
    }


    [Generate]
    internal class JoyConCapturer : BaseCppProject
    {
        public JoyConCapturer()
        {
            RootPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "JoyConCapturer");
            OutputType = Configuration.OutputType.Exe;
            Name = "JoyConCapturer";
            ClearTargets();
            AddTargets(new BaseCppTarget(Platform.nx,
                DevEnv.vs2015 | DevEnv.vs2017,
                Optimization.Debug | Optimization.Release,
                Sharpmake.OutputType.Lib, ApplicationType.Standalone));
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.TargetFileName = "JoyConCapturer";
            conf.TargetPath = OutputPath + @"\bin\[conf.Name]\Tools\ScoringTools\[project.Name]\";
        }
    }

    [Generate]
    public class JoyConCapturerSolution : BaseCppSolution
    {
        public static readonly string ToolsPath = Globals.BranchRoot + @"tools\";

        public static readonly string ScoringToolsApplicationsPath = Path.Combine(ToolsPath, "apps", "ScoringTools", "RecordingPipelineTools", "JoyConCapturer");

        public JoyConCapturerSolution()
        {
            Name = "JoyConCapturer";
            ClearTargets();
            AddTargets(new BaseCppTarget(Platform.nx,
                DevEnv.vs2015 | DevEnv.vs2017,
                Optimization.Debug | Optimization.Release,
                Sharpmake.OutputType.Lib, ApplicationType.Standalone));
        }

        public override void ConfigureAll(Configuration conf, BaseCppTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.AddProject<JoyConCapturer>(target);
            conf.SolutionPath = ScoringToolsApplicationsPath;
        }
    }

    //*************************** MANAGED CODE Solution*******************************
    ///
    /// Creates the solution for all the .NET based applications used in the scoring pipeline 
    ///

    [Generate]
    public class ManagedScoringTools : BaseSolution
    {
        public ManagedScoringTools()
        {
            Name = "ManagedScoringTools";
        }

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

            conf.RegisterProjectsOfType<ScoringToolsDotNetApplication>(target);
            conf.SolutionFileName = "ManagedScoringTools";
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools");
        }
    }


    //*************************** UNMANAGED CODE Solution*******************************
    [Generate]
    public class UnManagedScoringTools : BaseCppSolutionGeneric<ScoringToolsTarget>
    {
        public UnManagedScoringTools()
        {
            Name = "UnManagedScoringTools";
            ClearTargets();
            AddTargets(new ScoringToolsTarget(Platform.win64, DevEnv.vs2015,
                    Engine.Optimization.Debug | Engine.Optimization.Release, Sharpmake.OutputType.Lib));
        }

        public override void ConfigureAll(Configuration conf, ScoringToolsTarget target)
        {
            base.ConfigureAll(conf, target);
            conf.AddProject<MoveSpaceScoringTools>(target);     // we have one more project which is same as 
            conf.AddProject<MoveSpaceWrapper>(target);

            conf.SolutionFileName = "UnManagedScoringTools";
            conf.SolutionPath = Path.Combine(RootPath, "tools", "apps", "ScoringTools");
        }
    }
}