#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Claude-Level Coding Excellence 日本語版 生成器
===============================================
Claude (Fable-5) レベルのコーディング性能を目指すための
超高品質コード生成データセット。

通常版との違い：
  - CoT 平均長 7,000文字（通常版の約2倍）
  - 多段階推論：問題再定義 → 複数アプローチ比較 → 深掘り → 実装 → 検証
  - 自己対話・自己修正：「待てよ…」「ここで気づいたが…」の内省を含む
  - アーキテクチャ設計：システム構成・コンポーネント間連携・データフロー
  - 本番級コード：型ヒント・テスト・性能最適化・セキュリティ考慮
  - トレードオフ分析：なぜこのアプローチを選んだか明示

出力形式: {"instruction": "...", "input": "...", "output": "..."}
"""

import json
import random
import sys
import argparse
import numpy as np
from collections import Counter

# ============================================================
# 言語分布（Claude実績ベース）
# ============================================================
LANGUAGES = {
    'python': 0.32,
    'typescript': 0.20,
    'javascript': 0.18,
    'node.js/express': 0.10,
    'react': 0.08,
    'go': 0.05,
    'bash/shell': 0.04,
    'rust': 0.03,
}

# プロジェクト種別（より実践的・複雑なものに）
PROJECT_TYPES = [
    "マイクロサービスアーキテクチャ", "分散データパイプライン", "リアルタイム決済システム",
    "マルチテナントSaaS基盤", "イベント駆動型アーキテクチャ", "全文検索エンジン",
    "OAuth2.0認証サーバ", "グラフQL APIゲートウェイ", "水平スケーラブルWebSocketサーバ",
    "分散タスクスケジューラ", "変更データキャプチャ（CDC）パイプライン", "マルチリージョンDB同期",
    "Kubernetesオペレータ", "gRPCマイクロサービスメッシュ", "ストリーム処理エンジン",
    "S3互換オブジェクトストレージ", "分散トレーシングシステム", "Feature Flag 管理基盤",
    "A/Bテストプラットフォーム", "CI/CD パイプラインオーケストレータ",
]

# ============================================================
# Claudeレベルの深い思考：8段階推論テンプレート
# ============================================================

CLAUDE_COT_JA = [
    # --- Type A: フルスタック設計 thinking ---
    """
## 1. 問題の再定義

まず「{project_type}」が本当に求めているものを整理します。

表面的な要件の裏にある本質的な要求：
- {req1}
- {req2}
- {req3}

## 2. アプローチ比較

この問題を解決するには複数の方法があります。

**アプローチA**: {approach_a}
- メリット：{pro_a}
- デメリット：{con_a}

**アプローチB**: {approach_b}
- メリット：{pro_b}
- デメリット：{con_b}

**採用**: アプローチ{selected}を選びます。
理由：{reason}

## 3. アーキテクチャ設計

システム全体の構成を考えます。

```
[{component1}] ←→ [{component2}] ←→ [{component3}]
    ↕                   ↕
[{storage1}]        [{storage2}]
```

各コンポーネントの責務：
- {component1}: {resp1}
- {component2}: {resp2}
- {component3}: {resp3}

データフロー：
1. {flow1}
2. {flow2}
3. {flow3}

## 4. エッジケース分析

「普通はこう動く」の裏にある「想定外のケース」を洗い出します。

| シナリオ | 発生条件 | 影響 | 対策 |
|---------|---------|------|------|
| {edge1} | {cond1} | {impact1} | {mit1} |
| {edge2} | {cond2} | {impact2} | {mit2} |

## 5. 実装

上記の設計に基づいて実装します。

まずはデータ構造から決めていきます。ドメインモデルを定義し、その上で処理ロジックを構築します。

