import threading

class TaskAbortedError(Exception):
    """사용자에 의해 태스크가 중단됨을 나타내는 예외"""
    pass

class Executor:
    def __init__(self, config, abort_event=None):
        self.config = config
        self.abort_event = abort_event  # 외부에서 주입
    
    def _check_abort(self):
        """중단 요청 확인 - 각 단계 시작 전 호출"""
        if self.abort_event is not None and self.abort_event.is_set():
            logger.warning('🛑 중단 감지. 실행 중지.')
            raise TaskAbortedError('사용자에 의해 태스크 중단됨.')
    
    def execute_step(self, state):
        self._check_abort()  # 매 단계 시작 전 확인
        # ... 실제 작업 수행 ...
        return result

def __call__(self, task):
    self.resource_manager.setup()
    result = None
    
    try:
        for iteration in range(self.config.max_iterations):
            try:
                result = self.workflow.invoke({...})
                
                if result['decision']:
                    self._handle_success(result)
                    break
                    
            except TaskAbortedError:
                logger.warning(f'Iteration {iteration+1} 사용자에 의해 중단됨.')
                raise  # 상위로 전파
                
            except Exception as e:
                logger.error(f'Iteration {iteration+1} 오류: {e}')
                
    except (KeyboardInterrupt, TaskAbortedError) as e:
        is_abort = isinstance(e, TaskAbortedError)
        logger.warning('🛑 태스크 중단됨.' if is_abort else 'Ctrl+C로 중단됨.')
        
        if result:
            result['final_output'] = '사용자에 의해 중단됨.'
        else:
            result = {'final_output': '첫 반복 완료 전 중단됨.'}
            
    finally:
        # 항상 리소스 정리 - 중단되더라도
        self.resource_manager.clean_up()
        logger.info('🧹 리소스 정리 완료.')
    
    return result

# 멀티스레드 환경에서 외부 컨트롤러가 중단 트리거
class TaskController:
    def __init__(self):
        self.abort_event = threading.Event()
        self.executor = Executor(config, abort_event=self.abort_event)
    
    def run_in_background(self, task):
        def _run():
            try:
                self.result = self.executor(task)
            except Exception as e:
                self.error = e
        
        self.thread = threading.Thread(target=_run)
        self.thread.start()
    
    def abort(self):
        """외부에서 호출하여 실행 중단"""
        self.abort_event.set()
        if self.thread:
            self.thread.join(timeout=10)  # 정리 시간 대기

from fastapi import WebSocket

class TaskSession:
    def __init__(self):
        self.abort_event = threading.Event()
    
    async def handle_websocket(self, websocket: WebSocket):
        await websocket.accept()
        
        # 태스크 시작
        task_thread = threading.Thread(
            target=lambda: self.run_task(websocket)
        )
        task_thread.start()
        
        # 클라이언트 메시지 대기
        while True:
            message = await websocket.receive_json()
            if message.get('type') == 'abort':
                self.abort_event.set()
                await websocket.send_json({'status': 'abort_requested'})
                break

def sample_hypothesis(self, state):
    self._check_abort()  # 노드 진입점에서 확인
    # ... 작업 수행 ...

def verify(self, state):
    self._check_abort()  # 각 노드마다 적용
    # ... 작업 수행 ...