using Rainbow.Services;
using Xunit;

namespace XUnitTest.Rainbow.Services;

public class UpgradeServiceTests
{
    [Fact(DisplayName = "UpgradeService_默认构造_读取当前版本")]
    public void DefaultCtor_ReadsVersion()
    {
        var svc = new UpgradeService();

        Assert.NotNull(svc.CurrentVersion);
        Assert.NotEmpty(svc.CurrentVersion);
        Assert.Equal(UpgradeStatus.Idle, svc.Status);
        Assert.Equal("https://github.com/NewLifeX/Rainbow/releases", svc.Server);
        Assert.Equal("Release", svc.Channel);
    }

    [Fact(DisplayName = "UpgradeService_自定义更新目录")]
    public void CustomUpdateDir()
    {
        var svc = new UpgradeService("CustomUpdate");

        Assert.NotNull(svc.CurrentVersion);
    }

    [Fact(DisplayName = "UpgradeService_Server可自定义")]
    public void Server_CanBeCustomized()
    {
        var svc = new UpgradeService
        {
            Server = "https://example.com/updates",
            Channel = "Beta"
        };

        Assert.Equal("https://example.com/updates", svc.Server);
        Assert.Equal("Beta", svc.Channel);
    }

    [Fact(DisplayName = "UpgradeService_未检查时LatestVersion为空")]
    public void LatestVersion_NullBeforeCheck()
    {
        var svc = new UpgradeService();

        Assert.Null(svc.LatestVersion);
        Assert.Equal(default, svc.LastCheck);
    }

    [Fact(DisplayName = "UpgradeService_正在下载时检查更新抛异常")]
    public async Task CheckAsync_ThrowsWhenDownloading()
    {
        var svc = new UpgradeService();
        svc.Status = UpgradeStatus.Downloading;

        await Assert.ThrowsAsync<InvalidOperationException>(() => svc.CheckAsync());
    }

    [Fact(DisplayName = "UpgradeService_正在安装时检查更新抛异常")]
    public async Task CheckAsync_ThrowsWhenInstalling()
    {
        var svc = new UpgradeService();
        svc.Status = UpgradeStatus.Installing;

        await Assert.ThrowsAsync<InvalidOperationException>(() => svc.CheckAsync());
    }

    [Fact(DisplayName = "UpgradeService_未检查就安装抛异常")]
    public async Task InstallAsync_ThrowsWithoutCheck()
    {
        var svc = new UpgradeService();

        await Assert.ThrowsAsync<InvalidOperationException>(() => svc.InstallAsync());
    }

    [Fact(DisplayName = "UpgradeService_LastCheck在CheckAsync后更新")]
    public async Task CheckAsync_UpdatesLastCheck()
    {
        var svc = new UpgradeService();

        try
        {
            await svc.CheckAsync();
        }
        catch
        {
            // 网络不通时忽略异常，只验证 LastCheck 已更新
        }

        // 即使检查失败（网络不通），LastCheck 也应更新（在方法开始时设置）
        Assert.NotEqual(default, svc.LastCheck);
    }
}

public class UpgradeCheckResultTests
{
    [Fact(DisplayName = "UpgradeCheckResult_默认值")]
    public void Defaults()
    {
        var result = new UpgradeCheckResult();

        Assert.False(result.HasUpdate);
        Assert.Equal("", result.CurrentVersion);
        Assert.Null(result.LatestVersion);
    }

    [Fact(DisplayName = "UpgradeCheckResult_有新版本")]
    public void HasUpdate_True()
    {
        var result = new UpgradeCheckResult
        {
            HasUpdate = true,
            CurrentVersion = "1.0.0",
            LatestVersion = "2.0.0",
            FileName = "Rainbow_v2.0.0.zip"
        };

        Assert.True(result.HasUpdate);
        Assert.Equal("1.0.0", result.CurrentVersion);
        Assert.Equal("2.0.0", result.LatestVersion);
        Assert.Equal("Rainbow_v2.0.0.zip", result.FileName);
    }
}

public class UpgradeInstallResultTests
{
    [Fact(DisplayName = "UpgradeInstallResult_默认值")]
    public void Defaults()
    {
        var result = new UpgradeInstallResult();

        Assert.False(result.Success);
        Assert.Null(result.Message);
        Assert.False(result.NeedRestart);
    }

    [Fact(DisplayName = "UpgradeInstallResult_成功")]
    public void Success()
    {
        var result = new UpgradeInstallResult
        {
            Success = true,
            Message = "更新安装完成",
            NeedRestart = true
        };

        Assert.True(result.Success);
        Assert.Equal("更新安装完成", result.Message);
        Assert.True(result.NeedRestart);
    }
}

public class UpgradeStatusTests
{
    [Fact(DisplayName = "UpgradeStatus_枚举值")]
    public void EnumValues()
    {
        Assert.Equal(0, (Int32)UpgradeStatus.Idle);
        Assert.Equal(1, (Int32)UpgradeStatus.Checking);
        Assert.Equal(2, (Int32)UpgradeStatus.Downloading);
        Assert.Equal(3, (Int32)UpgradeStatus.Installing);
        Assert.Equal(4, (Int32)UpgradeStatus.Failed);
    }
}