GenHub

public sealed record ManifestFileEntry(
    string RelativePath,
    string CasHash,
    long FileSize,
    FilePermissionFlags Permissions = FilePermissionFlags.ReadOnly
);

public sealed class ContentManifest
{
    public required ManifestId Id { get; init; }
    public required string DisplayName { get; init; }
    public required ContentType Type { get; init; } // BaseGame, Mod, Patch, Addon, Map
    public required IReadOnlyList<ManifestFileEntry> Files { get; init; }
    public required IReadOnlyList<ManifestId> Dependencies { get; init; }
    public required IReadOnlyList<ManifestId> Incompatibilities { get; init; }
}

public sealed class ContentAddressableStorage(IFileSystem fileSystem, string casRootPath) : ICasStorage
{
    public async Task<Result<string>> StoreBlobAsync(Stream sourceStream, CancellationToken ct = default)
    {
        using var sha256 = SHA256.Create();
        var tempFile = Path.Combine(casRootPath, "temp", Guid.NewGuid().ToString("N"));
        
        fileSystem.CreateDirectory(Path.GetDirectoryName(tempFile)!);
        using (var dest = fileSystem.OpenWrite(tempFile))
        {
            await sourceStream.CopyToAsync(dest, ct);
        }

        var hash = ComputeFileSha256(tempFile);
        var blobPath = GetBlobPath(hash);

        if (!fileSystem.FileExists(blobPath))
        {
            fileSystem.CreateDirectory(Path.GetDirectoryName(blobPath)!);
            fileSystem.MoveFile(tempFile, blobPath);
        }
        else
        {
            fileSystem.DeleteFile(tempFile);
        }

        IncrementReferenceCount(hash);
        return Result<string>.Success(hash);
    }

    public string GetBlobPath(string casHash) =>
        Path.Combine(casRootPath, "objects", casHash[..2], casHash[2..4], casHash[4..]);
}

public interface IActionSet
{
    string Id { get; }
    string Title { get; }
    string Description { get; }
    string Category { get; }
    bool IsCoreFix { get; }
    bool IsCrucialFix { get; }
    Task<bool> IsApplicableAsync(GameInstallation installation, CancellationToken ct = default);
    Task<bool> IsAppliedAsync(GameInstallation installation, CancellationToken ct = default);
    Task<ActionSetResult> ApplyAsync(GameInstallation installation, CancellationToken ct = default);
    Task<ActionSetResult> UndoAsync(GameInstallation installation, CancellationToken ct = default);
}

public class ActionSetOrchestrator(
    IEnumerable<IActionSet> actionSets,
    IEnumerable<IActionSetProvider> providers,
    ILogger<ActionSetOrchestrator> logger) : IActionSetOrchestrator
{
    private readonly IReadOnlyList<IActionSet> _actionSets = InitializeActionSets(actionSets, providers, logger);

    public async Task<IReadOnlyList<IActionSet>> GetApplicableCoreFixesAsync(
        GameInstallation installation, 
        CancellationToken ct = default)
    {
        var applicable = new List<IActionSet>();
        foreach (var actionSet in _actionSets.Where(x => x.IsCoreFix))
        {
            ct.ThrowIfCancellationRequested();
            if (await actionSet.IsApplicableAsync(installation, ct))
            {
                applicable.Add(actionSet);
            }
        }
        return applicable;
    }

    public async Task<OperationResult<int>> ApplyActionSetsAsync(
        GameInstallation installation, 
        IEnumerable<IActionSet> targetSets, 
        CancellationToken ct = default)
    {
        int appliedCount = 0;
        foreach (var actionSet in targetSets)
        {
            var result = await actionSet.ApplyAsync(installation, ct);
            if (result.Success) appliedCount++;
            else if (actionSet.IsCrucialFix)
                return OperationResult<int>.CreateFailure($"Critical fix failed: {result.ErrorMessage}");
        }
        return OperationResult<int>.CreateSuccess(appliedCount);
    }
}

public sealed class WorkspaceReconciler(ILogger<WorkspaceReconciler> logger, IFileOperationsService fileOperations)
{
    public async Task<List<WorkspaceDelta>> AnalyzeWorkspaceDeltaAsync(
        WorkspaceInfo? existingWorkspace,
        WorkspaceConfiguration configuration,
        bool forceFullVerification = false)
    {
        var deltas = new List<WorkspaceDelta>();
        var workspacePath = Path.Combine(configuration.WorkspaceRootPath, configuration.Id);

        var expectedFiles = configuration.Manifests
            .SelectMany(m => m.Files ?? [])
            .Where(f => f.InstallTarget == ContentInstallTarget.Workspace)
            .ToDictionary(f => f.RelativePath, StringComparer.OrdinalIgnoreCase);

        // Fast path: if workspace already matches expected files, skip file operations
        foreach (var (relPath, manifestFile) in expectedFiles)
        {
            var targetPath = Path.Combine(workspacePath, relPath);
            if (!fileOperations.FileExists(targetPath))
            {
                deltas.Add(new WorkspaceDelta(WorkspaceDeltaOperation.Add, relPath, manifestFile));
            }
            else if (forceFullVerification && !await fileOperations.VerifyHashAsync(targetPath, manifestFile.Hash))
            {
                deltas.Add(new WorkspaceDelta(WorkspaceDeltaOperation.Update, relPath, manifestFile));
            }
            else
            {
                deltas.Add(new WorkspaceDelta(WorkspaceDeltaOperation.Skip, relPath, manifestFile));
            }
        }

        return deltas;
    }
}

