# AIコンサルティング年間収益モデル
revenue_model = {
    "year_1": {
        "tier1_assessments": {
            "count": 12, "avg_price": 1000000,
            "total": 12_000_000
        },
        "tier2_projects": {
            "count": 4, "avg_price": 5000000,
            "total": 20_000_000
        },
        "tier3_retainers": {
            "count": 3, "monthly": 500000, "months": 6,
            "total": 9_000_000
        },
        "annual_revenue": 41_000_000,  # 4,100万円
        "costs": {
            "tools_and_apis": 1_200_000,
            "subcontractors": 8_000_000,
            "marketing": 2_000_000,
            "overhead": 3_000_000,
            "total": 14_200_000
        },
        "profit": 26_800_000,  # 2,680万円
        "margin": 65.4  # 65.4%
    }
}

class ConsultingRevenueModel:
    """AIコンサルティングの収益モデルと成長予測"""
 
    def __init__(self):
        self.service_tiers = {
            "assessment": {
                "price_range": (500_000, 1_500_000),
                "duration_weeks": (2, 4),
                "capacity_per_month": 2,
                "conversion_to_tier2": 0.4,
            },
            "implementation": {
                "price_range": (2_000_000, 10_000_000),
                "duration_months": (2, 6),
                "capacity_per_quarter": 2,
                "conversion_to_tier3": 0.6,
            },
            "retainer": {
                "monthly_range": (300_000, 1_000_000),
                "avg_duration_months": 12,
                "churn_rate_monthly": 0.05,
            },
        }
 
    def project_3_years(self) -> list:
        """3年間の収益予測"""
        projections = []
 
        for year in range(1, 4):
            growth_factor = 1 + (year - 1) * 0.5
 
            assessments = int(12 * growth_factor)
            implementations = int(4 * growth_factor)
            retainers_new = int(3 * growth_factor)
 
            # アセスメント収益
            assessment_rev = assessments * 1_000_000
 
            # 実装プロジェクト収益
            impl_avg_price = 5_000_000 * (1 + (year - 1) * 0.2)
            impl_rev = implementations * impl_avg_price
 
            # リテイナー収益（累積効果）
            retainer_monthly = 500_000
            retainer_months = min(12, 6 + year * 2)
            active_retainers = retainers_new + max(0,
                (year - 1) * 2)  # 前年からの継続
            retainer_rev = active_retainers * retainer_monthly * retainer_months
 
            total = assessment_rev + impl_rev + retainer_rev
 
            projections.append({
                "year": year,
                "assessments": assessments,
                "implementations": implementations,
                "active_retainers": active_retainers,
                "assessment_revenue": assessment_rev,
                "implementation_revenue": int(impl_rev),
                "retainer_revenue": int(retainer_rev),
                "total_revenue": int(total),
                "team_size": 1 + year,
            })
 
        return projections
 
    def calculate_utilization(self, billable_hours: int,
                               total_hours: int = 2000) -> dict:
        """稼働率の計算"""
        utilization = billable_hours / total_hours
        non_billable = {
            "marketing": total_hours * 0.15,
            "admin": total_hours * 0.10,
            "learning": total_hours * 0.10,
            "sales": total_hours * 0.10,
        }
 
        return {
            "billable_hours": billable_hours,
            "total_hours": total_hours,
            "utilization_rate": round(utilization * 100, 1),
            "target": "65-75%が健全な範囲",
            "non_billable_breakdown": non_billable,
        }
 
 
# 使用例
model = ConsultingRevenueModel()
projections = model.project_3_years()
for p in projections:
    print(f"Year {p['year']}: 売上 {p['total_revenue']:,}円 "
          f"(チーム{p['team_size']}人)")

