//#define DEBUG_IMPORTER

using UnityEditor;
using UnityEngine;
using UnityEditor.AssetImporters;
using UnityEngine.Video;
using System;
using System.Linq;
using System.IO;
using System.Collections.Generic;

[ScriptedImporter(2, "xaml")]
class NoesisXamlImporter : ScriptedImporter
{
    [UnityEditor.InitializeOnLoadMethod]
    static void RegisterApplicationResourcesHash()
    {
        string projectPath = System.IO.Path.GetDirectoryName(Application.dataPath);
        string filename = System.IO.Path.Combine(projectPath, "Library", "Noesis", "ApplicationResources_Hash");

        if (File.Exists(filename))
        {
            try
            {
                string hash = File.ReadAllText(filename);
                AssetDatabase.RegisterCustomDependency("Noesis_ApplicationResources", Hash128.Parse(hash));
            }
            catch (Exception e)
            {
                Debug.LogException(e);
            }
        } 
    }

    [Serializable]
    struct Dependencies
    {
        public string hash;
        public long timestamp;
        public List<string> items;
    }

    static string HashFile(string path)
    {
        var hash = new Hash128();
        hash.Append(File.ReadAllText(path));
        return hash.ToString();
    }

    static string HashStr(string str)
    {
        var hash = new Hash128();
        hash.Append(str);
        return hash.ToString();
    }

    static string DependenciesPath()
    {
        string projectPath = System.IO.Path.GetDirectoryName(Application.dataPath);
        return System.IO.Path.Combine(projectPath, "Library", "Noesis", "Dependencies2");
    }

    static bool LoadDependencies(string path, ref Dependencies deps)
    {
        string folder = DependenciesPath();
        string filename = Path.Combine(folder, HashStr(path));

        if (File.Exists(filename))
        {
            try
            {
                string json = File.ReadAllText(filename);
                deps = JsonUtility.FromJson<Dependencies>(json);
                return true;
            }
            catch (Exception e)
            {
                Debug.LogException(e);
            }
        }

        return false;
    }

    static void SaveDependencies(string path, Dependencies deps)
    {
        try
        {
            string folder = DependenciesPath();
            System.IO.Directory.CreateDirectory(folder);

            string json = JsonUtility.ToJson(deps);
            File.WriteAllText(Path.Combine(folder, HashStr(path)), json);
        }
        catch (Exception e)
        {
            Debug.LogException(e);
        }
    }

