ADOFAIRenderer/API/RenderSession.cs

using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using ADOFAIRenderer.Core;
using ADOFAIRenderer.Data;
using ADOFAIRenderer.Util;

namespace ADOFAIRenderer.API;

/// <summary>
/// Fluent builder for configuring and starting a render session.
/// </summary>
[SuppressMessage("ReSharper", "UnusedType.Global")]
public class RenderSession
{
    private bool _auto = true;

    /// <summary>
    /// Specifies the types of patches that can be configured for a render session.
    /// </summary>
    public enum PatchType
    {
        /// <summary>
        /// Time-related patch controlling frame timing and clock synchronization.
        /// </summary>
        Time,

        /// <summary>
        /// Screen-related patch controlling screen resolution.
        /// </summary>
        Screen
    }

    private bool _timePatch = true;
    private bool _screenPatch = true;
    private string? _outputPath;

    private bool _notification = true;
    
    private Func<bool>? _endCondition;
    private Action<RenderResult>? _onComplete;

    /// <summary>
    /// Sets whether auto mode is enabled.
    /// </summary>
    /// <param name="enabled"><c>true</c> to enable auto mode; otherwise, <c>false</c>. Default is <c>true</c>.</param>
    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
    public RenderSession WithAuto(bool enabled = true)
    {
        _auto = enabled;
        return this;
    }

    /// <summary>
    /// Sets whether a specific patch type is enabled for the render session.
    /// </summary>
    /// <param name="patchType">The <see cref="PatchType"/> to configure.</param>
    /// <param name="enabled"><c>true</c> to enable the specified patch; otherwise, <c>false</c>. Default is <c>true</c>.</param>
    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
    /// <exception cref="ArgumentOutOfRangeException">Thrown when an unsupported <see cref="PatchType"/> is provided.</exception>
    public RenderSession WithPatch(PatchType patchType, bool enabled = true)
    {
        switch (patchType)
        {
            case PatchType.Time: _timePatch = enabled; break;
            case PatchType.Screen: _screenPatch = enabled; break;
            default: throw new ArgumentOutOfRangeException(nameof(patchType), patchType, null);
        }
        
        return this;
    }

    /// <summary>
    /// Sets the custom condition function that determines when the render session should end.
    /// </summary>
    /// <param name="endCondition">A delegate returning <c>true</c> when the session end condition is met.</param>
    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
    public RenderSession WithEndCondition(Func<bool> endCondition)
    {
        _endCondition = endCondition;
        return this;
    }

    /// <summary>
    /// Sets the custom output path for the rendered file.
    /// </summary>
    /// <param name="outputPath">The file path where the output will be saved, or <c>null</c> to use the default capture directory.</param>
    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
    public RenderSession WithOutputPath(string? outputPath)
    {
        _outputPath = outputPath;
        return this;
    }

    /// <summary>
    /// Sets whether desktop notifications should be displayed when rendering completes.
    /// </summary>
    /// <param name="enabled"><c>true</c> to enable desktop notifications; otherwise, <c>false</c>.</param>
    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
    public RenderSession WithNotification(bool enabled)
    {
        _notification = enabled;
        return this;
    }

    /// <summary>
    /// Adds a callback action to be invoked when the render session completes or fails.
    /// </summary>
    /// <param name="callback">The callback action that receives the resulting <see cref="RenderResult"/>.</param>
    /// <returns>The current <see cref="RenderSession"/> instance for method chaining.</returns>
    public RenderSession OnComplete(Action<RenderResult> callback)
    {
        _onComplete += callback;
        return this;
    }

    /// <summary>
    /// Applies the configured flags and initiates the render session.
    /// </summary>
    /// <param name="renderConfig">The configuration settings for the render session.</param>
    /// <param name="levelPath">The file path of the level to render.</param>
    /// <exception cref="InvalidOperationException">Thrown when the output directory cannot be determined from the output path.</exception>
    public void Start(RenderConfig renderConfig, string levelPath)
    {
        RenderContext.Auto = _auto;
        RenderContext.TimePatch = _timePatch;
        RenderContext.ScreenPatch = _screenPatch;
        RenderContext.OutputPath = _outputPath;
        RenderContext.Notification = _notification;
        
        if (_endCondition is not null) RenderContext.EndCondition = _endCondition;
        if (_onComplete is not null) RenderContext.OnComplete = _onComplete;
        
        RenderManager.Instance.levelPath = levelPath;
        RenderManager.Instance.Configuration = renderConfig;
        
        RenderManager.Instance.StartLoadingOverride();
        
        if (_outputPath is null) RenderManager.Instance.SetupCaptureDirectory();
        else FileUtil.CreateDirectory(Path.GetDirectoryName(_outputPath) ?? throw new InvalidOperationException());
        
        RenderManager.Instance.SetupGameScene();
    }
}