class SalesProcess:
    """AIコンサルティングの営業プロセス"""
 
    PIPELINE_STAGES = {
        "lead": {
            "description": "リード獲得",
            "sources": [
                "コンテンツマーケティング（ブログ、登壇）",
                "紹介・口コミ",
                "LinkedIn DM",
                "ウェビナー参加者",
                "問い合わせフォーム",
            ],
            "conversion_rate": 0.30,  # → 商談
            "avg_days": 7,
        },
        "discovery": {
            "description": "ヒアリング・課題発見",
            "activities": [
                "初回ミーティング（30-60分）",
                "課題の深掘りと構造化",
                "AI活用の可能性評価",
                "キーパーソン・予算の特定",
            ],
            "conversion_rate": 0.50,  # → 提案
            "avg_days": 14,
        },
        "proposal": {
            "description": "提案・見積",
            "activities": [
                "提案書作成（1-2週間）",
                "プレゼンテーション",
                "質疑応答・修正",
                "社内稟議サポート",
            ],
            "conversion_rate": 0.60,  # → 受注
            "avg_days": 21,
        },
        "negotiation": {
            "description": "交渉・契約",
            "activities": [
                "価格・スコープ調整",
                "契約書レビュー",
                "NDA締結",
                "発注書・契約締結",
            ],
            "conversion_rate": 0.80,  # → 開始
            "avg_days": 14,
        },
    }
 
    def calculate_pipeline_metrics(self, monthly_leads: int) -> dict:
        """パイプラインメトリクスの計算"""
        funnel = {"monthly_leads": monthly_leads}
        current = monthly_leads
 
        for stage, data in self.PIPELINE_STAGES.items():
            converted = int(current * data["conversion_rate"])
            funnel[stage] = {
                "input": current,
                "output": converted,
                "conversion": data["conversion_rate"],
            }
            current = converted
 
        funnel["monthly_deals"] = current
        funnel["overall_conversion"] = current / max(monthly_leads, 1)
 
        # 必要リード数の逆算
        target_monthly_deals = 2
        required_leads = target_monthly_deals
        for stage in reversed(list(self.PIPELINE_STAGES.values())):
            required_leads = int(required_leads / stage["conversion_rate"])
        funnel["required_leads_for_target"] = required_leads
 
        return funnel
 
    @staticmethod
    def create_outreach_templates() -> dict:
        """営業テンプレート"""
        return {
            "cold_linkedin": {
                "subject": None,
                "body": (
                    "{name}さん\n\n"
                    "{company}の{recent_activity}について拝見しました。\n"
                    "AIを活用した{use_case}で、同業の{reference_company}では"
                    "{result}を達成されています。\n\n"
                    "15分ほどお話しする機会をいただけないでしょうか？\n"
                    "御社の{department}における課題を伺い、"
                    "AI活用の可能性についてご提案できればと思います。"
                ),
                "follow_up_days": [3, 7, 14],
            },
            "warm_introduction": {
                "subject": "{introducer_name}さんからのご紹介",
                "body": (
                    "{name}さん\n\n"
                    "{introducer_name}さんからご紹介いただきました、"
                    "{my_name}と申します。\n"
                    "AI導入コンサルティングを専門としており、"
                    "{industry}業界での実績があります。\n\n"
                    "御社の{challenge}について、"
                    "AIでの解決アプローチをご提案できると思います。\n"
                    "30分ほどお時間をいただけますでしょうか？"
                ),
            },
            "post_webinar": {
                "subject": "ウェビナーご参加ありがとうございました",
                "body": (
                    "{name}さん\n\n"
                    "先日のウェビナー「{webinar_title}」に"
                    "ご参加いただきありがとうございました。\n\n"
                    "ウェビナーでご紹介した{topic}について、"
                    "御社でのAI活用の可能性を個別にご相談させていただければ幸いです。\n"
                    "無料の30分アセスメントセッションを実施しておりますので、"
                    "ご興味あればお知らせください。"
                ),
            },
        }

class ProposalGenerator:
    """AI提案書自動生成エンジン"""
 
    def __init__(self, client):
        self.client = client
 
    def generate_proposal(self, assessment: dict) -> dict:
        """アセスメント結果から提案書を自動生成"""
        sections = {}
 
        # 1. エグゼクティブサマリー
        sections["executive_summary"] = self._generate_section(
            f"""
以下のアセスメント結果に基づき、経営者向けエグゼクティブサマリーを作成:
- 企業名: {assessment['company']}
- 業界: {assessment['industry']}
- 課題: {assessment['pain_points']}
- 提案: {assessment['proposed_solutions']}
形式: 課題→解決策→期待効果→投資額の流れで1ページ以内。
"""
        )
 
        # 2. ROI分析
        roi = self.calculate_roi(assessment)
        sections["roi_analysis"] = roi
 
        # 3. 実施計画
        sections["implementation_plan"] = self._generate_section(
            f"""
以下のAI導入プロジェクトの実施計画を作成:
- ソリューション: {assessment['proposed_solutions']}
- 予算規模: {assessment['budget_range']}
- 期間: {assessment['timeline']}
形式: Phase 1(PoC)→Phase 2(本開発)→Phase 3(運用)の3段階。
"""
        )
 
        return sections
 
    def calculate_roi(self, assessment: dict) -> dict:
        """ROI計算"""
        costs = assessment["estimated_costs"]
        benefits = assessment["estimated_benefits"]
 
        initial_investment = costs["development"] + costs["infrastructure"]
        monthly_cost = costs["api"] + costs["maintenance"]
        monthly_benefit = benefits["time_saved"] + benefits["error_reduction"]
 
        payback_months = initial_investment / (monthly_benefit - monthly_cost)
        year1_roi = ((monthly_benefit - monthly_cost) * 12 - initial_investment
                     ) / initial_investment * 100
 
        return {
            "initial_investment": initial_investment,
            "monthly_cost": monthly_cost,
            "monthly_benefit": monthly_benefit,
            "monthly_net": monthly_benefit - monthly_cost,
            "payback_months": round(payback_months, 1),
            "year1_roi": round(year1_roi, 1),
            "year3_total_benefit": (monthly_benefit - monthly_cost) * 36
        }
 
    def _generate_section(self, prompt: str) -> str:
        response = self.client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            messages=[{"role": "user", "content": prompt}]
        )
        return response.content[0].text

