A コーディング — Protocol 構造的サブタイピング × TypeVar[bound=NotificationChannel] × frozen dataclass slots=True SendResult × StrEnum ChannelType × match 文 × functools.reduce（マルチチャネル通知 Bad→Good Ch2/Ch4/Ch6/Ch7/Ch10/Ch11）

📋 コピー"""notification_dispatcher.py — マルチチャネル通知ディスパッチャ

Ch2:  StrEnum ChannelType / Protocol 構造的サブタイピング
Ch4:  frozen dataclass slots=True SendResult（値オブジェクト）
Ch6:  Protocol + TypeVar[bound=NotificationChannel]（Open/Closed 原則）
Ch7:  名前付き定数（MAX_RETRY_COUNT, DEFAULT_PRIORITY）
Ch10: SendResult.failed_ids で部分失敗を型安全に保持
Ch11: match 文 優先度ラベル / functools.reduce 集計
"""
from __future__ import annotations
import functools, logging
from dataclasses import dataclass
from enum import StrEnum
from typing import Final, Protocol, TypeVar, runtime_checkable
from pydantic import BaseModel, Field

logger = logging.getLogger(__name__)

# ── 名前付き定数（Ch7）
MAX_RETRY_COUNT: Final[int] = 3
DEFAULT_PRIORITY: Final[str] = "medium"

# ── StrEnum（Ch2）
class ChannelType(StrEnum):
    EMAIL = "email"
    PUSH  = "push"
    LINE  = "line"

# ── 入力バリデーション（Pydantic v2）
class NotificationPayload(BaseModel):
    model_config = {"extra": "ignore"}
    campaign_id: str
    recipient_ids: list[str] = Field(min_length=1)  # 空リスト禁止
    message: str = Field(min_length=1)

# ── 値オブジェクト（Ch4）
@dataclass(frozen=True, slots=True)  # frozen: 書き換え禁止 / slots: 軽量化
class SendResult:
    """送信結果のイミュータブル値オブジェクト。"""
    channel_type: ChannelType
    sent_count: int
    success_count: int
    failed_ids: tuple[str, ...]  # tuple: hashable かつ slots 対応

    @property
    def success_rate(self) -> float:
        """成功率（ゼロ除算ガード付き）。"""
        return self.success_count / self.sent_count if self.sent_count else 0.0

    @property
    def failure_count(self) -> int:
        return self.sent_count - self.success_count

# ── Protocol（Ch6 / Ch2）
@runtime_checkable  # isinstance が必要な場合のみ
class NotificationChannel(Protocol):
    """通知チャネルのインターフェース（構造的サブタイピング）。"""
    @property
    def channel_type(self) -> ChannelType: ...
    def send(self, payload: NotificationPayload) -> SendResult: ...

# ── TypeVar（bound で Protocol を制約）
ChannelT = TypeVar("ChannelT", bound=NotificationChannel)

# ── 具体チャネル（Protocol を明示継承しなくてよい）
class EmailChannel:
    @property
    def channel_type(self) -> ChannelType:
        return ChannelType.EMAIL

    def send(self, payload: NotificationPayload) -> SendResult:
        logger.info("[Email] %s: %d 件", payload.campaign_id, len(payload.recipient_ids))
        success_ids = payload.recipient_ids[:90]   # stub: 90% 成功
        failed_ids  = tuple(payload.recipient_ids[90:])
        return SendResult(
            channel_type=ChannelType.EMAIL,
            sent_count=len(payload.recipient_ids),
            success_count=len(success_ids),
            failed_ids=failed_ids,
        )

class PushChannel:
    @property
    def channel_type(self) -> ChannelType:
        return ChannelType.PUSH

    def send(self, payload: NotificationPayload) -> SendResult:
        logger.info("[Push] %s: %d 件", payload.campaign_id, len(payload.recipient_ids))
        success_ids = payload.recipient_ids[:95]   # stub: 95% 成功
        failed_ids  = tuple(payload.recipient_ids[95:])
        return SendResult(
            channel_type=ChannelType.PUSH,
            sent_count=len(payload.recipient_ids),
            success_count=len(success_ids),
            failed_ids=failed_ids,
        )

class LineChannel:
    @property
    def channel_type(self) -> ChannelType:
        return ChannelType.LINE

    def send(self, payload: NotificationPayload) -> SendResult:
        logger.info("[LINE] %s: %d 件", payload.campaign_id, len(payload.recipient_ids))
        success_ids = payload.recipient_ids[:85]   # stub: 85% 成功
        failed_ids  = tuple(payload.recipient_ids[85:])
        return SendResult(
            channel_type=ChannelType.LINE,
            sent_count=len(payload.recipient_ids),
            success_count=len(success_ids),
            failed_ids=failed_ids,
        )

# ── 優先度ラベル（match 文 Ch11）
def priority_label(channel_type: ChannelType) -> str:
    """チャネル種別に応じた優先度ラベルを返す。

    Raises:
        ValueError: 未知チャネル種別。
    """
    match channel_type:
        case ChannelType.EMAIL:
            return "high"    # 開封率重視キャンペーンに最優先
        case ChannelType.PUSH:
            return "medium"
        case ChannelType.LINE:
            return "low"
        case _:
            # 新チャネル追加時のハンドリング漏れを Fail-Fast で検出
            raise ValueError(f"未知チャネル: {channel_type!r}")

# ── 型安全ディスパッチ（TypeVar bound）
def dispatch(channel: ChannelT, payload: NotificationPayload) -> SendResult:
    """Protocol 準拠オブジェクトに send() を委譲する薄いラッパー。"""
    label = priority_label(channel.channel_type)
    logger.debug("ch=%s priority=%s recipients=%d",
                 channel.channel_type, label, len(payload.recipient_ids))
    return channel.send(payload)

# ── 集計（functools.reduce）
def aggregate_results(results: list[SendResult]) -> dict[str, int]:
    """全 SendResult を functools.reduce で集計する。"""
    def merge(acc: dict[str, int], r: SendResult) -> dict[str, int]:
        return {
            "total_sent":    acc["total_sent"]    + r.sent_count,
            "total_success": acc["total_success"] + r.success_count,
            "total_failed":  acc["total_failed"]  + r.failure_count,
        }
    initial: dict[str, int] = {"total_sent": 0, "total_success": 0, "total_failed": 0}
    return functools.reduce(merge, results, initial)

# ── メイン処理
def run_campaign(
    campaign_id: str,
    recipient_ids: list[str],
    message: str,
    channels: list[NotificationChannel],
) -> dict[str, int]:
    """マルチチャネルにキャンペーン通知を送信し集計結果を返す。"""
    payload = NotificationPayload(
        campaign_id=campaign_id,
        recipient_ids=recipient_ids,
        message=message,
    )
    results = [dispatch(ch, payload) for ch in channels]
    for r in results:
        logger.info("ch=%s priority=%s rate=%.1f%% failed=%d",
                    r.channel_type, priority_label(r.channel_type),
                    r.success_rate * 100, r.failure_count)
    return aggregate_results(results)