```{lang}
""",

    # --- Type B: アルゴリズム深掘り ---
    """
## 1. 問題理解

「{project_type}」の核心的な課題は何か、一段抽象化して考えます。

この問題は本質的に{puzzle_type}問題であり、
制約条件として{constraint1}と{constraint2}があります。

## 2. 計算量の見積もり

ナイーブな実装では：
- 時間計算量: O({naive_big_o})
- 空間計算量: O({naive_space})

これは{scale}の入力サイズを想定すると実用的ではありません。

## 3. 最適化戦略

候補となる最適化手法：
1. {opt1} — {opt1_reason}
2. {opt2} — {opt2_reason}
3. {opt3} — {opt3_reason}

**検討**:
{analysis_deep}

## 4. トレードオフ分析

| 方式 | 速度 | メモリ | 保守性 | 拡張性 |
|-----|------|--------|--------|--------|
| {m1} | {s1} | {m1m} | {m1c} | {m1e} |
| {m2} | {s2} | {m2m} | {m2c} | {m2e} |

{selected_approach}を採用します。
決め手：{deciding_factor}

## 5. 実装（段階的詳細化）

### 5.1 データ構造
### 5.2 コアロジック
### 5.3 エッジケース対応

```{lang}
""",
]


# ============================================================
# 推論コンポーネント生成
# ============================================================

def gen_deep_reasoning_section(project_type, lang):
    """Claudeレベルの深い推論セクションを生成"""
    template = random.choice(CLAUDE_COT_JA)

    # ランダムなtrue/false選択のヘルパー
    pick2 = lambda: random.choice(["A", "B"])

    context = {
        "project_type": project_type,
        "lang": lang,
        "req1": random.choice([
            "高可用性（99.99%以上の稼働率）の保証",
            "データの一貫性と整合性の維持",
            "レイテンシ50ms以下の応答性能",
            "1,000万ユーザー規模へのスケーラビリティ",
            "PCI DSS / GDPR などのコンプライアンス対応",
            "ゼロダウンタイムデプロイの実現",
        ]),
        "req2": random.choice([
            "障害時のグレースフルデグラデーション",
            "監査可能な完全な操作ログの保持",
            "マルチリージョンでのデータレプリケーション",
            "料金プランごとの機能制限（Rate Limiting）",
            "バックワードコンパチビリティの維持",
            "段階的ロールアウトとロールバック対応",
        ]),
        "req3": random.choice([
            "開発者の生産性を最大化するDX",
            "テスト自動化とCI/CDパイプラインとの統合",
            "サードパーティプラグインの拡張可能性",
            "コスト最適化（インフラコストの最小化）",
            "オブザーバビリティ（メトリクス・トレース・ログ）",
            "セキュリティバイデザインの原則徹底",
        ]),
        "approach_a": random.choice([
            "Clean Architecture + CQRSパターン",
            "イベントソーシング + マイクロサービス",
            "モノリシック + モジュラーモノリス",
            "GraphQL + Apollo Federation",
            "gRPC双向通信ストリーム",
        ]),
        "approach_b": random.choice([
            "レイヤードアーキテクチャ + REST API",
            "従来のCRUD + RDB",
            "サーバレス + FaaS構成",
            "REST + WebSocketハイブリッド",
            "メッセージキュー駆動型アーキテクチャ",
        ]),
        "pro_a": random.choice([
            "責務の分離が明確でテスタビリティが高い",
            "スケーラビリティに優れ独立デプロイが可能",
            "変更の影響範囲が局所化され保守性が高い",
            "クライアントごとに必要なデータだけ取得できる",
            "リアルタイム性が高く双方向通信に向く",
        ]),
        "pro_b": random.choice([
            "シンプルで学習コストが低い",
            "運用インフラが単純でコストが安い",
            "ベンダーロックインがなく移植性が高い",
            "HTTPのキャッシュ機構を活用できる",
            "非同期処理により耐障害性が高い",
        ]),
        "con_a": random.choice([
            "初期構築のコストが高く複雑性が増す",
            "データの一貫性保証が難しく結果整合性になる",
            "過剰設計になりがちでスモールスタートには不向き",
            "N+1問題やキャッシュ戦略が複雑",
            "運用監視の複雑性が増し専門知識が必要",
        ]),
        "con_b": random.choice([
            "スケール限界に達した時のリファクタリングが困難",
            "機能間の結合度が高く変更の影響が大きい",
            "スケーリングが粗粒度でコスト効率が悪い",
            "ネットワークレイテンシの影響を受けやすい",
            "同期的な結合が障害の連鎖を引き起こす",
        ]),
        "selected": pick2(),
    }

    # 選ばれた方に応じて理由を生成
    selected = context["selected"]
    context["reason"] = random.choice([
        f"今回のユースケースでは「変更に対する俊敏性」が最優先であり、"
        f"アプローチ{selected}の方が長期的な保守性と拡張性で優位だからです。"
        f"また、チームのスキルセットと既存の技術スタックとの親和性も考慮しました。",
        f"プロダクトのフェーズとして「速度」よりも「品質」が求められており、"
        f"アプローチ{selected}の方がテスト容易性と信頼性で勝ります。"
        f"短期的な開発速度よりも中長期的な持続可能性を重視しました。",
        f"過去の類似プロジェクトの知見から、アプローチ{selected}のパターンが"
        f"この規模と複雑性のシステムに最も適合すると判断しました。"
        f"特に{pick2() == 'A' and '障害分離' or '運用の単純さ'}の観点で決定的な差があります。",
    ])

    # アーキテクチャコンポーネント
    context["component1"] = random.choice(["API Gateway", "Load Balancer", "Service Mesh", "CDN"])
    context["component2"] = random.choice(["Application Server", "Worker Pool", "Stream Processor", "Queue Broker"])
    context["component3"] = random.choice(["Database Cluster", "Cache Layer", "Object Storage", "Search Index"])
    context["storage1"] = random.choice(["PostgreSQL", "Redis Cluster", "S3 Bucket", "Elasticsearch"])
    context["storage2"] = random.choice(["Read Replica", "Memcached", "Snowflake", "Kafka"])
    context["resp1"] = random.choice([
        "リクエストルーティングとレート制限・認証の集約",
        "トラフィック分散とヘルスチェックによる障害検知",
        "サービス間通信の暗号化とトレース伝搬",
        "静的コンテンツのキャッシュとエッジ配信",
    ])
    context["resp2"] = random.choice([
        "ビジネスロジックの実行と非同期処理の調整",
        "ワーカープール管理とタスクの分散実行",
        "ストリームデータの変換・集計・フィルタリング",
        "メッセージのルーティングと配信保証制御",
    ])
    context["resp3"] = random.choice([
        "データの永続化とクエリ最適化",
        "キャッシュの一貫性保証とインバリデーション",
        "オブジェクトの保存とバージョニング管理",
        "全文検索とスコアリングの最適化",
    ])
    context["flow1"] = "クライアントからのリクエストを" + random.choice(["API Gateway", "Load Balancer"]) + "が受付"
    context["flow2"] = "認証・レート制限を通過後、" + random.choice(["該当マイクロサービス", "ワーカープール"]) + "が処理"
    context["flow3"] = "処理結果を" + random.choice(["キャッシュ", "DB"]) + "に書き込み、応答を返却"

    # エッジケース
    context["edge1"] = random.choice([
        "DB接続プール枯渇", "キャッシュアベイラビリティ低下",
        "ネットワークパーティション", "データ競合（Conflict）",
    ])
    context["cond1"] = random.choice([
        "想定の10倍以上の同時接続", "1台のDBノードがダウン",
        "AWS/Azureのリージョン障害", "同一キーへの並行書き込み",
    ])
    context["impact1"] = random.choice([
        "新規リクエストが処理不可に", "応答時間が30秒超に劣化",
        "一部ユーザーがサービス不能に", "データ不整合が発生",
    ])
    context["mit1"] = random.choice([
        "コネクションプーリング＋サーキットブレーカー", "マルチAZ構成＋フェイルオーバー",
        "カオスエンジニアリングで定期的に耐性検証", "楽観的ロック＋リトライロジック",
    ])
    context["edge2"] = random.choice([
        "レート制限の誤検知", "認証トークンの期限切れ",
        "サードパーティAPI障害", "メッセージの重複配信",
    ])
    context["cond2"] = random.choice([
        "CDNキャッシュの不整合", "クロックのずれによる判定ミス",
        "外部APIのレート制限超過", "Kafkaのat-least-once配送",
    ])
    context["impact2"] = random.choice([
        "正常なユーザーがブロックされる", "セッションが強制終了",
        "処理パイプラインが停止", "冪等性のない処理で重複書き込み",
    ])
    context["mit2"] = random.choice([
        "バースト制御＋適切なしきい値調整", "リフレッシュトークン+自動再認証",
        "サーキットブレーカー＋フォールバック応答", "冪等性キー＋重複排除ロジック",
    ])

    # アルゴリズム系のフィールド
    context["puzzle_type"] = random.choice(["探索", "最適化", "ソート/マージ", "グラフ走査", "動的計画法", "文字列処理"])
    context["constraint1"] = random.choice(["メモリ使用量100MB以下", "API応答2秒以内", "データ件数1億件"])
    context["constraint2"] = random.choice(["リアルタイム性が要求される", "バッチ処理で1時間以内に完了", "コスト1リクエストあたり0.01円以下"])
    context["naive_big_o"] = random.choice(["n²", "n·log n", "2ⁿ", "n·m"])
    context["naive_space"] = random.choice(["O(n)", "O(n²)", "O(log n)"])
    context["scale"] = random.choice(["数百万〜数千万", "数万〜数十万", "数億〜十億"])
    context["opt1"] = random.choice(["メモ化（Memoization）", "分割統治法", "近似アルゴリズム", "並列処理"])
    context["opt1_reason"] = random.choice([
        "同じ計算を繰り返さないことで計算量を削減",
        "問題を分割して各サブ問題を独立に解決",
        "厳密解ではなく許容範囲内の近似解で十分な場合がある",
        "マルチコア/分散環境を活用して処理を並列化",
    ])
    context["opt2"] = random.choice(["インデックス最適化", "データ構造の変更", "バッチ処理化", "遅延評価"])
    context["opt2_reason"] = random.choice([
        "適切なインデックスで検索を高速化",
        "HashSet/木構造など適切なデータ構造で操作を効率化",
        "個別処理よりバッチの方がスループットが高い",
        "本当に必要になるまで計算を遅延させて不要な計算を避ける",
    ])
    context["opt3"] = random.choice(["キャッシュ戦略", "アーリーリターン/枝刈り", "インクリメンタル計算", "事前計算"])
    context["opt3_reason"] = random.choice([
        "頻繁に参照されるデータを高速なストレージに保持",
        "不要な探索パスを早期に打ち切る",
        "全量再計算ではなく差分だけを計算",
        "実行時に計算するのではなく事前に計算結果を用意",
    ])
    context["analysis_deep"] = random.choice([
        f"各手法の特性を詳しく見ていきます。"
        f"{context['opt1']}は{context['opt1_reason']}という利点がありますが、"
        f"メモリ使用量が増加するトレードオフがあります。"
        f"一方{context['opt2']}は{context['opt2_reason']}ため、"
        f"特に特定の操作パターンに偏っている場合に有効です。"
        f"最終的には、想定されるデータ特性とアクセスパターンから、"
        f"両者を組み合わせたハイブリッド戦略が最適と判断しました。",

        f"実際のプロダクション環境を考慮すると、最悪ケースよりも"
        f"平均的なパフォーマンスが重要です。{context['opt1']}は"
        f"最悪ケースを改善しますが、{context['opt3']}は平均的な"
        f"パフォーマンスを劇的に向上させます。"
        f"両方導入することで、P99レイテンシと平均レイテンシの"
        f"両方を最適化できます。",
    ])

    # 方式比較表
    context["m1"] = random.choice(["バッチ処理", "リアルタイム処理", "同期処理", "プッシュ型"])
    context["m2"] = random.choice(["逐次処理", "バッファリング処理", "非同期処理", "プル型"])
    rands = ["⚡高速", "◯良好", "△普通", "🐢低速"]
    random.shuffle(rands)
    context["s1"] = rands[0]
    random.shuffle(rands)
    context["s2"] = rands[0]
    context["m1m"] = random.choice(["◯低メモリ", "△中メモリ", "✗大メモリ"])
    context["m2m"] = random.choice(["◯低メモリ", "△中メモリ", "✗大メモリ"])
    context["m1c"] = random.choice(["◯高い", "△普通", "✗低い"])
    context["m2c"] = random.choice(["◯高い", "△普通", "✗低い"])
    context["m1e"] = random.choice(["◯良い", "△普通", "✗悪い"])
    context["m2e"] = random.choice(["◯良い", "△普通", "✗悪い"])
    context["selected_approach"] = random.choice(["方式1", "方式2", "ハイブリッド方式"])
    context["deciding_factor"] = random.choice([
        "P99レイテンシの要件（50ms以下）を満たすのはこの方式だけ",
        "運用コストと開発速度のバランスが最も取れている",
        "将来の拡張性を考慮した時に最も柔軟性が高い",
        "チームの既存知見との親和性が高くリスクが低い",
    ])

    cot = template.format(**context)
    return cot


# ============================================================
# 本番級コード生成
# ============================================================

def gen_claude_code_python(project_type):
    """ClaudeレベルのPythonコード生成（フルプロダクション品質）"""
    en_name = project_type.replace(" ", "_").replace("-", "_")
    class_name = ''.join(w.capitalize() for w in en_name.split('_')[:4]) + 'Engine'

    entry = random.choice(["main.py", "app.py", "server.py", "__init__.py", "engine.py"])
    # Build code via concatenation to avoid f-string/.format conflicts with Python braces
    header = '''\
"""
{pt} — プロダクション実装