public sealed class HybridCopySymlinkStrategy(IFileSystem fileSystem, ICasStorage casStorage) : IWorkspaceStrategy
{
    public WorkspaceType Type => WorkspaceType.HybridCopySymlink;

    public async Task<Result> ConstructWorkspaceAsync(
        GameInstallation installation, 
        GameProfile profile, 
        IReadOnlyList<ContentManifest> activeManifests, 
        string targetSandboxDir, 
        CancellationToken ct)
    {
        fileSystem.CreateDirectory(targetSandboxDir);

        // 1. Symlink immutable base game archives (.BIG)
        foreach (var baseFile in fileSystem.GetFiles(installation.RootPath))
        {
            var fileName = Path.GetFileName(baseFile);
            var destPath = Path.Combine(targetSandboxDir, fileName);

            if (fileName.EndsWith(".big", StringComparison.OrdinalIgnoreCase))
            {
                fileSystem.CreateSymbolicLink(destPath, baseFile);
            }
            else
            {
                fileSystem.CopyFile(baseFile, destPath, overwrite: false);
            }
        }

        // 2. Layer active mod manifest files from CAS
        foreach (var manifest in activeManifests)
        {
            foreach (var fileEntry in manifest.Files)
            {
                var blobSource = casStorage.GetBlobPath(fileEntry.CasHash);
                var destPath = Path.Combine(targetSandboxDir, fileEntry.RelativePath);

                fileSystem.CreateDirectory(Path.GetDirectoryName(destPath)!);
                fileSystem.CreateSymbolicLink(destPath, blobSource);
            }
        }

        return Result.Success();
    }
}

public interface IContentDeliveryProvider
{
    string ProviderId { get; }
    Task<Result<IReadOnlyList<RemoteCatalogEntry>>> FetchCatalogAsync(Uri catalogUri, CancellationToken ct);
    Task<Result<Stream>> DownloadContentAsync(RemoteCatalogEntry entry, IProgress<double>? progress, CancellationToken ct);
}

public sealed class CatalogSubscriptionManager(
    IHttpClientFactory clientFactory,
    IContentManifestPool manifestPool,
    ICasStorage casStorage) : ICatalogSubscriptionManager
{
    public async Task<Result<int>> SynchronizeCatalogAsync(CatalogSubscription subscription, CancellationToken ct)
    {
        var client = clientFactory.CreateClient();
        var response = await client.GetAsync(subscription.FeedUrl, ct);
        if (!response.IsSuccessStatusCode)
        {
            return Result<int>.Failure($"Failed to fetch catalog feed from {subscription.FeedUrl}: HTTP {response.StatusCode}");
        }

        var catalogJson = await response.Content.ReadAsStringAsync(ct);
        var catalog = JsonSerializer.Deserialize<CommunityCatalogDto>(catalogJson);
        if (catalog is null) return Result<int>.Failure("Invalid catalog JSON schema.");

        int syncedCount = 0;
        foreach (var manifestDto in catalog.Manifests)
        {
            var manifest = ManifestFactory.CreateFromDto(manifestDto);
            await manifestPool.RegisterManifestAsync(manifest, ct);
            syncedCount++;
        }

        return Result<int>.Success(syncedCount);
    }
}

public sealed class GameLauncher(
    IWorkspaceManager workspaceManager, 
    IGameProcessManager processManager) : IGameLauncher
{
    public async Task<Result<LaunchSession>> LaunchProfileAsync(
        GameProfile profile, 
        GameInstallation installation, 
        CancellationToken ct = default)
    {
        var mutexName = $"Global\\GenHub_Profile_{profile.Id:N}";
        if (!Mutex.TryOpenExisting(mutexName, out _))
        {
            using var mutex = new Mutex(true, mutexName, out var createdNew);
            if (!createdNew) return Result<LaunchSession>.Failure("Profile is already running in another session.");

            // 1. Build isolated workspace sandbox
            var sandboxPath = Path.Combine(Path.GetTempPath(), "GenHub", "Sandboxes", profile.Id.ToString("N"));
            var workspaceResult = await workspaceManager.PrepareSandboxAsync(profile, installation, sandboxPath, ct);
            if (!workspaceResult.IsSuccess) return Result<LaunchSession>.Failure(workspaceResult.Error);

            // 2. Spawn game process with single-core CPU affinity lock
            var executablePath = Path.Combine(sandboxPath, profile.ClientExecutableName);
            var process = processManager.StartProcess(executablePath, profile.CustomArguments);

            // Lock to single physical core (Core 1: 0x02) to prevent SAGE engine timing crashes
            process.ProcessorAffinity = new IntPtr(1 << profile.TargetCpuCore);

            return Result<LaunchSession>.Success(new LaunchSession(process.Id, sandboxPath, profile.Id));
        }

        return Result<LaunchSession>.Failure("Profile execution mutex is locked.");
    }
}