1. Setup The Plagues Protocol

// XRUIOS.Interfaces/IPublicAcc.cs
using MagicOnion;

public interface IPublicAcc : IService<IPublicAcc>
{
    UnaryResult<PublicAccount> GetAccInfo(string accountName);
}

// XRUIOS.Interfaces/PublicAccount.cs
using System.Runtime.Serialization;

[DataContract]
public struct PublicAccount
{
    [DataMember] public string Name;
    [DataMember] public string LastCheck;
    [DataMember] public string OSFolder;

    public PublicAccount(string name, string lastCheck, string osFolder)
    {
        Name = name; LastCheck = lastCheck; OSFolder = osFolder;
    }
}

// Program.cs
using MagicOnion.Server;
using Microsoft.AspNetCore.Server.Kestrel.Core;
using XRUIOS.Windows.PublicAccountDataHandler;

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    options.ListenLocalhost(5000, o => o.Protocols = HttpProtocols.Http2);
    // Later: switch to named pipe → options.ListenNamedPipe("xruios-publicacc");
});

builder.Services.AddHttpContextAccessor();
builder.Services.AddSingleton<Worker>();
builder.Services.AddHostedService<Worker>();
builder.Services.AddMagicOnion();

var app = builder.Build();
app.MapMagicOnionService<PublicAccService>();
app.Run();

// Worker.cs + PublicAccService
using MagicOnion;
using MagicOnion.Server;
using XRUIOS.Interfaces;
using Pariah_Cybersecurity;
using static Pariah_Cybersecurity.EasyPQC;
using System.Diagnostics;

namespace XRUIOS.Windows.PublicAccountDataHandler
{
    public class PublicAccService : ServiceBase<IPublicAcc>, IPublicAcc
    {
        private readonly Worker _worker;
        public PublicAccService(Worker worker) => _worker = worker;
        public async UnaryResult<PublicAccount> GetAccInfo(string accountName)
            => await _worker.GetAccInfo(accountName);
    }

    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly IHttpContextAccessor _httpContext;
        private readonly IServer _server;

        public Worker(ILogger<Worker> logger, IHttpContextAccessor http, IServer server)
        {
            _logger = logger; _httpContext = http; _server = server;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            await Start();
            while (!stoppingToken.IsCancellationRequested)
            {
                _logger.LogInformation("Windows Plague alive: {time}", DateTimeOffset.Now);
                await Task.Delay(1000, stoppingToken);
            }
        }

        public async UnaryResult<PublicAccount> GetAccInfo(string accountName)
        {
            if (!await VerifyIntegrity2())
                throw new Exception("Integrity Check 2 Failed");

            var folder = $@"C:\Users\{accountName}\XRUIOS";
            var lastCheck = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            _logger.LogInformation("[Windows] Served account: {name}", accountName);

            return new PublicAccount(accountName, lastCheck, folder);
        }

        private async Task Start()
        {
            // Optional startup integrity
        }

        private async Task<bool> VerifyIntegrity2()
        {
            try
            {
                string exePath = Process.GetCurrentProcess().MainModule!.FileName;
                byte[] hash;
                using (var fs = new FileStream(exePath, FileMode.Open, FileAccess.Read))
                    hash = await FileOperations.HashFile(fs);

                using (var fs = new FileStream(exePath, FileMode.Open, FileAccess.Read))
                    return await FileOperations.VerifyHash(fs, hash);
            }
            catch { return false; }
        }
    }
}

// XRUIOS.Windows/Accounts.cs
using Grpc.Net.Client;
using MagicOnion.Client;
using XRUIOS.Interfaces;

namespace XRUIOS.Windows
{
    public class Accounts
    {
        public async Task<PublicAccount?> GetAccData(string accountName)
        {
            var addr = Utils.SecureStore.Get<string>("worker_addr") 
                       ?? "https://localhost:5000";
            using var channel = GrpcChannel.ForAddress(addr);
            var client = MagicOnionClient.Create<IPublicAcc>(channel);
            return await client.GetAccInfo(accountName);
        }
    }
}

// XRUIOS.Core/AccountsProvider.cs
using System.Runtime.InteropServices;
using XRUIOS.Interfaces;

#if WINDOWS
using XRUIOS.Windows;
#elif LINUX
using XRUIOS.Linux;
#endif

namespace XRUIOS.Core
{
    public static class AccountsProvider
    {
        public static async Task<PublicAccount> GetPublicAcc(string username)
        {
            return RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
                ? await new Windows.Accounts().GetAccData(username)
                : await new Linux.Accounts().GetAccData(username)
                  ?? throw new Exception("Failed to get account data");
        }
    }
}

using XRUIOS.Core;
using XRUIOS.Interfaces;

var result = await AccountsProvider.GetPublicAcc(Environment.UserName);
Console.WriteLine($"Name: {result.Name}");
Console.WriteLine($"Folder: {result.OSFolder}");
Console.WriteLine($"Checked: {result.LastCheck}");