video-pc/AvPlayer2/interfaces/IThreadPool.h

#ifndef ITHREADPOOL_H
#define ITHREADPOOL_H

#include <functional>
#include <memory>
#include <future>
#include <chrono>
#include <string>

namespace AVPlayer2 {
namespace Core {

/**
 * 线程池状态枚举
 */
enum class ThreadPoolState {
    Stopped,    // 停止状态
    Running,    // 运行状态
    Stopping    // 正在停止
};

/**
 * 任务优先级枚举
 */
enum class TaskPriority {
    Low,        // 低优先级
    Normal,     // 普通优先级
    High,       // 高优先级
    Critical    // 关键优先级
};

/**
 * 任务状态枚举
 */
enum class TaskState {
    Pending,    // 等待执行
    Running,    // 正在执行
    Completed,  // 已完成
    Cancelled,  // 已取消
    Failed      // 执行失败
};

} // namespace Core

namespace Types {

/**
 * 任务信息
 */
struct TaskInfo {
    std::string taskId;                     // 任务ID
    std::string taskName;                   // 任务名称
    Core::TaskPriority priority;            // 任务优先级
    Core::TaskState state;                  // 任务状态
    std::chrono::system_clock::time_point createTime;  // 创建时间
    std::chrono::system_clock::time_point startTime;   // 开始时间
    std::chrono::system_clock::time_point endTime;     // 结束时间
    std::string threadId;                   // 执行线程ID
    std::string errorMessage;               // 错误信息
    
    TaskInfo() {
        priority = Core::TaskPriority::Normal;
        state = Core::TaskState::Pending;
        createTime = std::chrono::system_clock::now();
    }
};

/**
 * 线程池统计信息
 */
struct ThreadPoolStats {
    int totalThreads;           // 总线程数
    int activeThreads;          // 活跃线程数
    int idleThreads;            // 空闲线程数
    int pendingTasks;           // 等待任务数
    int completedTasks;         // 已完成任务数
    int failedTasks;            // 失败任务数
    double averageTaskTime;     // 平均任务执行时间（毫秒）
    double threadUtilization;   // 线程利用率（0.0-1.0）
    
    ThreadPoolStats() {
        totalThreads = 0;
        activeThreads = 0;
        idleThreads = 0;
        pendingTasks = 0;
        completedTasks = 0;
        failedTasks = 0;
        averageTaskTime = 0.0;
        threadUtilization = 0.0;
    }
};

/**
 * 线程池配置
 */
struct ThreadPoolConfig {
    int minThreads;             // 最小线程数
    int maxThreads;             // 最大线程数
    int maxQueueSize;           // 最大队列大小
    std::chrono::milliseconds keepAliveTime;   // 线程保活时间
    bool allowCoreThreadTimeout;               // 是否允许核心线程超时
    std::string threadNamePrefix;              // 线程名称前缀
    
    ThreadPoolConfig() {
        minThreads = 2;
        maxThreads = 8;
        maxQueueSize = 100;
        keepAliveTime = std::chrono::milliseconds(60000);
        allowCoreThreadTimeout = false;
        threadNamePrefix = "AVPlayer2-Thread-";
    }
};

} // namespace Types

namespace Core {

/**
 * 线程池抽象接口
 * 提供与平台无关的线程池功能
 */
class IThreadPool {
public:
    virtual ~IThreadPool() = default;

    /**
     * 初始化线程池
     * @param config 线程池配置
     * @return 是否初始化成功
     */
    virtual bool initialize(const Types::ThreadPoolConfig& config) = 0;

    /**
     * 启动线程池
     * @return 是否启动成功
     */
    virtual bool start() = 0;

    /**
     * 停止线程池
     * @param waitForCompletion 是否等待所有任务完成
     */
    virtual void stop(bool waitForCompletion = true) = 0;

    /**
     * 提交任务（无返回值）
     * @param task 任务函数
     * @param priority 任务优先级
     * @param taskName 任务名称
     * @return 任务ID
     */
    virtual std::string submitTask(std::function<void()> task, 
                                   TaskPriority priority = TaskPriority::Normal,
                                   const std::string& taskName = "") = 0;

    /**
     * 提交任务（有返回值）
     * @param task 任务函数
     * @param priority 任务优先级
     * @param taskName 任务名称
     * @return 任务结果的future对象
     */
    template<typename F, typename... Args>
    auto submitTaskWithResult(F&& task, TaskPriority priority = TaskPriority::Normal,
                              const std::string& taskName = "") 
        -> std::future<typename std::result_of<F(Args...)>::type> {
        using ReturnType = typename std::result_of<F(Args...)>::type;
        
        auto taskPtr = std::make_shared<std::packaged_task<ReturnType()>>(
            std::bind(std::forward<F>(task))
        );
        
        std::future<ReturnType> result = taskPtr->get_future();
        
        submitTask([taskPtr](){ (*taskPtr)(); }, priority, taskName);
        
        return result;
    }

    /**
     * 取消任务
     * @param taskId 任务ID
     * @return 是否取消成功
     */
    virtual bool cancelTask(const std::string& taskId) = 0;

    /**
     * 等待任务完成
     * @param taskId 任务ID
     * @param timeout 超时时间（毫秒，-1表示无限等待）
     * @return 是否在超时前完成
     */
    virtual bool waitForTask(const std::string& taskId, int timeout = -1) = 0;

    /**
     * 等待所有任务完成
     * @param timeout 超时时间（毫秒，-1表示无限等待）
     * @return 是否在超时前完成
     */
    virtual bool waitForAllTasks(int timeout = -1) = 0;

    /**
     * 获取任务信息
     * @param taskId 任务ID
     * @return 任务信息
     */
    virtual Types::TaskInfo getTaskInfo(const std::string& taskId) = 0;

    /**
     * 获取线程池状态
     * @return 线程池状态
     */
    virtual ThreadPoolState getState() const = 0;

    /**
     * 获取线程池统计信息
     * @return 统计信息
     */
    virtual Types::ThreadPoolStats getStats() const = 0;

    /**
     * 调整线程池大小
     * @param newSize 新的线程数
     * @return 是否调整成功
     */
    virtual bool resize(int newSize) = 0;

    /**
     * 清空任务队列
     * @return 被清空的任务数
     */
    virtual int clearQueue() = 0;

    /**
     * 设置任务完成回调
     * @param callback 任务完成回调函数
     */
    virtual void setTaskCompletedCallback(
        std::function<void(const std::string&, TaskState)> callback) = 0;

    /**
     * 设置线程池状态变化回调
     * @param callback 状态变化回调函数
     */
    virtual void setStateChangedCallback(
        std::function<void(ThreadPoolState)> callback) = 0;

    /**
     * 设置错误回调
     * @param callback 错误回调函数
     */
    virtual void setErrorCallback(
        std::function<void(const std::string&, const std::string&)> callback) = 0;
};

/**
 * 线程池工厂接口
 */
class IThreadPoolFactory {
public:
    virtual ~IThreadPoolFactory() = default;

    /**
     * 创建线程池实例
     * @param name 线程池名称
     * @return 线程池智能指针
     */
    virtual std::unique_ptr<IThreadPool> createThreadPool(const std::string& name = "") = 0;

    /**
     * 获取默认线程池配置
     * @return 默认配置
     */
    virtual Types::ThreadPoolConfig getDefaultConfig() = 0;

    /**
     * 获取推荐的线程数
     * @return 推荐线程数
     */
    virtual int getRecommendedThreadCount() = 0;
};

} // namespace Core
} // namespace AVPlayer2

#endif // ITHREADPOOL_H