// 线程控制块结构体
typedef struct {
    jmp_buf context;    // 线程执行上下文
    void (*func)(void*); // 线程执行函数
    void* arg;          // 线程参数
    ThreadState state;  // 线程当前状态
    char* stack;        // 线程栈空间指针
    int id;             // 线程ID
} Thread;

typedef struct {
    ucontext_t context;    // 保存了线程的完整执行上下文(寄存器, 栈指针, 信号掩码等)
    ThreadState state;    // 当前线程的状态
    char* stack;        // 指向为该线程分配的栈空间的指针
} Thread;

// 线程状态枚举: 用于描述一个线程当前所处的生命周期阶段
typedef enum {
    READY,            // 就绪状态: 线程已准备好, 等待调度器分配CPU时间
    RUNNING,        // 运行状态: 线程当前正在CPU上执行
    TERMINATED        // 终止状态: 线程已经执行完毕
} ThreadState;

// 阻塞定时器信号: 用于保护临界区代码,防止在执行敏感操作时被定时器中断
static void block_timer() {
    sigset_t set;                    // 定义一个信号集
    sigemptyset(&set);                    // 清空信号集
    sigaddset(&set, SIGALRM);                // 将定时器信号(SIGALRM)加入集合
    sigprocmask(SIG_BLOCK, &set, NULL);        // 调用sigprocmask阻塞该信号
}

// 解除定时器信号阻塞: 在离开临界区后,恢复定时器信号
static void unblock_timer() {
    sigset_t set;                        // 定义一个信号集
    sigemptyset(&set);                    // 清空信号集
    sigaddset(&set, SIGALRM);                // 将定时器信号(SIGALRM)加入集合
    sigprocmask(SIG_UNBLOCK, &set, NULL);        // 调用sigprocmask解除对该信号的阻塞
}

//线程运行的函数封装
void thread_wrapper(void (*func)(void*), void* arg) {
    unblock_timer(); // 新线程开始执行,解除信号阻塞,允许被抢占
    func(arg);       // 执行用户传入的实际线程函数
    block_timer();   // 线程函数执行完毕,进入临界区
    threads[current_thread].state = TERMINATED; // 将自身状态标记为"终止"

} 

// 创建一个新线程
int thread_create(void (*func)(void*), void* arg) {
    block_timer(); // 进入临界区,防止在创建过程中被中断
    if (thread_count >= MAX_THREADS) { // 检查是否达到线程数上限
        unblock_timer(); // 解除阻塞
        return -1;                // 返回错误
    }

    int tid = thread_count++; // 分配一个新的线程ID,并增加线程总数
    threads[tid].stack = malloc(STACK_SIZE); // 为新线程的栈分配内存
    if (!threads[tid].stack) { // 检查内存分配是否成功
        thread_count--;    // 分配失败,撤销线程计数
        unblock_timer();   // 解除阻塞
        return -1;            // 返回错误
    }

    // 核心步骤: 初始化新线程的上下文
    getcontext(&threads[tid].context); // 1. 获取一个当前上下文作为模板
    threads[tid].context.uc_stack.ss_sp = threads[tid].stack;        // 2. 设置新线程的栈指针
    threads[tid].context.uc_stack.ss_size = STACK_SIZE;        // 3. 设置新线程的栈大小
    threads[tid].context.uc_link = &main_scheduler_context;        // 4. 设置后继上下文:当线程函数返回时,会自动切换到此上下文
    threads[tid].state = READY;    // 5. 将新线程的状态设置为"就绪"

    // 核心步骤: 修改上下文,使其从thread_wrapper函数开始执行
    makecontext(&threads[tid].context, (void (*)(void))thread_wrapper, 2, func, arg);

    unblock_timer(); // 离开临界区
    return tid;            // 返回新创建的线程ID
}

//调度器: 决定下一个应该运行哪个线程
void schedule() {
    block_timer(); // 进入临界区

    int prev_thread = current_thread;    // 记录即将被换出的线程
    if (threads[prev_thread].state == RUNNING) {    // 如果它还在运行(而不是阻塞或终止)
        threads[prev_thread].state = READY;        // 则将其状态变更为"就绪"
    }

    int next_thread = -1;    // 准备寻找下一个可运行的线程
    while(next_thread == -1) {    // 持续寻找直到找到或确认无线程可运行
        int all_done = 1;    // 假设所有工作线程都已完成
        for (int i = 1; i < thread_count; i++) {    // 遍历所有工作线程(0号是主线程)
            if (threads[i].state != TERMINATED) {    // 如果发现任何一个没结束
                all_done = 0;            // 推翻假设
                break;                // 无需再检查
            }
        }
        if (all_done) {    // 如果所有工作线程真的都结束了
             unblock_timer(); // 解除阻塞
             // 通过 setcontext 直接跳转回 main 函数的循环, 而不是通过 swapcontext
             // 因为当前线程(通常是main)还要继续执行join, 而不是切换出去
             setcontext(&threads[0].context);
             return;
        }

        // 轮询算法: 从当前线程之后开始,查找下一个处于READY状态的线程
        for (int i = 1; i <= thread_count; i++) {
            int tid = (current_thread + i) % thread_count;
            if (threads[tid].state == READY) {
                next_thread = tid;    // 找到
                break;
            }
        }

        if (next_thread == -1) {
            // 如果没找到可运行的线程,但又不是所有线程都结束,说明可能发生死锁或都在等待
            // 在这个简单的库里,我们直接返回,等待下一次定时器中断再来调度
            unblock_timer();
            return;    
        }
    }

    current_thread = next_thread;    // 更新当前运行线程的ID
    threads[current_thread].state = RUNNING;    // 更新其状态为"运行"

    unblock_timer(); // 准备切换,解除阻塞
    // 核心: 原子地保存当前上下文到prev_thread,并切换到next_thread的上下文
    //thread_wrapper 只在 swapcontext 函数执行之后才开始运行
    swapcontext(&threads[prev_thread].context, &threads[current_thread].context);
}