このモジュールは{pt}のコア実装を提供します。
設計原則:
- 依存性注入によるテスタビリティの確保
- 明示的なエラーバウンダリ
- 構造化ロギングとオブザーバビリティ
- 型安全性の徹底
*/
'''.replace('{pt}', project_type)

    imports = '''\
from __future__ import annotations
import asyncio, logging, os, sys, time, uuid
from dataclasses import dataclass, field
from typing import Any, Dict, Generic, List, Optional, TypeVar, Callable
try:
    import orjson as jsonlib
    HAS_ORJSON = True
except ImportError:
    import json as jsonlib
    HAS_ORJSON = False
'''

    config_class = '''\
class ConfigError(Exception):
    """設定関連のエラー"""
    pass

@dataclass(frozen=True)
class Config:
    """アプリケーション設定（環境変数から読み込み）"""
    host: str = field(default_factory=lambda: os.getenv("HOST", "0.0.0.0"))
    port: int = field(default_factory=lambda: int(os.getenv("PORT", "8080")))
    database_url: str = field(default_factory=lambda: os.getenv("DATABASE_URL", "postgresql://localhost:5432/app"))
    log_level: str = field(default_factory=lambda: os.getenv("LOG_LEVEL", "INFO"))

    def __post_init__(self) -> None:
        errors = []
        if not 1024 <= self.port <= 65535:
            errors.append(f"PORT out of range: {self.port}")
        if errors:
            raise ConfigError("; ".join(errors))

    @classmethod
    def from_env(cls) -> "Config":
        return cls()
