#!/usr/bin/env python3
"""
短作业优先调度算法 (SJF)
Shortest Job First / Shortest Remaining Time First (SRTF)
"""

from typing import List, Dict

from base import (
    Process,
    ProcessScheduler,
    generate_random_processes,
    print_processes
)


class SJFScheduler(ProcessScheduler):
    """短作业优先调度 (Shortest Job First)"""
    
    def __init__(self, processes: List[Process], preemptive: bool = False):
        super().__init__(processes)
        self.preemptive = preemptive
    
    def schedule(self) -> Dict:
        """SJF 调度算法"""
        if self.preemptive:
            return self.schedule_preemptive()
        return self.schedule_non_preemptive()
    
    def schedule_non_preemptive(self) -> Dict:
        """非抢占式 SJF"""
        processes = sorted(self.processes, key=lambda p: p.arrival_time)
        ready_queue: List[Process] = []
        current_time = 0
        completed = 0
        
        while completed < len(processes):
            for p in processes:
                if p.arrival_time <= current_time and p not in ready_queue and p not in self.results:
                    ready_queue.append(p)
            
            if ready_queue:
                ready_queue.sort(key=lambda p: p.burst_time)
                p = ready_queue.pop(0)
                
                p.start_time = current_time
                current_time += p.burst_time
                self.calculate_metrics(p, current_time)
                self.results.append(p)
                completed += 1
            else:
                current_time += 1
        
        return self.print_results("SJF (短作业优先 - 非抢占)")
    
    def schedule_preemptive(self) -> Dict:
        """抢占式 SJF (SRTF)"""
        processes = sorted(self.processes, key=lambda p: p.arrival_time)
        ready_queue: List[Process] = []
        current_time = 0
        completed = 0
        
        while completed < len(processes):
            for p in processes:
                if p.arrival_time <= current_time and p not in ready_queue and p not in self.results:
                    ready_queue.append(p)
            
            if ready_queue:
                ready_queue.sort(key=lambda p: p.remaining_time)
                p = ready_queue[0]
                
                if p.start_time == -1:
                    p.start_time = current_time
                
                p.remaining_time -= 1
                current_time += 1
                
                if p.remaining_time == 0:
                    self.calculate_metrics(p, current_time)
                    self.results.append(p)
                    ready_queue.remove(p)
                    completed += 1
            else:
                current_time += 1
        
        return self.print_results("SRTF (最短剩余时间优先 - 抢占)")


if __name__ == "__main__":
    processes = generate_random_processes(n=5, seed=42)
    print_processes(processes, "测试数据")
    
    print("\n" + "="*60)
    print("非抢占式 SJF")
    print("="*60)
    scheduler1 = SJFScheduler(processes, preemptive=False)
    scheduler1.schedule()
    
    print("\n" + "="*60)
    print("抢占式 SJF (SRTF)")
    print("="*60)
    scheduler2 = SJFScheduler(processes, preemptive=True)
    scheduler2.schedule()