class ProposalTemplates:
    """提案書の各セクション詳細テンプレート"""
 
    @staticmethod
    def executive_summary_template(data: dict) -> str:
        """エグゼクティブサマリーテンプレート"""
        return f"""
# エグゼクティブサマリー
 
## 背景と課題
{data['company_name']}様は、{data['business_context']}において
{data['main_challenge']}という課題を抱えておられます。
現在、{data['current_process']}に月間約{data['hours_spent']}時間、
年間約{data['annual_cost']:,}円のコストが発生しています。
 
## ご提案内容
AI技術（{data['ai_technology']}）を活用した
{data['solution_name']}の導入をご提案いたします。
 
## 期待効果
- 処理時間: {data['time_reduction']}%削減
- コスト: 年間{data['cost_saving']:,}円削減
- 品質: {data['quality_improvement']}
 
## 投資額と回収期間
- 初期投資: {data['initial_cost']:,}円
- 月額運用コスト: {data['monthly_cost']:,}円
- 投資回収期間: {data['payback_months']}ヶ月
- 初年度ROI: {data['year1_roi']}%
"""
 
    @staticmethod
    def risk_assessment_template() -> dict:
        """リスク評価テンプレート"""
        return {
            "technical_risks": [
                {
                    "risk": "AIモデルの精度が目標に達しない",
                    "probability": "中",
                    "impact": "高",
                    "mitigation": "PoC段階で精度を検証。"
                                  "目標未達の場合は別アプローチを検討",
                },
                {
                    "risk": "AIプロバイダのAPI障害",
                    "probability": "低",
                    "impact": "高",
                    "mitigation": "マルチプロバイダ構成。"
                                  "フォールバック機能を実装",
                },
                {
                    "risk": "既存システムとの統合が困難",
                    "probability": "中",
                    "impact": "中",
                    "mitigation": "API層で疎結合に設計。"
                                  "段階的な統合アプローチ",
                },
            ],
            "operational_risks": [
                {
                    "risk": "社員のAIへの抵抗感",
                    "probability": "高",
                    "impact": "中",
                    "mitigation": "早期段階からのユーザー参加。"
                                  "丁寧なトレーニングプログラム",
                },
                {
                    "risk": "運用担当者のスキル不足",
                    "probability": "中",
                    "impact": "中",
                    "mitigation": "運用マニュアル整備。"
                                  "引き継ぎ期間の設定（1-2ヶ月）",
                },
            ],
            "legal_risks": [
                {
                    "risk": "個人情報のAIへの入力",
                    "probability": "高",
                    "impact": "高",
                    "mitigation": "PII検出・マスキング処理。"
                                  "データ処理契約（DPA）の締結",
                },
                {
                    "risk": "AI生成物の著作権問題",
                    "probability": "低",
                    "impact": "中",
                    "mitigation": "利用規約への明記。"
                                  "AI生成物の人間によるレビュー必須化",
                },
            ],
        }
 
    @staticmethod
    def pricing_template() -> dict:
        """見積テンプレート"""
        return {
            "initial_costs": {
                "assessment": {
                    "description": "現状分析・要件定義",
                    "hours": 40,
                    "rate": 25000,
                    "total": 1_000_000,
                },
                "poc_development": {
                    "description": "PoC開発・検証",
                    "hours": 120,
                    "rate": 25000,
                    "total": 3_000_000,
                },
                "production_development": {
                    "description": "本番システム開発",
                    "hours": 200,
                    "rate": 25000,
                    "total": 5_000_000,
                },
                "integration_testing": {
                    "description": "統合テスト・品質保証",
                    "hours": 60,
                    "rate": 25000,
                    "total": 1_500_000,
                },
                "training": {
                    "description": "社員トレーニング",
                    "hours": 20,
                    "rate": 30000,
                    "total": 600_000,
                },
                "subtotal": 11_100_000,
            },
            "monthly_costs": {
                "ai_api": {
                    "description": "AI API使用料",
                    "monthly": 200_000,
                },
                "infrastructure": {
                    "description": "インフラ運用費",
                    "monthly": 50_000,
                },
                "support": {
                    "description": "運用サポート",
                    "monthly": 300_000,
                },
                "subtotal": 550_000,
            },
            "payment_terms": {
                "schedule": [
                    "契約時: 30%",
                    "PoC完了時: 30%",
                    "本番リリース時: 30%",
                    "検収完了時: 10%",
                ],
                "payment_method": "銀行振込（請求書発行後30日以内）",
            },
        }