'''

    result_class = '''\
T = TypeVar("T")

@dataclass
class Result(Generic[T]):
    """処理結果（Railway Oriented Programming）"""
    success: bool
    value: Optional[T] = None
    error: Optional[str] = None
    duration_ms: float = 0.0
    request_id: str = field(default_factory=lambda: uuid.uuid4().hex)

    @classmethod
    def ok(cls, value: T, duration_ms: float = 0.0) -> "Result[T]":
        return cls(success=True, value=value, duration_ms=duration_ms)

    @classmethod
    def fail(cls, error: str, duration_ms: float = 0.0) -> "Result[T]":
        return cls(success=False, error=error, duration_ms=duration_ms)
'''

    engine_class = f'''\
class {class_name}:
    """
    {project_type}のメインエンジン。
    このクラスは{project_type}のコアロジックを実装します。
    """

    def __init__(self, config: Optional[Config] = None) -> None:
        self.config = config or Config.from_env()
        self.logger = logging.getLogger(self.__class__.__name__)
        self._started_at: float = 0.0
        self._request_count: int = 0
        self._error_count: int = 0
        self.logger.info("Engine initialized")

    async def start(self) -> None:
        self._started_at = time.monotonic()
        self.logger.info("Engine started")

    async def shutdown(self) -> None:
        elapsed = time.monotonic() - self._started_at
        self.logger.info("Shutdown: %d req, %d err, %.2fs", self._request_count, self._error_count, elapsed)

    async def process(self, data: Dict[str, Any]) -> Result[Dict[str, Any]]:
        start = time.monotonic()
        self._request_count += 1
        rid = uuid.uuid4().hex
        self.logger.info("Processing request %s", rid)
        try:
            if not isinstance(data, dict):
                raise ValueError("Input must be a dict")
            return Result.ok({{"status": "ok", "request_id": rid}})
        except ValueError as e:
            self._error_count += 1
            self.logger.warning("Validation error: %s", e)
            return Result.fail(str(e))
        except Exception as e:
            self._error_count += 1
            self.logger.error("Unexpected error", exc_info=True)
            return Result.fail(f"Internal error: {{e}}")
