WIn_RustTools/RustTools/App.xaml.cs


using System.Diagnostics;
using System.IO.Compression;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.UI.Xaml;
using Microsoft.Windows.AppLifecycle;
using Newtonsoft.Json;
using RustTools.Activation;
using RustTools.Contracts.Services;
using RustTools.DataList;
using RustTools.Helpers;
using RustTools.Models;
using RustTools.muqing;
using RustTools.Services;
using RustTools.ViewModels;
using RustTools.Views;
using RustTools.WindowUI;
using Windows.ApplicationModel.Activation;
using Windows.Storage;

namespace RustTools;

// To learn more about WinUI 3, see https://docs.microsoft.com/windows/apps/winui/winui3/.
public partial class App : Microsoft.UI.Xaml.Application
{
    // The .NET Generic Host provides dependency injection, configuration, logging, and other services.
    // https://docs.microsoft.com/dotnet/core/extensions/generic-host
    // https://docs.microsoft.com/dotnet/core/extensions/dependency-injection
    // https://docs.microsoft.com/dotnet/core/extensions/configuration
    // https://docs.microsoft.com/dotnet/core/extensions/logging
    public IHost Host
    {
        get;
    }

    public static T GetService<T>()
        where T : class
    {
        if ((App.Current as App)!.Host.Services.GetService(typeof(T)) is not T service)
        {
            throw new ArgumentException($"{typeof(T)} needs to be registered in ConfigureServices within App.xaml.cs.");
        }

        return service;
    }


    public static UIElement? AppTitlebar
    {
        get; set;
    }
    public static WindowEx? MainWindow;

    public App()
    {
        InitializeComponent();
        // 注册激活事件处理程序
        Host = Microsoft.Extensions.Hosting.Host.
        CreateDefaultBuilder().
        UseContentRoot(AppContext.BaseDirectory).
        ConfigureServices((context, services) =>
        {
            // Default Activation Handler
            services.AddTransient<ActivationHandler<Microsoft.UI.Xaml.LaunchActivatedEventArgs>, DefaultActivationHandler>();

            // Other Activation Handlers

            // Services
            services.AddSingleton<ILocalSettingsService, LocalSettingsService>();
            services.AddSingleton<IThemeSelectorService, ThemeSelectorService>();
            services.AddTransient<INavigationViewService, NavigationViewService>();

            services.AddSingleton<IActivationService, ActivationService>();
            services.AddSingleton<IPageService, PageService>();
            services.AddSingleton<INavigationService, NavigationService>();

            // Core Services
            services.AddSingleton<IFileService, FileService>();

            // Views and ViewModels
            services.AddTransient<SettingsViewModel>();
            services.AddTransient<SettingsPage>();

            services.AddTransient<HomePageViewModel>();
            //services.AddTransient<HomePage>();
            services.AddTransient<ConcernViewModel>();
            //services.AddTransient<ConcernPage>();
            services.AddTransient<RankingViewModel>();
            //services.AddTransient<RankingPage>();
            services.AddTransient<UserViewModel>();
            //services.AddTransient<UserPage>();
            //模组碎片
            services.AddTransient<ModuleViewModel>();
            //services.AddTransient<ModulePage>();

            services.AddTransient<CodeTableViewModel>();
            //services.AddTransient<CodeTablePage>();

            services.AddTransient<ShellPage>();
            services.AddTransient<ShellViewModel>();

            // Configuration
            services.Configure<LocalSettingsOptions>(context.Configuration.GetSection(nameof(LocalSettingsOptions)));
        }).
        Build();

        UnhandledException += App_UnhandledException;
        var path = ApplicationData.Current.LocalFolder.Path;
        var v = Path.Combine(path, "CodeTable");
        gj.sc(path);
        if (Directory.Exists(v) == false)
        {
            Directory.CreateDirectory(v);
        }
        var RustCode = Path.Combine(v, "RustCode");
        if (Directory.Exists(RustCode) == false)
        {
            new Thread(() =>
            {
                var zipFilePath = Path.Combine(AppContext.BaseDirectory, "Assets\\RustCode.zip");
                gj.sc(zipFilePath);
                try
                {
                    ZipFile.ExtractToDirectory(zipFilePath, RustCode);
                    var iniHelper = new IniHelper(IniHelper.FILE.Config);
                    iniHelper.SetValue("CodeTable", "Dir", RustCode);
                    iniHelper.Save();
                    var vr = Path.Combine(RustCode, "DataBaseManifest.json");
                    if (File.Exists(vr))
                    {
                        var json = JsonConvert.DeserializeObject<DataBaseManifest>(File.ReadAllText(vr));
                        json.Dir = RustCode;
                        CodeDataPage.codetable = json;
                    }
                    Debug.WriteLine("ZIP文件已成功解压缩并复制到目标目录。");
                }
                catch (FileNotFoundException)
                {
                    Debug.WriteLine("源文件未找到。");
                }
                catch (IOException ex)
                {
                    Debug.WriteLine("发生IO异常: " + ex.Message);
                }
                catch (Exception ex)
                {
                    
                    Debug.WriteLine("发生未知错误: " + ex.Message);
                }
            }).Start();
        }
        else
        {
            var iniHelper = new IniHelper(IniHelper.FILE.Config);
            var v1 = iniHelper.GetValue("CodeTable", "Dir");
            if (string.IsNullOrEmpty(v1)) { v1 = RustCode; }
            var vr = Path.Combine(v1, "DataBaseManifest.json");
            if (File.Exists(vr))
            {
                var json = JsonConvert.DeserializeObject<DataBaseManifest>(File.ReadAllText(vr));
                json.Dir = v1;
                CodeDataPage.codetable = json;
            }
        }
    }

    private void App_UnhandledException(object sender, Microsoft.UI.Xaml.UnhandledExceptionEventArgs e)
    {
        // TODO: Log and handle exceptions as appropriate.
        // https://docs.microsoft.com/windows/windows-app-sdk/api/winrt/microsoft.ui.xaml.application.unhandledexception.
    }


    protected async override void OnLaunched(Microsoft.UI.Xaml.LaunchActivatedEventArgs args)
    {
        base.OnLaunched(args);
        var activatedEventArgs = Microsoft.Windows.AppLifecycle.AppInstance.GetCurrent().GetActivatedEventArgs();
        if (activatedEventArgs.Kind == Microsoft.Windows.AppLifecycle.ExtendedActivationKind.File)
        {
            gj.sc("打开文件");
            if (activatedEventArgs.Kind == ExtendedActivationKind.File)
            {
                if (activatedEventArgs.Data is IFileActivatedEventArgs fileArgs)
                {
                    var files = fileArgs.Files;
                    // 处理打开的文件
                    foreach (var file in files)
                    {
                        var storageFile = file as Windows.Storage.StorageFile;
                        if (storageFile != null)
                        {
                            gj.sc(storageFile.Path);
                            var importModule = new ImportModule(storageFile.Path);
                            importModule.Activate();
                            // 读取或处理文件内容
                        }
                    }
                }
            }
            return;
        }
        var mainInstance = Microsoft.Windows.AppLifecycle.AppInstance.FindOrRegisterForKey("main");
        if (!mainInstance.IsCurrent)
        {
            await mainInstance.RedirectActivationToAsync(activatedEventArgs);
            System.Diagnostics.Process.GetCurrentProcess().Kill();
            return;
        }
        else
        {
            //new Editor.EditorWin().Activate();
            MainWindow = new MainWindow();
            await App.GetService<IActivationService>().ActivateAsync(args);
        }
    }
}