# 業務別ROI算出
roi_templates = {
    "customer_support": {
        "current_state": {
            "agents": 10,
            "salary_per_agent": 4_000_000,  # 年間
            "tickets_per_month": 5000,
            "avg_resolution_time_min": 15,
            "customer_satisfaction": 72  # %
        },
        "after_ai": {
            "agents_needed": 6,  # 40%削減
            "ai_cost_annual": 3_600_000,
            "avg_resolution_time_min": 5,  # 67%短縮
            "customer_satisfaction": 85  # +13pt
        },
        "roi_calculation": {
            "salary_saved": 4 * 4_000_000,     # 1,600万円
            "ai_cost": 3_600_000,               # 360万円
            "net_benefit": 16_000_000 - 3_600_000,  # 1,240万円
            "satisfaction_impact": "解約率2%減 ≒ 年500万円",
            "total_annual_benefit": 17_400_000,
            "implementation_cost": 8_000_000,
            "roi_year1": "117%",
            "payback": "5.5ヶ月"
        }
    },
    "document_processing": {
        "current_state": {
            "staff": 5,
            "salary_per_staff": 5_000_000,
            "documents_per_month": 3000,
            "avg_processing_time_min": 20,
            "error_rate": 0.05,
        },
        "after_ai": {
            "staff_needed": 2,
            "ai_cost_annual": 2_400_000,
            "avg_processing_time_min": 3,
            "error_rate": 0.01,
        },
        "roi_calculation": {
            "salary_saved": 3 * 5_000_000,
            "ai_cost": 2_400_000,
            "error_cost_saved": 3000 * 12 * 0.04 * 5000,
            "net_annual_benefit": 20_200_000,
            "implementation_cost": 6_000_000,
            "roi_year1": "237%",
            "payback": "3.6ヶ月",
        },
    },
    "sales_forecasting": {
        "current_state": {
            "forecast_accuracy": 0.65,
            "annual_revenue": 500_000_000,
            "inventory_waste_rate": 0.08,
        },
        "after_ai": {
            "forecast_accuracy": 0.85,
            "inventory_waste_rate": 0.03,
        },
        "roi_calculation": {
            "waste_reduction": 500_000_000 * 0.05,
            "ai_cost_annual": 5_000_000,
            "net_annual_benefit": 20_000_000,
            "implementation_cost": 10_000_000,
            "roi_year1": "100%",
            "payback": "6ヶ月",
        },
    },
}