'''

    main_func = f'''\
async def main() -> None:
    config = Config.from_env()
    logging.basicConfig(level=config.log_level.upper(), force=True)
    logger = logging.getLogger("main")
    logger.info("Starting {project_type} engine")
    logger.info("Engine ready")

if __name__ == "__main__":
    asyncio.run(main())
'''

    code = header + imports + '\n' + config_class + '\n' + result_class + '\n' + engine_class + '\n' + main_func
    return code


# ============================================================
# 指示文生成（Claudeレベルの要求）
# ============================================================

INSTRUCTIONS_CLAUDE = [
    "{project_type}をゼロから設計・実装してください。アーキテクチャの選択肢を比較検討し、採用した理由を明確にした上で、本番運用可能なコードを提供してください。エラーハンドリング、ロギング、設定管理、テスト容易性をすべて考慮してください。",
    "次の{project_type}について、まず問題を分析し、複数のアプローチを比較した上で最適な設計を選んでください。選定理由をトレードオフとともに説明し、その設計に基づいたプロダクション品質のコードを実装してください。型安全性とエッジケースへの対応を重視してください。",
    "{project_type}を実装するにあたり、まずシステム全体のアーキテクチャを検討してください。コンポーネント図、データフロー、エッジケースの分析を行った上で、実装に移ってください。コードは本番環境でそのまま使える品質を目指し、コメントは日本語で理由を説明してください。",
    "{project_type}の設計と実装をお願いします。以下の観点を必ず含めてください：1) アーキテクチャの選択肢比較、2) 採用した設計の根拠、3) エッジケースの洗い出しと対策、4) 具体的な実装コード（型ヒント・エラーハンドリング・ロギング完備）、5) 性能とスケーラビリティの考慮。思考過程は日本語で詳しく記述してください。",
    "プロダクションレベルの{project_type}を実装してください。単なるコードではなく、設計判断のプロセスを日本語で詳しく説明しながら進めてください。想定される障害モード、それに対する対策、なぜその実装方法を選んだのかを明確にしてください。",
]


def gen_claude_instruction(project_type):
    t = random.choice(INSTRUCTIONS_CLAUDE)
    return t.format(project_type=project_type)


def gen_claude_input(project_type, lang):
    inputs = [
        f"言語: {lang}\n想定スケール: {random.choice(['月間100万リクエスト', '同時接続10,000', 'データ量10TB級', '全世界マルチリージョン展開', 'エンタープライズSaaS'])}\nSLA要件: {random.choice(['99.9%可用性', '99.99%可用性（年間ダウンタイム53分以内）', 'P99レイテンシ200ms以下'])}\nセキュリティ要件: {random.choice(['OWASP Top 10対策必須', 'PCI DSS準拠が必要', '社内認証基盤との統合必須'])}",
        f"言語: {lang}\nコンテキスト: {random.choice(['スタートアップのMVPだが将来の拡張を見据えた設計', '既存のモノリスをマイクロサービス化する移行プロジェクト', 'ゼロからのグリーンフィールド開発', 'レガシーシステムのモダナイゼーション'])}\n制約: {random.choice(['チームは5名、全員がこのアーキテクチャは初心者', '6ヶ月以内に本番リリース必須', '週次デプロイを目標としたCI/CDパイプライン構築済み'])}",
        "",
    ]
    return random.choice(inputs)


# ============================================================
# 後処理（CoTに自己検証・振り返りを追加）
# ============================================================

COT_APPENDICES = [
    """\n\n## 6. 実装の振り返り

ここまでの実装を振り返り、改善点を洗い出します。

### よかった点
- {good1}
- {good2}

### 改善余地
- {improve1}
- {improve2}

### 追加で考慮すべきこと
実装中に気づいた追加の考慮事項：
1. {extra1}
2. {extra2}

これらの点を改善すれば、さらに堅牢なシステムになります。
現時点では優先度とインパクトを考慮し、コア機能に集中しました。""",

    """\n\n## 6. 検証

実装が正しいことを確認します。

### 正常系テスト
- 標準的な入力 → 期待通りの出力 ✅
- 設定変更による動作の変化 → 期待通り ✅

### 異常系テスト
- 不正な入力 → 適切なエラーレスポンス ✅
- DB接続障害 → グレースフルデグラデーション ✅
- タイムアウト → リクエストのキャンセルとクリーンアップ ✅

### 性能見積もり
- 想定負荷: {perf_load}
- 推定スループット: {perf_throughput}
- ボトルネック予測: {perf_bottleneck}

### 改善の余地
{perf_improve}""",
]

CLAUDE_APPENDIX_FILLS = {
    "good1": [
        "依存性注入によりテスト容易性が確保できている",
        "エラーバウンダリが明確で、障害の伝播を制御できている",
        "型ヒントによりAPIの契約が明確になっている",
        "構造化ロギングで運用時のデバッグ容易性が高い",
    ],
    "good2": [
        "設定の外部化により環境依存がなくなった",
        "非同期処理によりI/O待ちの効率が向上している",
        "Resultモナドパターンでエラー処理が統一されている",
        "コンテキストマネージャでリソース管理が安全になった",
    ],
    "improve1": [
        "サーキットブレーカーパターンの導入を検討すべき",
        "リトライ戦略に指数バックオフを適用する余地がある",
        "メトリクス収集を追加すればより詳細な監視が可能",
        "バリデーションルールを宣言的に記述するともっと保守しやすい",
    ],
    "improve2": [
        "分散トレーシングの対応を入れると障害追跡が容易になる",
        "キャッシュ戦略をより精緻化すればレイテンシを改善できる",
        "バルクヘッドパターンで障害の影響範囲をさらに限定できる",
        "ヘルスチェックエンドポイントを充実させればK8sとの親和性が高まる",
    ],
    "extra1": [
        "データの暗号化（保存時・転送時）の対応",
        "監査ログの出力と改ざん防止策",
        "レート制限の適切なしきい値設計",
        "依存ライブラリの脆弱性スキャン",
    ],
    "extra2": [
        "カオスエンジニアリングによる耐障害性検証",
        "負荷テストによる性能限界の把握",
        "セキュリティレビュー（SAST/DAST）の実施",
        "ドキュメント生成とAPI仕様の自動化",
    ],
    "perf_load": random.choice([
        "毎秒1,000リクエストの定常負荷 + バースト3,000",
        "毎秒100リクエストだが各リクエストの処理が重い（〜500ms）",
        "時間帯によって10倍以上の負荷変動がある",
    ]),
    "perf_throughput": random.choice([
        "単一ノードで毎秒2,000リクエスト処理可能（推定）",
        "水平スケーリングによりほぼ線形にスループット向上可能",
        "キャッシュヒット率80%想定で実効スループットは5倍",
    ]),
    "perf_bottleneck": random.choice([
        "DB接続プールが最もクリティカルなリソース",
        "直列化が必要な処理がスケーリングの制約になる",
        "メモリ割り当てとGCが高負荷時に問題になりうる",
    ]),
    "perf_improve": random.choice([
        "コネクションプーリングのチューニングでさらに10-20%改善可能",
        "読み取り系をレプリカにオフロードすれば書き込みのスループットが向上",
        "オブジェクトの再利用でGCプレッシャーを低減できる",
    ]),
}


def append_claude_verification(cot):
    """自己検証・振り返りを追記"""
    if random.random() < 0.65:
        template = random.choice(COT_APPENDICES)
        fills = {}
        for key in ["good1", "good2", "improve1", "improve2", "extra1", "extra2", "perf_load", "perf_throughput", "perf_bottleneck", "perf_improve"]:
            val = CLAUDE_APPENDIX_FILLS.get(key)
            if isinstance(val, list):
                fills[key] = random.choice(val)
            elif val is not None:
                fills[key] = val
        return cot + template.format(**fills)
    return cot


# ============================================================
# メイン生成ロジック
# ============================================================

def generate_record():
    """Claudeレベル1レコード生成"""
    lang = pick_weighted(LANGUAGES)
    project_type = random.choice(PROJECT_TYPES)
    
    instruction = gen_claude_instruction(project_type)
    input_text = gen_claude_input(project_type, lang)
    
    # English name for code blocks
    en_name = project_type.lower()\
        .replace(" ", "_").replace("-", "_")\
        .replace("アーキテクチャ", "architecture")\
        .replace("パイプライン", "pipeline")\
        .replace("システム", "system")\
        .replace("サーバ", "server")\
        .replace("エンジン", "engine")\
        .replace("基盤", "platform")\
        .replace("管理", "manager")\
        .replace("処理", "processor")\
        .replace("同期", "sync")\
        .replace("配信", "delivery")\
        .replace("変換", "converter")\
        .replace("抽出", "extractor")\
        .replace("駆動型", "_driven")\
        .replace("基盤", "infra")\
        .replace("認証", "auth")\
        .replace("ゲートウェイ", "gateway")\
        .replace("スケジューラ", "scheduler")\
        .replace("オペレータ", "operator")\
        .replace("メッシュ", "mesh")\
        .replace("ストレージ", "storage")\
        .replace("トレーシング", "tracing")\
        .replace("オーケストレータ", "orchestrator")\
        .replace("プラットフォーム", "platform")\
        .replace("格納", "store")\
        .replace("対応", "")\
        .replace("（", "_").replace("）", "")\
        .replace("(", "_").replace(")", "")\
        .replace(" ", "_")\
        .strip("_")
    
    # CoT生成（深い推論）
    cot = gen_deep_reasoning_section(project_type, lang)
    
    # CoT長さ調整（Claudeレベル: 平均7000文字）
    target_len = truncated_gauss(7000, 2500, 3000, 18000)
    while len(cot) < target_len:
        cot += '\n\n' + random.choice([
            "ここで一つ確認しておきます。この設計では「障害が発生したときの影響範囲」を最小限に抑えることを意図しています。コンポーネント間の依存関係をよく設計することで、あるモジュールの障害が連鎖的に全体に波及するのを防ぎます。この考え方は、信頼性工学における「フェイルソフト」の原則に基づいています。",
            "待てよ、この実装には見落としがあるかもしれない。並行処理の競合状態（レースコンディション）についてもう一度確認しておこう。複数のリクエストが同時に同じリソースにアクセスした場合、楽観的ロックで十分だろうか？それとも悲観的ロックが必要か？書き込みの競合が稀なユースケースなので、楽観的ロック+リトライで十分と判断する。",
            "セキュリティの観点からもう一度確認：入力値のバリデーションは通過したが、それは「形式」のチェックであって「内容」の安全保証ではない。例えばファイルアップロード機能があれば、拡張子だけでなくMIMEタイプの実検証も必要だ。また、エラーメッセージにスタックトレースを含めていないか？内部情報の漏洩はセキュリティインシデントにつながる。",
            "より深く考えてみると、この問題は単なる技術実装ではなく、ドメイン駆動設計（DDD）の観点からもアプローチすべきだ。ユビキタス言語（共通言語）をコードに反映できているか？境界付けられたコンテキスト（Bounded Context）は適切に分離されているか？DDDの戦略的設計と戦術的設計の両面から、この実装を評価する必要がある。",
            "実装のパフォーマンスについて：Big-O記法での計算量は重要だが、実際のプロダクションでは定数倍の最適化も無視できない。Pythonであれば、リスト内包表記よりジェネレータ式がメモリ効率が良い場合がある。また、dictのキー検索はO(1)だが、ハッシュ衝突の最悪ケースを考慮すると、適切な初期容量の設定も検討すべきだ。",
        ])
    cot = cot[:target_len]
    
    # 自己検証セクション追加
    cot = append_claude_verification(cot)
    
    # コード生成（Claude品質）
    if lang == 'python':
        code = gen_claude_code_python(project_type)
    else:
        code = f'''// {project_type} — プロダクション実装
