AI 기반 이동형-고정식 통합
수소 충전 네트워크 최적화 플랫폼

# apps/demand_forecaster/services/ensemble_forecaster.py
class H2FlexPredictionEngine:
    """
    H2-Flex AX 수요 예측 엔진 — 3단계 파이프라인
      1단계: Prophet+LSTM 기본 시계열 예측
      2단계: 실시간 대기 큐 보정 (30초 갱신)
      3단계: 이벤트 오버레이 (공사·행사 수요 가산)
    파라미터: FCEV_KG_PER_UNIT = 131.6 (백동현 외 2025)
    """
    FCEV_KG_PER_UNIT = 131.6  # 수소차 1대 연평균 소비량 (논문 기준)

    def predict(self, region_code: str, horizon_hours: int = 24) -> dict:
        # 1단계: 기본 앙상블 예측
        base = self._ensemble_forecast(region_code, horizon_hours)

        # 2단계: 실시간 대기 보정
        queue_adj = self.queue_adjuster.get_adjusted_demand(
            station_id=region_code, base_forecast_kg=base['demand_kg']
        )

        # 3단계: 이벤트 오버레이 (공사·행사)
        event_overlay = self.event_model.get_overlay(region_code, horizon_hours)

        total_demand = (queue_adj['adjusted_demand_kg'] +
                        event_overlay['event_demand_kg'])
        return {
            'total_demand_kg':    total_demand,
            'base_forecast_kg':   base['demand_kg'],
            'queue_demand_kg':    queue_adj['queue_demand_kg'],
            'event_demand_kg':    event_overlay['event_demand_kg'],
            'dispatch_needed':    queue_adj['dispatch_needed'],
            'dispatch_urgency':   queue_adj['dispatch_urgency'],
            'event_dispatch_lead': event_overlay['dispatch_lead_time_h'],
        }

# apps/dsr_optimizer/services/capex_minimizer.py (논문 직접 반영)
class DSRCapexMinimizer:
    """
    논문 백동현 외(2025) 동적 확장판
    핵심 파라미터 (SystemConfig DB에서 관리 → 재훈련 불필요):
      FCEV_KG_PER_UNIT = 131.6  # 수소차 1대 연평균 소비량
      SHRS_ANNUAL_KG   = 40 × 300 × 0.625 = 7,500  kg/년
      MSHRS_ANNUAL_KG  = 50 × 300 × 0.625 = 9,375  kg/년
      DSR_TARGET       = 0.34 (± 0.02)
      SHRS_CAPEX       = 40억원 / 고정식 신설
      MSHRS_CAPEX      = 45억원 / 통합모델 신설
      MRS_ADD_CAPEX    =  7.5억원 / 기존 sHRS 전환 추가분
    목표: 시나리오 A 기준 895억 절감 → 동적 최적화로 추가 절감
    """
    DSR_TARGET    = 0.34
    DSR_TOL       = 0.02
    SCENARIO_A    = {'conversions': 50, 'new_builds': 30}  # 논문 기준선

    def optimize_annual(self, year: int, fcev_count: int,
                          existing_sHRS: int, existing_msHRS: int) -> dict:
        from scipy.optimize import minimize
        annual_demand_kg = fcev_count * 131.6

        result = minimize(
            lambda x: x[0] * 7.5 + x[1] * 45,  # 구축비 최소화
            x0=[30, 20],
            constraints={'type': 'ineq', 'fun': lambda x:
                ((existing_sHRS-x[0])*7500 + (existing_msHRS+x[0]+x[1])*9375)
                / annual_demand_kg - (self.DSR_TARGET - self.DSR_TOL)},
            method='SLSQP', bounds=[(0, existing_sHRS), (0, 200)]
        )
        opt_conv, opt_new = int(result.x[0]), int(result.x[1])
        scenario_a_cost = self.SCENARIO_A['conversions']*7.5 + self.SCENARIO_A['new_builds']*45

        return {
            'year':                 year,
            'optimal_conversions':  opt_conv,   # 기존 sHRS 전환 수
            'optimal_new_builds':   opt_new,    # msHRS 신설 수
            'total_capex_billion':  float(result.fun),
            'vs_scenario_a_saving': scenario_a_cost - float(result.fun),
            'vs_stationary_saving': self._calc_stationary_cost(fcev_count) - float(result.fun),
            'dsr_achieved_pct':     self._calc_dsr(opt_conv, opt_new,
                                                           existing_sHRS, existing_msHRS,
                                                           annual_demand_kg) * 100,
        }