class ROICalculator:
    """包括的なROI計算ツール"""
 
    def __init__(self):
        self.discount_rate = 0.08  # 割引率8%
 
    def calculate_simple_roi(self, investment: float,
                              annual_benefit: float,
                              annual_cost: float) -> dict:
        """単純ROI計算"""
        net_benefit = annual_benefit - annual_cost
        roi = (net_benefit - investment) / investment * 100
        payback = investment / max(net_benefit / 12, 1)
 
        return {
            "investment": investment,
            "annual_benefit": annual_benefit,
            "annual_cost": annual_cost,
            "net_annual_benefit": net_benefit,
            "roi_percentage": round(roi, 1),
            "payback_months": round(payback, 1),
        }
 
    def calculate_npv(self, investment: float,
                       cash_flows: list,
                       discount_rate: float = None) -> dict:
        """NPV（正味現在価値）計算"""
        rate = discount_rate or self.discount_rate
        npv = -investment
 
        discounted_flows = []
        for year, cf in enumerate(cash_flows, 1):
            discounted = cf / (1 + rate) ** year
            discounted_flows.append({
                "year": year,
                "cash_flow": cf,
                "discounted": round(discounted),
            })
            npv += discounted
 
        return {
            "investment": investment,
            "discount_rate": rate,
            "npv": round(npv),
            "is_positive": npv > 0,
            "cash_flows": discounted_flows,
        }
 
    def calculate_irr(self, investment: float,
                       cash_flows: list) -> float:
        """IRR（内部収益率）計算"""
        # 二分法で計算
        low, high = -0.5, 5.0
 
        for _ in range(100):
            mid = (low + high) / 2
            npv = -investment
            for year, cf in enumerate(cash_flows, 1):
                npv += cf / (1 + mid) ** year
 
            if abs(npv) < 1000:
                break
            elif npv > 0:
                low = mid
            else:
                high = mid
 
        return round(mid * 100, 1)
 
    def sensitivity_analysis(self, base_case: dict,
                              variables: dict) -> list:
        """感度分析"""
        results = []
 
        for var_name, var_range in variables.items():
            for factor in var_range:
                case = base_case.copy()
                case[var_name] = base_case[var_name] * factor
 
                roi = self.calculate_simple_roi(
                    investment=case.get("investment", 0),
                    annual_benefit=case.get("annual_benefit", 0),
                    annual_cost=case.get("annual_cost", 0),
                )
 
                results.append({
                    "variable": var_name,
                    "factor": factor,
                    "value": case[var_name],
                    "roi": roi["roi_percentage"],
                    "payback_months": roi["payback_months"],
                })
 
        return results
 
    def generate_roi_report(self, assessment: dict) -> str:
        """ROIレポートの自動生成"""
        simple = self.calculate_simple_roi(
            investment=assessment["investment"],
            annual_benefit=assessment["annual_benefit"],
            annual_cost=assessment["annual_cost"],
        )
 
        cash_flows = [
            assessment["annual_benefit"] - assessment["annual_cost"]
        ] * 3  # 3年間
 
        npv = self.calculate_npv(assessment["investment"], cash_flows)
        irr = self.calculate_irr(assessment["investment"], cash_flows)
 
        report = f"""
## ROI分析レポート
 
### 投資概要
- 初期投資額: {assessment['investment']:,}円
- 年間期待効果: {assessment['annual_benefit']:,}円
- 年間運用コスト: {assessment['annual_cost']:,}円
 
### 主要指標
- **ROI**: {simple['roi_percentage']}%
- **投資回収期間**: {simple['payback_months']}ヶ月
- **NPV（3年、割引率{self.discount_rate*100}%）**: {npv['npv']:,}円
- **IRR**: {irr}%
 
### 判定
{'投資推奨: ROI 100%以上、回収12ヶ月以内' if simple['roi_percentage'] > 100
 else '要検討: ROIまたは回収期間の改善が必要'}
"""
        return report
 
 
# 使用例
calculator = ROICalculator()
 
# カスタマーサポートAI導入のROI
result = calculator.calculate_simple_roi(
    investment=8_000_000,
    annual_benefit=17_400_000,
    annual_cost=3_600_000,
)
print(f"ROI: {result['roi_percentage']}%")
print(f"回収期間: {result['payback_months']}ヶ月")
 
# NPV計算
npv = calculator.calculate_npv(
    investment=8_000_000,
    cash_flows=[13_800_000, 13_800_000, 13_800_000],
)
print(f"NPV: {npv['npv']:,}円")

# AIコンサルティングプロジェクト管理
project_phases = {
    "Phase 0: Discovery (1-2週間)": {
        "activities": [
            "ステークホルダーインタビュー",
            "現行業務フロー分析",
            "データ品質評価",
            "技術環境調査"
        ],
        "deliverables": ["アセスメントレポート", "提案書"],
        "success_criteria": "経営層の承認"
    },
    "Phase 1: PoC (2-4週間)": {
        "activities": [
            "プロトタイプ開発",
            "限定データでのAI検証",
            "精度・性能測定",
            "ユーザーテスト"
        ],
        "deliverables": ["PoCレポート", "デモ", "Go/No-Go判定"],
        "success_criteria": "精度目標達成 + ビジネス価値確認"
    },
    "Phase 2: Build (1-3ヶ月)": {
        "activities": [
            "本番システム開発",
            "既存システム統合",
            "セキュリティ対策",
            "負荷テスト"
        ],
        "deliverables": ["本番システム", "運用マニュアル"],
        "success_criteria": "SLA要件達成"
    },
    "Phase 3: Launch & Optimize (継続)": {
        "activities": [
            "段階的ロールアウト",
            "モニタリング設定",
            "モデル改善",
            "社員トレーニング"
        ],
        "deliverables": ["月次レポート", "改善提案"],
        "success_criteria": "ROI目標達成"
    }
}