// 設計原則:
// - 依存性注入によるテスタビリティ
// - 明示的なエラーバウンダリ
// - 構造化ロギング
// - 型安全性の徹底

import {{ EventEmitter }} from 'events';
import {{ randomUUID }} from 'crypto';
import {{ createLogger, format, transports }} from 'winston';
import * as dotenv from 'dotenv';

dotenv.config();

// === 設定管理 ===
interface AppConfig {{
    readonly host: string;
    readonly port: number;
    readonly databaseUrl: string;
    readonly maxRetries: number;
    readonly requestTimeout: number;
    readonly logLevel: string;
}}

function loadConfig(): AppConfig {{
    const config: AppConfig = {{
        host: process.env.HOST || '0.0.0.0',
        port: parseInt(process.env.PORT || '8080', 10),
        databaseUrl: process.env.DATABASE_URL || 'postgresql://localhost:5432/app',
        maxRetries: parseInt(process.env.MAX_RETRIES || '3', 10),
        requestTimeout: parseInt(process.env.REQUEST_TIMEOUT || '30000', 10),
        logLevel: process.env.LOG_LEVEL || 'info',
    }};
    
    // バリデーション
    if (config.port < 1024 || config.port > 65535) {{
        throw new Error(`Invalid port: ${{config.port}}`);
    }}
    if (config.maxRetries < 0) {{
        throw new Error(`Invalid maxRetries: ${{config.maxRetries}}`);
    }}
    
    return Object.freeze(config);
}}