# apps/mobile_router/services/fault_replacer.py — ★NEW (v3 핵심)
from apps.mobile_router.models import MobileUnit, DispatchPlan
from apps.mobile_router.services.vrp_solver import MobileChargingVRPSolver
from django.utils import timezone
from datetime import timedelta

class FaultReplacementRouter:
    """
    고정식 충전소 고장·점검 감지 → 이동형 즉시 대체 경로 생성
    
    트리거:
      - OCPP WebSocket: 충전소 상태 'Faulted' / 'Unavailable' 수신
      - 정기점검 스케줄: 24시간 전 사전 배차 계획 생성
    
    SLA 목표:
      - 고장 감지 → 대체 배차 계획 생성: 5분 이내
      - 이동형 충전소 현장 도착: 2시간 이내
      - 서비스 공백 최소화
    """
    FAULT_RESPONSE_TARGET_MIN  = 5    # 배차 계획 생성 SLA (분)
    ARRIVAL_TARGET_HOURS       = 2    # 현장 도착 목표 (시간)
    MIN_HYDROGEN_LEVEL         = 50   # 투입 가능 최소 수소 잔량 %

    def handle_fault_event(self, station_id: int, fault_type: str) -> dict:
        """
        OCPP Faulted 이벤트 수신 시 즉시 호출
        fault_type: 'FAULT' | 'SCHEDULED_MAINTENANCE' | 'EMERGENCY'
        """
        faulted_station = self._get_station(station_id)
        affected_demand = self._estimate_lost_demand(faulted_station)

        # 최근접 가용 이동형 충전소 탐색 (수소 잔량 50% 이상)
        candidate_units = MobileUnit.objects.filter(
            status__in=['IDLE', 'DISPATCHED'],
            hydrogen_level__gte=self.MIN_HYDROGEN_LEVEL,
        ).annotate(
            dist=    # PostGIS ST_Distance 기준 정렬
        ).order_by('dist')[:3]

        if not candidate_units.exists():
            self._escalate_alert(station_id, 'NO_MOBILE_UNIT_AVAILABLE')
            return {'status': 'ESCALATED', 'reason': 'no_available_unit'}

        best_unit = candidate_units.first()
        eta = timezone.now() + timedelta(hours=self.ARRIVAL_TARGET_HOURS)

        # OR-Tools로 대체 경로 즉시 생성 (30초 이내)
        route = MobileChargingVRPSolver().solve_single_unit(
            unit=best_unit,
            target=faulted_station.location,
            demand_kg=affected_demand,
            time_limit_sec=30
        )

        plan = DispatchPlan.objects.create(
            mobile_unit    = best_unit,
            target_sites   = [station_id],
            route_geom     = route['geometry'],
            estimated_eta  = eta,
            demand_served  = affected_demand,
            dispatch_type  = 'FAULT_REPLACEMENT',  # ★ 대체 배차 구분
            fault_ref_id   = station_id,
            is_active      = True
        )
        best_unit.status = 'DISPATCHED'
        best_unit.save()

        return {
            'status':          'DISPATCHED',
            'unit_id':         best_unit.unit_id,
            'estimated_eta':   eta.isoformat(),
            'demand_covered_kg': affected_demand,
            'route_distance_km': route['total_distance_km'],
            'plan_id':         plan.id,
        }

    def handle_scheduled_maintenance(self, station_id: int,
                                        maintenance_start: str) -> dict:
        """정기점검 24시간 전 사전 배차 계획 생성"""
        pass  # 동일 로직, ETA만 정기점검 시작 시각으로 설정