class ProjectManagement:
    """AIコンサルティングプロジェクト管理"""
 
    def __init__(self, project_name: str, client: str):
        self.project_name = project_name
        self.client = client
        self.status = "initiated"
        self.risks = []
        self.milestones = []
 
    def create_project_charter(self) -> dict:
        """プロジェクト憲章の作成"""
        return {
            "project_name": self.project_name,
            "client": self.client,
            "objective": "",
            "scope": {
                "in_scope": [],
                "out_of_scope": [],
            },
            "stakeholders": {
                "executive_sponsor": "",
                "project_owner": "",
                "technical_lead": "",
                "end_users": [],
            },
            "timeline": {
                "start_date": "",
                "target_end_date": "",
                "key_milestones": [],
            },
            "budget": {
                "total": 0,
                "breakdown": {},
            },
            "success_criteria": [],
            "assumptions": [],
            "constraints": [],
        }
 
    def create_status_report(self, week: int, data: dict) -> str:
        """週次ステータスレポート生成"""
        report = f"""
# 週次ステータスレポート - Week {week}
 
## プロジェクト: {self.project_name}
## クライアント: {self.client}
 
### 進捗サマリー
- 全体進捗: {data.get('overall_progress', 0)}%
- 今週の完了タスク: {', '.join(data.get('completed_tasks', []))}
- 来週の予定タスク: {', '.join(data.get('planned_tasks', []))}
 
### ハイライト
{chr(10).join(f'- {h}' for h in data.get('highlights', []))}
 
### リスク・課題
{chr(10).join(f'- [{r["severity"]}] {r["description"]}: {r["action"]}'
              for r in data.get('risks', []))}
 
### KPI
| 指標 | 目標 | 現在値 | ステータス |
|------|------|--------|-----------|
"""
        for kpi in data.get('kpis', []):
            status = "達成" if kpi['current'] >= kpi['target'] else "未達"
            report += (f"| {kpi['name']} | {kpi['target']} | "
                      f"{kpi['current']} | {status} |\n")
 
        return report
 
    def create_handover_document(self, system_info: dict) -> dict:
        """引き継ぎドキュメントテンプレート"""
        return {
            "system_overview": {
                "architecture": system_info.get("architecture", ""),
                "components": system_info.get("components", []),
                "data_flow": system_info.get("data_flow", ""),
            },
            "operational_guide": {
                "daily_tasks": [
                    "AI出力品質のサンプルチェック（10件/日）",
                    "エラーログの確認",
                    "使用量・コストの確認",
                ],
                "weekly_tasks": [
                    "精度メトリクスの集計・レポート",
                    "ユーザーフィードバックの確認",
                    "コスト最適化の検討",
                ],
                "monthly_tasks": [
                    "月次レポート作成",
                    "モデル/プロンプト改善の検討",
                    "新機能要望の整理",
                ],
            },
            "troubleshooting": {
                "common_issues": [
                    {
                        "issue": "AI APIのレスポンスが遅い",
                        "cause": "APIプロバイダ側の負荷",
                        "solution": "フォールバックモデルに切替。"
                                    "キャッシュヒット率を確認。",
                    },
                    {
                        "issue": "AI出力の品質低下",
                        "cause": "入力データの変化、プロンプトの劣化",
                        "solution": "入力データの分布を確認。"
                                    "プロンプトのA/Bテスト実施。",
                    },
                ],
            },
            "escalation": {
                "l1_support": "社内運用チーム",
                "l2_support": "コンサルタント（月次契約内）",
                "emergency": "緊急連絡先: xxx-xxxx-xxxx",
            },
        }