// === 構造化ロギング ===
const logger = createLogger({{
    level: process.env.LOG_LEVEL || 'info',
    format: format.combine(
        format.timestamp(),
        format.errors({{ stack: true }}),
        format.json(),
    ),
    defaultMeta: {{ service: '{en_name}', version: '1.0.0' }},
    transports: [
        new transports.Console(),
        ...(process.env.LOG_DIR
            ? [new transports.File({{ filename: process.env.LOG_DIR + '/app.log' }})]
            : []),
    ],
}});

// === エンジン ===
export class Engine extends EventEmitter {{
    private readonly config: AppConfig;
    private startTime: number = 0;
    private requestCount: number = 0;
    private errorCount: number = 0;
    
    constructor(config?: Partial<AppConfig>) {{
        super();
        this.config = {{ ...loadConfig(), ...config }};
        logger.info('Engine initialized', {{ config: this.config }});
    }}
    
    async start(): Promise<void> {{
        this.startTime = Date.now();
        logger.info('Engine started');
        this.emit('started');
    }}
    
    async shutdown(): Promise<void> {{
        const elapsed = Date.now() - this.startTime;
        logger.info('Engine shutting down', {{
            requests: this.requestCount,
            errors: this.errorCount,
            uptimeMs: elapsed,
        }});
        this.emit('shutdown');
    }}
    
