using Explorer.Application;

namespace Explorer.Application.Tests;

public class BackgroundWorkPolicyTests
{
    private static BackgroundWorkInputs Idle(TimeSpan? idle = null, bool enabled = true, bool ac = true,
        bool acOnly = true, bool foreground = false, bool runNow = false)
        => new(
            enabled,
            TimeSpan.FromMinutes(10),
            idle ?? TimeSpan.FromMinutes(12),
            acOnly,
            ac,
            foreground,
            runNow);

    [Fact]
    public void Below_threshold_stays_active()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle(TimeSpan.FromMinutes(3)));
        Assert.Equal(UserActivityState.Active, decision.Activity);
        Assert.False(decision.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.BelowIdleThreshold, decision.SkipReason);
    }

    [Fact]
    public void Idle_past_threshold_allows_maintenance()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle());
        Assert.Equal(UserActivityState.Idle, decision.Activity);
        Assert.True(decision.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.None, decision.SkipReason);
    }

    [Fact]
    public void Activity_resumes_and_blocks_maintenance()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle(TimeSpan.Zero));
        Assert.Equal(UserActivityState.Active, decision.Activity);
        Assert.False(decision.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.UserActive, decision.SkipReason);
    }

    [Fact]
    public void Foreground_jobs_block_even_when_idle()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle(foreground: true));
        Assert.False(decision.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.ForegroundOperations, decision.SkipReason);
    }

    [Fact]
    public void Disabled_policy_never_allows()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle(enabled: false));
        Assert.False(decision.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.Disabled, decision.SkipReason);
    }

    [Fact]
    public void Ac_only_skips_on_battery()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle(ac: false, acOnly: true));
        Assert.Equal(UserActivityState.Idle, decision.Activity);
        Assert.False(decision.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.OnBattery, decision.SkipReason);
    }

    [Fact]
    public void Ac_only_allows_on_ac()
    {
        var decision = BackgroundWorkPolicy.Evaluate(Idle(ac: true, acOnly: true));
        Assert.True(decision.MaintenanceAllowed);
    }

    [Fact]
    public void Run_now_bypasses_idle_and_battery_but_not_foreground()
    {
        var allowed = BackgroundWorkPolicy.Evaluate(Idle(TimeSpan.Zero, ac: false, runNow: true));
        Assert.True(allowed.MaintenanceAllowed);

        var blocked = BackgroundWorkPolicy.Evaluate(Idle(TimeSpan.Zero, foreground: true, runNow: true));
        Assert.False(blocked.MaintenanceAllowed);
        Assert.Equal(MaintenanceSkipReason.ForegroundOperations, blocked.SkipReason);
    }
}