// 等待一个线程结束 (阻塞)
void thread_join(int tid) {
    if (tid < 0 || tid >= thread_count) return;    // 无效ID则直接返回
    while (threads[tid].state != TERMINATED) {    // 只要目标线程还没结束
        schedule();                    // 就调用调度器,把CPU让给其他线程
    }
    block_timer(); // 目标线程已结束,进入临界区
    free(threads[tid].stack);            // 释放其栈空间
    threads[tid].stack = NULL;            // 指针置空,防止野指针
    unblock_timer(); // 离开临界区
}

// 定时器中断处理函数
void timer_handler(int signum) {
    (void)signum;    // 避免编译器关于未使用参数的警告
    schedule();        // 定时器触发,强制调用调度器进行抢占
}

// 初始化线程库
void uthread_init() {
    // 将当前执行流(main函数)初始化为0号线程
    getcontext(&threads[0].context);
    threads[0].state = RUNNING;
    threads[0].stack = NULL;    // 主线程使用进程默认的栈,无需单独分配

    // 设置信号处理
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = timer_handler;    // 指定SIGALRM信号的处理函数
    sigaction(SIGALRM, &sa, NULL);

    // 设置定时器,每10毫秒触发一次SIGALRM信号
    struct itimerval timer;
    timer.it_value.tv_sec = 0;
    timer.it_value.tv_usec = 10000;    // 首次触发时间
    timer.it_interval.tv_sec = 0;
    timer.it_interval.tv_usec = 10000;    // 后续触发间隔
    setitimer(ITIMER_REAL, &timer, NULL);
}

// 一个示例线程函数
void sample_thread_func(void* arg) {
    int id = *(int*)arg;    // 获取传入的参数
    for (int i = 0; i < 5; ++i) {
        printf("Thread %d says: %d\n", id, i);
        // 执行一个耗时循环,以模拟真实工作,并清晰地展示抢占式调度效果
        volatile unsigned long long k = 0;
        for (unsigned long long j = 0; j < 100000000; ++j) { k++; }
    }
    printf("Thread %d finished.\n", id);
    free(arg);        // 释放传入的参数内存
}

// 主函数
int main() {
    printf("Main: Initializing user-level thread library with ucontext.\n");
    uthread_init();    // 初始化线程库

    // 在此保存一个特殊的上下文,作为所有子线程结束后的“返回点”
    getcontext(&main_scheduler_context);

    printf("Main: Creating threads.\n");
    int* tid1 = malloc(sizeof(int)); *tid1 = 1;    // 为线程参数分配内存
    int* tid2 = malloc(sizeof(int)); *tid2 = 2;
    int t1_id = thread_create(sample_thread_func, tid1);    // 创建1号线程
    int t2_id = thread_create(sample_thread_func, tid2);    // 创建2号线程

    // 等待线程结束
    thread_join(t1_id);
    printf("Main: Joined thread %d.\n", t1_id);
    thread_join(t2_id);
    printf("Main: Joined thread %d.\n", t2_id);

    printf("Main: All threads finished. Exiting.\n");

    return 0;
}

// 互斥锁结构体
typedef struct {
    atomic_int locked;          // 原子锁标志
    int blocking_threads[MAX_THREADS]; // 阻塞在该锁上的线程数组
    int count;                  // 阻塞线程计数
} Mutex;

// 创建互斥锁
Mutex mutex_create() {
    Mutex m;
    atomic_init(&m.locked, 0);  // 初始化为未锁定状态
    m.count = 0;                // 初始化阻塞线程数为0
    return m;
}

// 获取互斥锁
void mutex_lock(Mutex* m) {
    // 使用原子交换尝试获取锁
    while (atomic_exchange(&m->locked, 1)) {
        // 如果获取失败，将当前线程加入阻塞队列
        m->blocking_threads[m->count++] = current_thread;
        threads[current_thread].state = BLOCKED;
        // 主动让出CPU
        longjmp(threads[current_thread].context, 1);
    }
}

// 释放互斥锁
void mutex_unlock(Mutex* m) {
    atomic_store(&m->locked, 0);  // 原子操作释放锁
    // 唤醒所有阻塞在该锁上的线程
    for (int i = 0; i < m->count; i++) {
        int tid = m->blocking_threads[i];
        if (threads[tid].state == BLOCKED) {
            threads[tid].state = READY;
        }
    }
    m->count = 0;  // 重置阻塞线程计数
}