# core/intraday_stock_manager.py (기존)
batch_size = 20  # 고정!
await asyncio.sleep(0.2)  # 고정!

for i in range(0, len(stock_codes), batch_size):
    batch = stock_codes[i:i + batch_size]

    # 각 종목당 2개 API 호출 (분봉 + 현재가)
    minute_tasks = [self.update_realtime_data(code) for code in batch]
    price_tasks = [self._update_current_price_data(code) for code in batch]

    # 병렬 실행
    await asyncio.gather(*minute_tasks, *price_tasks)

    await asyncio.sleep(0.2)  # 다음 배치까지 200ms

batch_size = 10  # 20 → 10으로 줄임

await asyncio.sleep(1.0)  # 0.2초 → 1.0초

batch_size = 5
await asyncio.sleep(0.5)

# 종목 수에 따라 자동으로 계산
batch_size, delay = calculate_optimal(total_stocks)

# core/dynamic_batch_calculator.py
class DynamicBatchCalculator:
    """한국투자증권 API(KIS API) 제약 조건 하에서 종목 수에 따른 최적 배치 계산
    
    KIS API Rate Limit: 초당 20개 호출 제한
    """

    API_LIMIT_PER_SECOND = 20  # 한국투자증권 KIS API: 초당 20개 제한
    TARGET_UPDATE_TIME = 10    # 목표 10초
    APIS_PER_STOCK = 2         # 종목당 2개 API (분봉 + 현재가)

    def calculate_optimal_batch(self, total_stocks: int):
        """최적 배치 크기와 지연 시간 계산"""

        if total_stocks <= 10:
            # 소량: 빠른 처리
            return 10, 0.2

        elif total_stocks <= 30:
            # 중량: 중간 처리
            return 10, 0.5

        elif total_stocks <= 50:
            # 다량: 안전 처리
            return 8, 0.8

        else:
            # 대량 (50개 이상): 동적 계산
            # 70개 × 2 API = 140개
            # 140개 ÷ 20개/초 = 7초 필요
            # 배치 크기 10개 → 7개 배치
            # 7초 ÷ 7배치 = 1.0초 지연

            safe_per_second = 20
            total_apis = total_stocks * 2

            # 필요한 최소 시간
            min_time_needed = total_apis / safe_per_second

            # 배치 크기 결정
            batch_size = 10
            num_batches = (total_stocks + batch_size - 1) // batch_size

            # 배치당 지연 시간
            batch_delay = min_time_needed / num_batches
            batch_delay = max(0.5, batch_delay)  # 최소 0.5초

            return batch_size, batch_delay

# core/intraday_stock_manager.py (수정)
class IntradayStockManager:
    def __init__(self):
        # 🆕 동적 배치 계산기 추가
        self.batch_calculator = DynamicBatchCalculator()

    async def batch_update_realtime_data(self):
        """모든 종목 실시간 데이터 업데이트"""

        stock_codes = list(self.selected_stocks.keys())
        total_stocks = len(stock_codes)

        # 🆕 동적 배치 크기 계산
        batch_size, batch_delay = self.batch_calculator.calculate_optimal_batch(
            total_stocks
        )

        self.logger.info(
            f"📊 동적 배치: {total_stocks}개 종목 → "
            f"배치 {batch_size}개 × 지연 {batch_delay:.2f}초"
        )

        # 배치 처리
        for i in range(0, len(stock_codes), batch_size):
            batch = stock_codes[i:i + batch_size]

            # 분봉 + 현재가 동시 업데이트
            minute_tasks = [self.update_realtime_data(code) for code in batch]
            price_tasks = [self._update_current_price_data(code) for code in batch]

            await asyncio.gather(*minute_tasks, *price_tasks)

            # 🆕 동적 지연 시간 적용
            if i + batch_size < len(stock_codes):
                await asyncio.sleep(batch_delay)

# test_dynamic_batch.py
calc = DynamicBatchCalculator()

test_cases = [10, 30, 50, 70, 80, 100]

for stock_count in test_cases:
    batch_size, batch_delay = calc.calculate_optimal_batch(stock_count)
    estimated_time = calc.get_estimated_time(stock_count, batch_size, batch_delay)
    api_speed = calc.get_estimated_calls_per_second(batch_size, batch_delay)

    print(f"{stock_count}개: 배치 {batch_size}, "
          f"지연 {batch_delay:.2f}초, "
          f"완료 {estimated_time:.1f}초, "
          f"속도 {api_speed:.1f}개/초")

# ❌ 나쁜 예: 고정값
BATCH_SIZE = 20  # 항상 20?

# ✅ 좋은 예: 계산값
batch_size = calculate_optimal(current_stocks)