    static IEnumerable<string> FindFonts(string uri)
    {
        int index = uri.IndexOf('#');
        if (index != -1)
        {
            string folder = uri.Substring(0, index);
            if (Directory.Exists(folder))
            {
                string family = uri.Substring(index + 1);
                var files = Directory.EnumerateFiles(folder).Where(s => IsFont(s));

                foreach (var font in files)
                {
                    using (FileStream file = File.Open(font, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        if (NoesisUnity.HasFamily(file, family))
                        {
                            yield return font;
                        }
                    }
                }
            }
        }
    }

    static Dependencies GetCachedDependencies(string path)
    {
        Dependencies deps = new Dependencies();
        bool cached = LoadDependencies(path, ref deps);

        long timestamp = 0;

        try
        {
            timestamp = File.GetLastWriteTime(path).Ticks;
        }
        catch (Exception e)
        {
            Debug.LogException(e);
        }

        if (cached)
        {
            if (timestamp == deps.timestamp)
            {
                return deps;
            }

            deps.timestamp = timestamp;

            string hash = HashFile(path);
            if (hash == deps.hash)
            {
                SaveDependencies(path, deps);
                return deps;
            }

            deps.hash = hash;
        }
        else
        {
            deps.timestamp = timestamp;
            deps.hash = HashFile(path);
        }

      #if DEBUG_IMPORTER
        Debug.Log($"=> Dependencies {path}");
      #endif

        deps.items = new List<string>();

        bool typesWithAttributeRequested = false;
        TypeCache.TypeCollection typesWithAttribute;

        using (FileStream file = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            Noesis.GUI.GetXamlDependencies(file, path, (uri_, type) =>
            {
                try
                {
                    string assembly = Noesis.UriHelper.GetAssembly(uri_);
                    string uri = Noesis.UriHelper.GetPath(uri_);

                    if (assembly == "Noesis.GUI.Extensions")
                    {
                        uri = $"Packages/com.noesis.noesisgui/{uri}";
                    }

                    if (type == Noesis.XamlDependencyType.Filename)
                    {
                        deps.items.Add(uri);
                    }
                    else if (type == Noesis.XamlDependencyType.Font)
                    {
                        foreach (var font in FindFonts(uri))
                        {
                            if (!deps.items.Contains(font))
                            {
                                deps.items.Add(font);
                            }
                        }
                    }
                    else if (type == Noesis.XamlDependencyType.Class)
                    {
                        if (!typesWithAttributeRequested)
                        {
                            typesWithAttributeRequested = true;
                            typesWithAttribute = TypeCache.GetTypesWithAttribute<Noesis.AssetDependencyAttribute>();
                        }

                        foreach (var cachedType in typesWithAttribute)
                        {
                            if (cachedType.FullName == uri)
                            {
                                object[] attributes = cachedType.GetCustomAttributes(typeof(Noesis.AssetDependencyAttribute), false);
                                foreach (Noesis.AssetDependencyAttribute attribute in attributes)
                                {
                                    if (String.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(attribute.AssetPath)))
                                    {
                                        Debug.LogWarning($"[{cachedType.FullName}] Invalid AssetDependency '{attribute.AssetPath}'");
                                    }
                                    else
                                    {
                                        deps.items.Add(attribute.AssetPath);
                                    }
                                }
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    Debug.LogException(e);
                }
            });
        }

        SaveDependencies(path, deps);
        return deps;
    }

    static string[] GatherDependenciesFromSourceFile(string path)
    {
        NoesisUnity.InitCore();
        List<string> deps = new List<string>();

        try
        {
            foreach (var dep in GetCachedDependencies(path).items)
            {
                if (File.Exists(dep))
                {
                    deps.Add(dep);
                }
            }
        }
        catch (Exception e)
        {
            Debug.LogException(e);
        }

        return deps.ToArray();
    }

    static bool AddFont(string uri, ref List<NoesisFont> fonts)
    {
        NoesisFont font = AssetDatabase.LoadAssetAtPath<NoesisFont>(uri);

        if (font != null)
        {
            fonts.Add(font);
            return true;
        }

        return false;
    }

    static bool AddTexture(string uri, ref List<Texture> textures, ref List<Sprite> sprites)
    {
        if (AssetImporter.GetAtPath(uri) is TextureImporter textureImporter)
        {
            if (!AssetDatabase.GetLabels(textureImporter).Contains("Noesis"))
            {
                Debug.LogWarning($"{uri} is missing Noesis label");
            }

            if (textureImporter.textureType == TextureImporterType.Sprite &&
                textureImporter.spriteImportMode == SpriteImportMode.Single)
            {
                Sprite sprite = AssetDatabase.LoadAssetAtPath<Sprite>(uri);

                if (sprite != null)
                {
                    sprites.Add(sprite);
                    return true;
                }
            }
            else
            {
                Texture texture = AssetDatabase.LoadAssetAtPath<Texture>(uri);

                if (texture != null)
                {
                    textures.Add(texture);
                    return true;
                }
            }
        }

        return false;
    }

    static bool AddAudio(string uri, ref List<AudioClip> audios)
    {
        AudioClip audio = AssetDatabase.LoadAssetAtPath<AudioClip>(uri);

        if (audio != null)
        {
            audios.Add(audio);
            return true;
        }

        return false;
    }

    static bool AddVideo(string uri, ref List<VideoClip> videos)
    {
        VideoClip video = AssetDatabase.LoadAssetAtPath<VideoClip>(uri);

        if (video != null)
        {
            videos.Add(video);
            return true;
        }

        return false;
    }

    static bool AddRive(string uri, ref List<NoesisRive> rives)
    {
        NoesisRive rive = AssetDatabase.LoadAssetAtPath<NoesisRive>(uri);

        if (rive != null)
        {
            rives.Add(rive);
            return true;
        }

        return false;
    }

    static bool AddXaml(string uri, ref List<NoesisXaml> xamls)
    {
        NoesisXaml xaml = AssetDatabase.LoadAssetAtPath<NoesisXaml>(uri);

        if (xaml != null)
        {
            xamls.Add(xaml);
            return true;
        }

        return false;
    }

    static bool AddShader(string uri, ref List<NoesisShader> shaders)
    {
        NoesisShader shader = AssetDatabase.LoadAssetAtPath<NoesisShader>(uri);

        if (shader != null)
        {
            shaders.Add(shader);
            return true;
        }

        return false;
    }

    static void ScanDependencies(AssetImportContext ctx,
        out List<NoesisFont> fonts_, out List<Texture> textures_, out List<Sprite> sprites_,
        out List<AudioClip> audios_, out List<VideoClip> videos_, out List<NoesisRive> rives_,
        out List<NoesisXaml> xamls_, out List<NoesisShader> shaders_)
    {
        List<NoesisFont> fonts = new List<NoesisFont>();
        List<Texture> textures = new List<Texture>();
        List<Sprite> sprites = new List<Sprite>();
        List<AudioClip> audios = new List<AudioClip>();
        List<VideoClip> videos = new List<VideoClip>();
        List<NoesisRive> rives = new List<NoesisRive>();
        List<NoesisXaml> xamls = new List<NoesisXaml>();
        List<NoesisShader> shaders = new List<NoesisShader>();

        string filename = ctx.assetPath;

        try
        {
            if (HasExtension(filename, ".xaml"))
            {
                // Add dependency to code-behind, just the source, we don't need the artifact
                // Even if the file doesn't exist we add it to get a reimport first time code-behind is created
                ctx.DependsOnSourceAsset(filename + ".cs");
            }

            var dependencies = GetCachedDependencies(filename);

            foreach (var dep in dependencies.items)
            {
                // Register the dependency even if it doesn't currently exist. 
                // This ensures we are re-evaluated if it is imported later.
                ctx.DependsOnArtifact(dep);

                if (!String.IsNullOrEmpty(AssetDatabase.AssetPathToGUID(dep)))
                {
                    if (!AddXaml(dep, ref xamls))
                    {
                        if (!AddTexture(dep, ref textures, ref sprites))
                        {
                            if (!AddFont(dep, ref fonts))
                            {
                                if (!AddAudio(dep, ref audios))
                                {
                                    if (!AddVideo(dep, ref videos))
                                    {
                                        if (!AddShader(dep, ref shaders))
                                        {
                                            AddRive(dep, ref rives);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        catch (Exception e)
        {
            Debug.LogException(e);
        }

        fonts_ = fonts;
        textures_ = textures;
        sprites_ = sprites;
        audios_ = audios;
        videos_ = videos;
        rives_ = rives;
        xamls_ = xamls;
        shaders_ = shaders;
    }

    public override void OnImportAsset(AssetImportContext ctx)
    {
        NoesisUnity.InitCore();

      #if DEBUG_IMPORTER
        Debug.Log($"=> Import {ctx.assetPath}");
      #endif

        NoesisXaml xaml = (NoesisXaml)ScriptableObject.CreateInstance<NoesisXaml>();
        xaml.uri = ctx.assetPath;
        xaml.content = System.Text.Encoding.UTF8.GetBytes(File.ReadAllText(ctx.assetPath));

        // Add dependencies
        List<NoesisFont> fonts;
        List<Texture> textures;
        List<Sprite> sprites;
        List<AudioClip> audios;
        List<VideoClip> videos;
        List<NoesisRive> rives;
        List<NoesisXaml> xamls;
        List<NoesisShader> shaders;

        ScanDependencies(ctx, out fonts, out textures, out sprites, out audios, out videos, out rives, out xamls, out shaders);

        xaml.xamls = xamls.Select(x => new NoesisXaml.Xaml { uri = AssetDatabase.GetAssetPath(x), xaml = x }).ToArray();
        xaml.textures = textures.Select(x => new NoesisXaml.Texture { uri = AssetDatabase.GetAssetPath(x), texture = x }).ToArray();
        xaml.sprites = sprites.Select(x => new NoesisXaml.Sprite { uri = AssetDatabase.GetAssetPath(x), sprite = x }).ToArray();
        xaml.audios = audios.Select(x => new NoesisXaml.Audio { uri = AssetDatabase.GetAssetPath(x), audio = x }).ToArray();
        xaml.videos = videos.Select(x => new NoesisXaml.Video { uri = AssetDatabase.GetAssetPath(x), video = x }).ToArray();
        xaml.rives = rives.Select(x => new NoesisXaml.Rive { uri = AssetDatabase.GetAssetPath(x), rive = x }).ToArray();
        xaml.fonts = fonts.Select(x => new NoesisXaml.Font { uri = AssetDatabase.GetAssetPath(x), font = x }).ToArray();
        xaml.shaders = shaders.Select(x => new NoesisXaml.Shader { uri = AssetDatabase.GetAssetPath(x), shader = x} ).ToArray();

        // Depends on global dictionary
        ctx.DependsOnCustomDependency("Noesis_ApplicationResources");

        ctx.AddObjectToAsset("XAML", xaml);
        ctx.SetMainObject(xaml);
    }

    static bool HasExtension(string filename, string extension)
    {
        return filename.EndsWith(extension, StringComparison.OrdinalIgnoreCase);
    }

    static bool IsFont(string filename)
    {
        return HasExtension(filename, ".ttf") || HasExtension(filename, ".otf") || HasExtension(filename, ".ttc");
    }
}

<UserControl
    x:Class="StellarConquest.Presentation.Unity.UI.ButtonPanelControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
    xmlns:b="http://schemas.microsoft.com/xaml/behaviors"     
    xmlns:local="clr-namespace:StellarConquest.Presentation.Unity.UI"    
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
    d:DesignWidth="1280" d:DesignHeight="720">

    <Grid x:Name="_LayoutRoot" KeyboardNavigation.DirectionalNavigation="Continue" Margin="0, 0, 0, 0" HorizontalAlignment="Center" VerticalAlignment="Center">
        <local:BorderControlBorderless x:Name="_BorderControl" BlurLayer="{DynamicResource BaseBlurSource}">
            <Grid Margin="20" HorizontalAlignment="Center" VerticalAlignment="Center">
                <StackPanel x:Name="_PlayStackPanel1" HorizontalAlignment="Center" VerticalAlignment="Top">
                    <Button x:Name="_PlayButton" Margin="0,0,0,8" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">PLAY</Button>
                    <Button x:Name="_OptionsButton" Margin="0,0,0,8" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">SETTINGS</Button>
                    <Button x:Name="_CreditsButton" Margin="0,0,0,22" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">CREDITS</Button>

                    <Button x:Name="_QuitButton" Margin="0,0,0,0" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">QUIT</Button>
                </StackPanel>
                <StackPanel x:Name="_PlayStackPanel2" HorizontalAlignment="Center" VerticalAlignment="Top" Visibility="Collapsed">
                    <Button x:Name="_ResumeButton" Margin="0,0,0,22" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120" Visibility="Visible">RESUME</Button>

                    <Grid x:Name="_ConquestButtonGrid" Margin="0,0,0,8" Background="Transparent">
                        <Button x:Name="_ConquestButton" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">CONQUEST</Button>
                    </Grid>
                    <Button x:Name="_SurvivalButton" Margin="0,0,0,8" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120" Visibility="Collapsed">SURVIVAL</Button>
                    <Button x:Name="_CreativeButton" Margin="0,0,0,8" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120" Visibility="Collapsed">CREATIVE</Button>
                    <Button x:Name="_DesignerButton" Margin="0,0,0,22" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">DESIGNER</Button>

                    <Button x:Name="_CustomButton" Margin="0,0,0,8" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">NEW GAME</Button>
                    <Button x:Name="_LoadButton" Margin="0,0,0,8" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">LOAD GAME</Button>
                    <Button x:Name="_JoinButton" Margin="0,0,0,22" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">JOIN GAME</Button>

                    <Button x:Name="_LocalizationButton" Margin="0,0,0,22" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120" Visibility="Collapsed">LOCALIZATION</Button>

                    <Button x:Name="_BackButton" Margin="0,0,0,0" Style="{StaticResource DefaultUI.ButtonBlueText}" MinWidth="120">BACK</Button>
                </StackPanel>

            </Grid>
        </local:BorderControlBorderless>
    </Grid>
</UserControl>

using Noesis;
using System;
using System.IO;
using UnityEngine;
using GUI = Noesis.GUI;
using NoesisEventArgs = Noesis.EventArgs;
using SystemEventArgs = System.EventArgs;
using Grid = Noesis.Grid;

namespace StellarConquest.Presentation.Unity.UI
{
    [AssetDependency]
    public partial class ButtonPanelControl : UserControl
    {
        public event EventHandler<SystemEventArgs> PlayButtonClicked;
        public event EventHandler<SystemEventArgs> CreditsButtonClicked;
        public event EventHandler<SystemEventArgs> DesignerButtonClicked;
        public event EventHandler<SystemEventArgs> SettingsButtonClicked;
        public event EventHandler<SystemEventArgs> LocalizationButtonClicked;

        public event EventHandler<SystemEventArgs> ResumeButtonClicked;
        public event EventHandler<SystemEventArgs> ConquestButtonClicked;
        public event EventHandler<SystemEventArgs> SurvivalButtonClicked;
        public event EventHandler<SystemEventArgs> CreativeButtonClicked;

        public event EventHandler<SystemEventArgs> LoadButtonClicked;
        public event EventHandler<SystemEventArgs> JoinButtonClicked;

        public event EventHandler<SystemEventArgs> BackButtonClicked;

        private FrameworkElement _Root;

        private BorderControlBorderless _BorderControl;

        private StackPanel _PlayStackPanel1;
        private Button _PlayButton;
        private Button _OptionsButton;
        private Button _CreditsButton;
        private Button _QuitButton;

        private StackPanel _PlayStackPanel2;
        private Button _ResumeButton;
        private Grid _ConquestButtonGrid;
        private Button _ConquestButton;
        private Button _SurvivalButton;
        private Button _CreativeButton;
        private Button _CustomButton;
        private Button _DesignerButton;
        private Button _LocalizationButton;
        private Button _LoadButton;
        private Button _JoinButton;
        private Button _BackButton;

        private NewsControl _NewsControl;

        public ButtonPanelControl()
        {
            if (!Application.isPlaying)
                return;

            Initialized += OnInitialized;
            InitializeComponent();
        }

        private void InitializeComponent()
        {
            GUI.LoadComponent(this, "Assets/User Interface/Screens/Title/Button Panel/ButtonPanelControl.xaml");
            _Root = Content as FrameworkElement;

            _BorderControl = _Root.FindName(nameof(_BorderControl)) as BorderControlBorderless;

            _PlayStackPanel1 = _Root.FindName(nameof(_PlayStackPanel1)) as StackPanel;
            _PlayButton = _Root.FindName("_PlayButton") as Button;
            _OptionsButton = _Root.FindName("_OptionsButton") as Button;
            _CreditsButton = _Root.FindName("_CreditsButton") as Button;
            _QuitButton = _Root.FindName("_QuitButton") as Button;

            _PlayStackPanel2 = _Root.FindName(nameof(_PlayStackPanel2)) as StackPanel;
            _ResumeButton = _Root.FindName(nameof(_ResumeButton)) as Button;

            _ConquestButtonGrid = _Root.FindName(nameof(_ConquestButtonGrid)) as Grid;
            _ConquestButton = _Root.FindName(nameof(_ConquestButton)) as Button;
            _SurvivalButton = _Root.FindName(nameof(_SurvivalButton)) as Button;
            _CreativeButton = _Root.FindName(nameof(_CreativeButton)) as Button;
            _CustomButton = _Root.FindName(nameof(_CustomButton)) as Button;
            _DesignerButton = _Root.FindName("_DesignerButton") as Button;
            _LocalizationButton = _Root.FindName("_LocalizationButton") as Button;
            _LoadButton = _Root.FindName("_LoadButton") as Button;
            _JoinButton = _Root.FindName("_JoinButton") as Button;

            _BackButton = _Root.FindName(nameof(_BackButton)) as Button;

            if (Application.isConsolePlatform || Application.isMobilePlatform)
                _QuitButton.Visibility = Visibility.Collapsed;

            _ConquestButton.IsEnabled = false;
            _LoadButton.Visibility = Visibility.Collapsed;
        }

        private void OnInitialized(object sender, NoesisEventArgs args)
        {
            _PlayButton.Click += (sender2, e2) =>
            {
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                PlayButtonClicked(sender, SystemEventArgs.Empty);

                if (RuntimeSettings.Instance.IsDeveloperMode)
                    _LocalizationButton.Visibility = Visibility.Visible;
                else
                    _LocalizationButton.Visibility = Visibility.Collapsed;
            };

            _OptionsButton.Click += (sender2, e2) =>
            {
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                SettingsButtonClicked(sender, SystemEventArgs.Empty);
            };

            _CreditsButton.Click += (sender2, e2) =>
            {
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                CreditsButtonClicked(sender, SystemEventArgs.Empty);
            };

            _ResumeButton.MouseEnter += (sender2, e2) =>
            {
                _NewsControl.Update($"Resume game '{PlayerPreferences.Instance.PreviousGameName}'.");
            };

            _ResumeButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                ResumeButtonClicked(sender, SystemEventArgs.Empty);
            };

            _ConquestButtonGrid.MouseEnter += (sender2, e2) =>
            {
                string text =
                    "Join a community of empire builders and [b]CONQUER[/b] an unending universe." + Environment.NewLine + Environment.NewLine +
                    "• Limitless Galaxies" + Environment.NewLine +
                    "• Limitless Players (Internet)" + Environment.NewLine +
                    "• Context-Aware Colonist Dialogue (LLM)";

                if (SessionState.Instance.ServerVersion == null)
                    text += Environment.NewLine + Environment.NewLine + "[i]CONQUEST is down for maintenance and will be back up shortly.[/i]";
                else if (SessionState.Instance.ClientVersion != SessionState.Instance.ServerVersion)
                    text += Environment.NewLine + Environment.NewLine + $"[i]UPDATE to version {SessionState.Instance.ServerVersion} to play CONQUEST.[/i]";

                _NewsControl.Update(text);
            };

            _ConquestButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                ConquestButtonClicked(sender, SystemEventArgs.Empty);
            };

            _SurvivalButton.MouseEnter += (sender2, e2) => _NewsControl.Update(
                "Build an empire alone or with a team of friends witin a single hostile galaxy." + Environment.NewLine + Environment.NewLine +
                "• Single Galaxy" + Environment.NewLine +
                "• 1 to 16 Players (Local or Internet)");

            _SurvivalButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                SurvivalButtonClicked(this, SystemEventArgs.Empty);
            };

            _CreativeButton.MouseEnter += (sender2, e2) => _NewsControl.Update(
                "Construct and manage an empire without the threat of conflict." + Environment.NewLine + Environment.NewLine +
                "• Single Galaxy" + Environment.NewLine +
                "• 1 to 16 Players (Local or Internet)");

            _CreativeButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                CreativeButtonClicked(this, SystemEventArgs.Empty);
            };

            _CustomButton.MouseEnter += (sender2, e2) => _NewsControl.Update(
                "Create a [b]NEW GAME[/b] in [b]SURVIVAL[/b] or [b]CREATIVE[/b] mode." + Environment.NewLine + Environment.NewLine +
                "• Single Galaxy" + Environment.NewLine +
                "• 1 to 32 Players (Local or Internet)");

            _CustomButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                SurvivalButtonClicked(sender, SystemEventArgs.Empty);
            };

            _DesignerButton.MouseEnter += (sender2, e2) => _NewsControl.Update(
                "[b]DESIGN[/b] starship, space station, and building blueprints.");

            _DesignerButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                DesignerButtonClicked(sender, SystemEventArgs.Empty);
            };

            _LocalizationButton.MouseEnter += (sender2, e2) => _NewsControl.Update(
               "[b]LOCALIZE[/b] game content to supported languages.");

            _LocalizationButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                LocalizationButtonClicked(sender, SystemEventArgs.Empty);
            };

            _LoadButton.MouseEnter += (sender2, e2) => _NewsControl.Update("[b]LOAD[/b] an existing game.");

            _LoadButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                LoadButtonClicked(sender, SystemEventArgs.Empty);
            };

            _JoinButton.MouseEnter += (sender2, e2) => _NewsControl.Update(
                "[b]JOIN[/b] an existing game (Local or Internet).");

            _JoinButton.Click += (sender2, e2) =>
            {
                IsHitTestVisible = false;
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                JoinButtonClicked(sender, SystemEventArgs.Empty);
            };

            _BackButton.MouseEnter += (sender2, e2) => _NewsControl.Update(string.Empty);

            _BackButton.Click += (sender2, e2) =>
            {
                SoundEffect.PlayUI(SoundEffects.UserInterface.ButtonClick(), 0.25f);
                BackButtonClicked(this, SystemEventArgs.Empty);

                _PlayStackPanel1.Visibility = Visibility.Visible;
                _PlayStackPanel2.Visibility = Visibility.Collapsed;

                _BorderControl.Resize();
            };

            _QuitButton.Click += (sender2, e2) =>
            {
                Application.Quit();
            };
        }

        public void SetPlayButtonEnabled(bool isEnabled)
        {
            _PlayButton.IsEnabled = isEnabled;
        }

        public void SetPlayButtonText(string text)
        {
            _PlayButton.Content = text;
        }

        public void SetDesignerButtonEnabled(bool isEnabled)
        {
            _DesignerButton.IsEnabled = isEnabled;
        }

        public void SetConquestButtonEnabled(bool isEnabled)
        {
            isEnabled = isEnabled && SessionState.Instance.ClientVersion == SessionState.Instance.ServerVersion;

            _ConquestButton.IsEnabled = isEnabled;
            if (isEnabled && InputManager.Instance != null && InputManager.Instance.HasGamepad)
                _ConquestButton.Focus();
        }

        public void Register(NewsControl newsControl)
        {
            _NewsControl = newsControl;
        }

        public void ShowTitleOptions()
        {
            IsHitTestVisible = true;
            _PlayStackPanel1.Visibility = Visibility.Visible;
            _PlayStackPanel2.Visibility = Visibility.Collapsed;
            _BorderControl.Resize();
        }

        public void ShowPlayOptions()
        {
            IsHitTestVisible = true;
            _PlayStackPanel1.Visibility = Visibility.Collapsed;
            _PlayStackPanel2.Visibility = Visibility.Visible;
            string previousGame = PlayerPreferences.Instance.PreviousGameName;

            if (string.IsNullOrEmpty(previousGame) || !ServerControl.SavedGameExists(previousGame))
                _ResumeButton.Visibility = Visibility.Collapsed;
            else
                _ResumeButton.Visibility = Visibility.Visible;

            DirectoryInfo savedGames = new DirectoryInfo(RuntimeSettings.Instance.SavedGamesPath);
            if (savedGames.Exists && savedGames.GetDirectories().Length > 0)
                _LoadButton.Visibility = Visibility.Visible;
            else
                _LoadButton.Visibility = Visibility.Collapsed;

            _NewsControl.Update("Select Game Type");
            _BorderControl.Resize();
        }
    }
}

<UserControl
    x:Class="StellarConquest.Presentation.Unity.UI.TitleScreen"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="d"
    xmlns:noesis="clr-namespace:NoesisGUIExtensions"
    xmlns:b="http://schemas.microsoft.com/xaml/behaviors" 
    xmlns:local="clr-namespace:StellarConquest.Presentation.Unity.UI"
    d:DesignWidth="1280" d:DesignHeight="720">
    <noesis:Xaml.Dependencies>
        <noesis:Dependency Source="/Assets/User Interface/Screens/Title/License Control/LicenseControl.xaml"/>
        <noesis:Dependency Source="/Assets/User Interface/Screens/Title/Localization Control/LocalizationControl.xaml"/>
        <noesis:Dependency Source="/Assets/User Interface/Screens/Title/Credits Control/CreditsControl.xaml"/>
        <noesis:Dependency Source="/Assets/User Interface/Screens/Title/Credits Control/LicenseAttributionControl.xaml"/>
        <noesis:Dependency Source="/Assets/User Interface/Screens/Title/Server Control/ServerControl.xaml"/>
        <noesis:Dependency Source="/Assets/User Interface/Screens/Title/Server Control/ServerListControl.xaml"/>
    </noesis:Xaml.Dependencies>
    <Grid>
        <Viewbox x:Name="LoginScreenViewBox">
            <local:ViewboxGridControl x:Name="_LayoutRoot">
                <Grid>
                    <Grid>
                        <Grid.RowDefinitions>
                            <RowDefinition Height="1*"/>
                            <RowDefinition Height="6*"/>
                            <RowDefinition Height="1*"/>
                        </Grid.RowDefinitions>

                        <StackPanel x:Name="_LoginStackPanel" Orientation="Horizontal" Grid.Row="1" HorizontalAlignment="Center" VerticalAlignment="Center">
                            <local:ButtonPanelControl x:Name="_ButtonPanelControl" VerticalAlignment="Center" Margin="0, -35, 20, 0"/>

                            <StackPanel x:Name="_NewsStackPanel1" Orientation="Vertical" VerticalAlignment="Center">
                                <local:NewsControl x:Name="_NewsControl1" Margin="0, 0, 0, 20"/>
                                <local:SocialMediaPanelControl x:Name="_SocialMediaPanelControl"/>
                            </StackPanel>

                            <StackPanel x:Name="_NewsStackPanel2" Orientation="Vertical" VerticalAlignment="Center" Visibility="Collapsed">
                                <local:NewsControl x:Name="_NewsControl2" Margin="0, 0, 0, 20"/>
                                <Grid Height="50"/>
                            </StackPanel>
                        </StackPanel>

                        <TextBlock x:Name="_Handle" Grid.Row="2" HorizontalAlignment="Right" FontFamily="{StaticResource Teko}" FontSize="35" VerticalAlignment="Bottom" Foreground="White" Opacity="0.9" Margin="0, 0, 60, 35"/>
                        <TextBlock x:Name="_VersionTextBlock" Grid.Row="2" HorizontalAlignment="Center" FontFamily="{StaticResource Teko}" FontSize="22" VerticalAlignment="Bottom" Foreground="White" Opacity="0.7" Margin="0, 0, 0, 40"/>
                    </Grid>

                    <StackPanel x:Name="_SecondaryScreenStackPanel" HorizontalAlignment="Center" VerticalAlignment="Center"/>



                    <Grid x:Name="_PreviewGrid" Background="Transparent" Opacity="0" Visibility="Collapsed">
                        <Grid Background="#99000000" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>

                        <Grid HorizontalAlignment="Center" VerticalAlignment="Stretch">
                            <Border HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
                                <b:Interaction.Behaviors>
                                    <noesis:BackgroundEffectBehavior Source="{DynamicResource BaseBlurSource}">
                                        <BlurEffect Radius="{Binding Radius, Source={StaticResource TopBlurRadius}}"/>
                                    </noesis:BackgroundEffectBehavior>
                                </b:Interaction.Behaviors>
                            </Border>

                            <Grid Background="#AA000000" HorizontalAlignment="Stretch" VerticalAlignment="Stretch"/>

                            <Rectangle Fill="#66777777" Width="2" HorizontalAlignment="Left" VerticalAlignment="Stretch"/>
                            <Rectangle Fill="#66777777" Width="2" HorizontalAlignment="Right" VerticalAlignment="Stretch"/>

                            <StackPanel Orientation="Vertical" HorizontalAlignment="Center" VerticalAlignment="Center" Margin="50, -50, 50, 50">
                                <Viewbox Width="600" Margin="-10, 0, -10, 15">
                                    <Grid>
                                        <Grid.Effect>
                                            <DropShadowEffect BlurRadius="10" ShadowDepth="3" Opacity="1"/>
                                        </Grid.Effect>
                                        <Image x:Name="_LogoEllipse" Source="{StaticResource ellipse}" Width="550" Stretch="Uniform" Margin="0, 0, 0, 100"/>
                                        <TextBlock x:Name="_LogoText" HorizontalAlignment="Center" FontFamily="{StaticResource Agency}" FontSize="95" VerticalAlignment="Bottom" Margin="0, 0, 0, 0" Foreground="White" Opacity="0.9" noesis:Text.CharacterSpacing="350" Text="STELLAR CONQUEST"/>
                                    </Grid>
                                </Viewbox>

                                <StackPanel Orientation="Vertical" MaxWidth="500" Effect="{StaticResource UIDropShadow}">
                                    <TextBlock FontFamily="{StaticResource Teko}" FontSize="40" FontWeight="Normal" HorizontalAlignment="Center" Margin="0, 0, 0, 95">PREVIEW</TextBlock>
                                    <TextBlock FontFamily="{StaticResource DefaultFontFamily}" FontSize="30" FontWeight="Normal" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" Margin="0, 0, 0, 35">This is an unfinished version of the game. You might encounter broken or missing parts.</TextBlock>
                                    <TextBlock FontFamily="{StaticResource DefaultFontFamily}" FontSize="30" FontWeight="Normal" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" Margin="0, 0, 0, 35">Saved galaxies won't work with the final release version.</TextBlock>
                                    <TextBlock FontFamily="{StaticResource HeadingFontFamily}" FontSize="30" FontWeight="Bold" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" Margin="0, 0, 0, 0">Press any key or button to start</TextBlock>
                                </StackPanel>
                            </StackPanel>
                        </Grid>
                    </Grid>

                </Grid>
            </local:ViewboxGridControl>
        </Viewbox>

    </Grid>
</UserControl>