    async process<T>(data: T): Promise<{{ success: boolean; data?: T; error?: string }}> {{
        const start = Date.now();
        this.requestCount++;
        const requestId = randomUUID();
        
        logger.debug('Processing request', {{ requestId }});
        
        try {{
            // ビジネスロジック
            // const validated = this.validate(data);
            // const result = await this.execute(validated);
            return {{ success: true, data }};
        }} catch (error) {{
            this.errorCount++;
            const message = error instanceof Error ? error.message : 'Unknown error';
            logger.error('Request failed', {{ requestId, error: message }});
            return {{ success: false, error: message }};
        }} finally {{
            const duration = Date.now() - start;
            logger.debug('Request completed', {{ requestId, durationMs: duration }});
        }}
    }}
}}

// === エントリポイント ===
async function main() {{
    const engine = new Engine();
    
    process.on('SIGINT', async () => {{
        logger.info('Received SIGINT');
        await engine.shutdown();
        process.exit(0);
    }});
    
    process.on('SIGTERM', async () => {{
        logger.info('Received SIGTERM');
        await engine.shutdown();
        process.exit(0);
    }});
    
    await engine.start();
    logger.info('Service ready');
}}

if (require.main === module) {{
    main().catch((err) => {{
        logger.error('Fatal error', {{ error: err }});
        process.exit(1);
    }});
}}
'''
    
    output = f"{cot}\n\n```{lang}\n{code}\n```"
    
    return {
        "instruction": instruction,
        "input": input_text,
        "output": output,
    }


def truncated_gauss(mean, std, lo, hi):
    v = random.gauss(mean, std)
    return int(max(lo, min(hi, v)))


def pick_weighted(items):
    total = sum(items.values())
    r = random.random() * total
    c = 0
    for item, weight in items.items():
        c += weight
        if r <= c:
            return item
    return list(items.keys())[-1]


def generate_dataset(num_records, output_path):
    records = []
    print(f"Claudeレベル日本語データセットを生成中... {num_records} レコード", file=sys.stderr)
    
    for i in range(num_records):
        record = generate_record()
        records.append(record)
        if (i + 1) % 5000 == 0:
            print(f"  {i+1}/{num_records} 生成完了", file=sys.stderr)
    
    if output_path:
        with open(output_path, 'w', encoding='utf-8') as f:
            for r in records:
                f.write(json.dumps(r, ensure_ascii=False) + '\n')
        print(f"{len(records)} レコードを {output_path} に書き込みました", file=sys.stderr)
    else:
        for r in records:
            print(json.dumps(r, ensure_ascii=False))
    
    total_chars = sum(len(r['output']) for r in records)
    avg = total_chars / len(records) if records else 0
    print(f"\n統計: {len(records)} レコード, 平均出力長: {avg:.0f} 文字", file=sys.stderr)
    return records


if __name__ == '__main__':
    ap = argparse.ArgumentParser(description='Claude-Level 日本語コーディングデータセット生成器')
    ap.add_argument('--records', type=int, default=30000, help='生成レコード数')
    ap.add_argument('--output', type=str, default='coding_excellence_ja_claude.jsonl', help='出力ファイル')
    ap.add_argument('--seed', type=int, default=None, help='乱数シード')
    args = ap.parse_args()
    
    if args.seed is not None:
        random.seed(args.seed)
        np.random.seed(args.seed)
    
    generate_dataset(args.records, args.output)