using System;
using System.Threading.Tasks;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using TaskOperate;
using System.Threading;
using System.Diagnostics;

namespace TaskOperateUnitTest
{
    [TestClass]
    public class RunTaskBaseTests
    {
        [TestMethod]
        public async Task StartTask_WhenTaskSucceeds_ReturnsSuccessResult()
        {
            // Arrange
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 100);
                var sw = Stopwatch.StartNew();

                // Act
                var result = await task.StartTask();
                sw.Stop();

                // Assert
                Assert.IsNotNull(result);
                Assert.AreEqual(TaskResultTypes.Success, result.ResultType);
                Assert.AreEqual("测试任务执行成功", result.TaskResult);
                Assert.IsTrue(sw.ElapsedMilliseconds >= 100, "任务执行时间应该至少等于延迟时间");
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WhenCalledMultipleTimes_ShouldExecuteIndependently()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 100);

                // Act
                var result1 = await task.StartTask();
                var result2 = await task.StartTask();

                // Assert
                Assert.AreEqual(TaskResultTypes.Success, result1.ResultType);
                Assert.AreEqual(TaskResultTypes.Success, result2.ResultType);
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WithZeroDelay_ShouldCompleteImmediately()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 0);
                var sw = Stopwatch.StartNew();

                // Act
                var result = await task.StartTask();
                sw.Stop();

                // Assert
                Assert.AreEqual(TaskResultTypes.Success, result.ResultType);
                Assert.IsTrue(sw.ElapsedMilliseconds < 50, "零延迟任务应该几乎立即完成");
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WithNegativeDelay_ShouldHandleGracefully()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: -100);

                // Act
                var result = await task.StartTask();

                // Assert
                Assert.AreEqual(TaskResultTypes.Success, result.ResultType);
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WhenTaskFails_ShouldIncludeDetailedError()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 100, shouldSucceed: false);

                // Act
                var result = await task.StartTask();

                // Assert
                Assert.AreEqual(TaskResultTypes.Failed, result.ResultType);
                Assert.IsNotNull(result.Exception);
                Assert.IsNotNull(result.Exception.Message);
                Assert.IsNotNull(result.Exception.StackTrace);
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WhenTimeoutIsZero_ShouldTimeoutImmediately()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 1000);
                task.SetTimeout(0);

                // Act
                var result = await task.StartTask();

                // Assert
                Assert.AreEqual(TaskResultTypes.Timeout, result.ResultType);
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WhenCancelledMultipleTimes_ShouldHandleGracefully()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 3000);

                // Act
                var taskRun = task.StartTask();
                await Task.Delay(100); // 给任务一些启动时间
                task.RequestCancel();
                task.RequestCancel(); // 重复取消
                var result = await taskRun;

                // Assert
                Assert.AreEqual(TaskResultTypes.Canceled, result.ResultType);
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task StartTask_WhenTimeoutOccurs_ShouldIncludeTimeoutDuration()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 3000);
                task.SetTimeout(500);

                // Act
                var result = await task.StartTask();

                // Assert
                Assert.AreEqual(TaskResultTypes.Timeout, result.ResultType);
                Assert.IsTrue(result.TaskResult.Contains("500"), "超时消息应包含超时时间");
                Assert.IsTrue(result.ExecutionTime >= 500, "执行时间应该至少等于超时时间");
            }
            finally
            {
                task?.Dispose();
            }
        }

        [TestMethod]
        public async Task Dispose_WhenTaskIsRunning_ShouldCleanupResources()
        {
            TestRunTask task = null;
            try
            {
                task = new TestRunTask(delayTime: 5000);
                var taskRun = task.StartTask(); // 开始任务
                await Task.Delay(100); // 给任务一些启动时间

                // Act
                task.Dispose(); // 在任务运行时释放资源

                // Assert - 不应抛出异常
                Assert.IsTrue(true, "Dispose应该正常完成而不抛出异常");

                // 等待任务完成，避免未处理的异常
                try
                {
                    await taskRun;
                }
                catch
                {
                    // 忽略任务取消或失败的异常
                }
            }
            finally
            {
                task?.Dispose();
            }
        }
    }
}