class PoCFramework:
    """PoC（概念実証）の設計と評価フレームワーク"""
 
    @staticmethod
    def design_poc(requirements: dict) -> dict:
        """PoC設計"""
        return {
            "objective": requirements.get("objective", ""),
            "hypothesis": requirements.get("hypothesis", ""),
            "scope": {
                "data": "本番データの10-20%サンプル",
                "users": "3-5名のテストユーザー",
                "duration": "2-4週間",
                "features": "コア機能1つのみ",
            },
            "success_criteria": {
                "accuracy": {
                    "metric": requirements.get("accuracy_metric", "F1"),
                    "threshold": requirements.get("accuracy_threshold", 0.85),
                    "measurement": "テストデータセットでの評価",
                },
                "performance": {
                    "latency_p50": "1秒以内",
                    "latency_p95": "3秒以内",
                    "throughput": "10 req/sec以上",
                },
                "user_acceptance": {
                    "satisfaction": "テストユーザーの70%が「使いたい」",
                    "usability": "SUS 70以上",
                },
                "cost": {
                    "api_cost_per_request": "50円以内",
                    "monthly_projection": "予算の120%以内",
                },
            },
            "go_no_go_criteria": {
                "go": "4指標中3つ以上を達成",
                "conditional_go": "2つ達成 + 改善計画あり",
                "no_go": "1つ以下の達成 → ピボットまたは中止",
            },
        }
 
    @staticmethod
    def evaluate_poc(results: dict, criteria: dict) -> dict:
        """PoC結果の評価"""
        scores = {}
        passed = 0
        total = 0
 
        for category, threshold in criteria.items():
            if category in results:
                actual = results[category]
                target = threshold.get("threshold", 0)
                is_passed = actual >= target
                scores[category] = {
                    "actual": actual,
                    "target": target,
                    "passed": is_passed,
                }
                if is_passed:
                    passed += 1
                total += 1
 
        recommendation = (
            "GO" if passed >= total * 0.75 else
            "CONDITIONAL GO" if passed >= total * 0.5 else
            "NO GO"
        )
 
        return {
            "scores": scores,
            "passed": passed,
            "total": total,
            "recommendation": recommendation,
        }

# BAD: 技術的に面白いが、ビジネス価値が不明確
proposal_bad = {
    "title": "最新GPT-4o + RAG + ベクトルDB導入提案",
    "focus": "技術アーキテクチャの先進性",
    "roi": "算定なし",
    "result": "経営層: 「で、いくら儲かるの？」→ 却下"
}
 
# GOOD: ビジネス課題起点で技術は手段として説明
proposal_good = {
    "title": "カスタマーサポートコスト40%削減 AI導入提案",
    "focus": "コスト削減額と顧客満足度向上",
    "roi": "初年度ROI 117%、投資回収5.5ヶ月",
    "technology": "補足資料に記載（興味ある方向け）",
    "result": "経営層: 「すぐ始めよう」→ 受注"
}

# BAD: PoCは成功するが本番移行しない
poc_trap = {
    "poc_success_rate": "80%",
    "production_rate": "20%",  # PoC成功の25%しか本番化しない
    "reason": "PoCのゴール設定が曖昧、本番要件を考慮していない"
}
 
# GOOD: PoCに本番移行基準を最初から組み込む
poc_with_exit_criteria = {
    "go_criteria": [
        "精度: 目標値の90%以上を達成",
        "速度: レスポンスタイム2秒以内",
        "コスト: API費用が月10万円以内",
        "ユーザー: テストユーザーの70%以上が「使いたい」"
    ],
    "no_go_action": "ピボットまたは中止（追加投資しない）",
    "go_action": "Phase 2の予算承認を同時に取得"
}

# BAD: プロジェクト中に要件が際限なく膨らむ
scope_creep = {
    "original_scope": "カスタマーサポートチャットボット",
    "week_2": "+ メール対応も追加して",
    "week_4": "+ 電話の文字起こしも",
    "week_6": "+ 営業部門のFAQも対応して",
    "result": "予算2倍、期間3倍、品質低下"
}
 
# GOOD: 変更管理プロセスを導入
change_management = {
    "process": [
        "1. 変更要求を書面で受領",
        "2. 影響分析（コスト、期間、品質）",
        "3. 見積書を提出",
        "4. クライアント承認後に実施",
    ],
    "template": {
        "change_request_id": "CR-001",
        "description": "メール対応機能の追加",
        "impact_cost": "+1,500,000円",
        "impact_timeline": "+3週間",
        "priority": "medium",
        "approval_required": True,
    },
}

# BAD: 実績作りのために安く受ける
underpricing = {
    "quote": 500_000,  # 相場の1/3
    "actual_hours": 200,  # 想定の3倍
    "effective_rate": 2500,  # 時給2,500円
    "result": "疲弊、品質低下、クライアントの期待値も歪む"
}
 
# GOOD: バリューベースの価格設定
value_pricing = {
    "client_current_cost": 20_000_000,  # 年間2000万円の課題
    "expected_saving": 12_000_000,  # 60%削減
    "fee": 3_000_000,  # 削減額の25%
    "value_ratio": 4.0,  # クライアントにとって4倍のリターン
    "message": "300万円の投資で1200万円の削減。ROI 300%です。"
}

# 演習1: 基本実装のテンプレート
class Exercise1:
    """基本的な実装パターンの演習"""
 
    def __init__(self):
        self.data = []
 
    def validate_input(self, value):
        """入力値の検証"""
        if value is None:
            raise ValueError("入力値がNoneです")
        return True
 
    def process(self, value):
        """データ処理のメインロジック"""
        self.validate_input(value)
        self.data.append(value)
        return self.data
 
    def get_results(self):
        """処理結果の取得"""
        return {
            'count': len(self.data),
            'data': self.data
        }
 
# テスト
def test_exercise1():
    ex = Exercise1()
    assert ex.process(1) == [1]
    assert ex.process(2) == [1, 2]
    assert ex.get_results()['count'] == 2
 
    try:
        ex.process(None)
        assert False, "例外が発生するべき"
    except ValueError:
        pass
 
    print("全テスト合格!")
 
test_exercise1()

# 演習2: 応用パターン
from typing import List, Dict, Optional
from datetime import datetime
 
class AdvancedExercise:
    """応用パターンの演習"""
 
    def __init__(self, max_size: int = 100):
        self._items: List[Dict] = []
        self._max_size = max_size
        self._created_at = datetime.now()
 
    def add(self, key: str, value: any) -> bool:
        """アイテムの追加（サイズ制限付き）"""
        if len(self._items) >= self._max_size:
            return False
        self._items.append({
            'key': key,
            'value': value,
            'timestamp': datetime.now().isoformat()
        })
        return True
 
    def find(self, key: str) -> Optional[Dict]:
        """キーによる検索"""
        for item in reversed(self._items):
            if item['key'] == key:
                return item
        return None
 
    def remove(self, key: str) -> bool:
        """キーによる削除"""
        for i, item in enumerate(self._items):
            if item['key'] == key:
                self._items.pop(i)
                return True
        return False
 
    def stats(self) -> Dict:
        """統計情報"""
        return {
            'total_items': len(self._items),
            'max_size': self._max_size,
            'usage_percent': len(self._items) / self._max_size * 100,
            'uptime': str(datetime.now() - self._created_at)
        }
 
# テスト
def test_advanced():
    ex = AdvancedExercise(max_size=3)
    assert ex.add("a", 1) == True
    assert ex.add("b", 2) == True
    assert ex.add("c", 3) == True
    assert ex.add("d", 4) == False  # サイズ制限
    assert ex.find("b")['value'] == 2
    assert ex.remove("b") == True
    assert ex.find("b") is None
    stats = ex.stats()
    assert stats['total_items'] == 2
    print("応用テスト全合格!")
 
test_advanced()

# 演習3: パフォーマンス最適化
import time
from functools import lru_cache
 
# 最適化前（O(n^2)）
def slow_search(data: list, target: int) -> int:
    """非効率な検索"""
    for i in range(len(data)):
        for j in range(i + 1, len(data)):
            if data[i] + data[j] == target:
                return (i, j)
    return (-1, -1)
 
# 最適化後（O(n)）
def fast_search(data: list, target: int) -> tuple:
    """ハッシュマップを使った効率的な検索"""
    seen = {}
    for i, num in enumerate(data):
        complement = target - num
        if complement in seen:
            return (seen[complement], i)
        seen[num] = i
    return (-1, -1)
 
# ベンチマーク
def benchmark():
    import random
    data = list(range(5000))
    random.shuffle(data)
    target = data[100] + data[4000]
 
    start = time.time()
    result1 = slow_search(data, target)
    slow_time = time.time() - start
 
    start = time.time()
    result2 = fast_search(data, target)
    fast_time = time.time() - start
 
    print(f"非効率版: {slow_time:.4f}秒")
    print(f"効率版:   {fast_time:.6f}秒")
    print(f"高速化率: {slow_time/fast_time:.0f}倍")
 
benchmark()