# 成功AI SaaSの共通パターンを定量分析
class SuccessPatternAnalyzer:
    """成功AI SaaSの共通DNA分析"""
 
    def analyze_common_patterns(self) -> dict:
        """共通成功パターンの抽出"""
        return {
            "timing": {
                "pattern": "新技術リリース後6ヶ月以内にMVP",
                "examples": {
                    "jasper": "GPT-3リリース(2020.06)→創業(2021.01)",
                    "midjourney": "Diffusion Models論文→創業(2022.02)",
                    "cursor": "Codex/Copilot→Fork IDE(2022.09)"
                },
                "insight": "技術の窓が開いてから半年が最適参入時期"
            },
            "focus": {
                "pattern": "1つのユースケースに極度に集中",
                "examples": {
                    "jasper": "マーケティングコピー（最初はFacebook広告のみ）",
                    "otter": "会議録文字起こし（他は一切やらない）",
                    "midjourney": "画像生成（テキストは対象外）"
                },
                "insight": "「この1つのことだけは世界一」を作る"
            },
            "distribution": {
                "pattern": "既存のコミュニティ/プラットフォームを活用",
                "examples": {
                    "midjourney": "Discord（コミュニティが製品体験の場）",
                    "copilot": "GitHub/VSCode（既存開発者ベース）",
                    "notion_ai": "Notionユーザー3000万人"
                },
                "insight": "ゼロからユーザーを集めるより既存の集団にリーチ"
            },
            "monetization": {
                "pattern": "価値に明確に紐づく価格設定",
                "examples": {
                    "jasper": "コピーライター月額$5000→Jasper月額$49",
                    "copilot": "開発者の生産性55%向上→月額$19",
                    "cursor": "IDE + AI = 開発速度2倍→月額$20"
                },
                "insight": "「代替手段の1/10以下」が初期の最適価格"
            }
        }
 
    def calculate_success_score(self, product: dict) -> float:
        """プロダクトの成功スコアを算出（100点満点）"""
        scores = {
            "timing_score": self._score_timing(product),
            "focus_score": self._score_focus(product),
            "distribution_score": self._score_distribution(product),
            "monetization_score": self._score_monetization(product),
            "moat_score": self._score_moat(product)
        }
        weights = {
            "timing_score": 0.15,
            "focus_score": 0.25,
            "distribution_score": 0.25,
            "monetization_score": 0.15,
            "moat_score": 0.20
        }
        total = sum(scores[k] * weights[k] for k in scores)
        return round(total, 1)
 
    def _score_timing(self, product: dict) -> float:
        months_after_tech = product.get("months_after_base_tech", 12)
        if months_after_tech <= 6:
            return 100
        elif months_after_tech <= 12:
            return 75
        elif months_after_tech <= 24:
            return 50
        return 25
 
    def _score_focus(self, product: dict) -> float:
        use_cases = product.get("initial_use_cases", 1)
        return min(100, 100 / use_cases)
 
    def _score_distribution(self, product: dict) -> float:
        existing_users = product.get("leveraged_existing_users", 0)
        if existing_users > 1_000_000:
            return 100
        elif existing_users > 100_000:
            return 75
        elif existing_users > 10_000:
            return 50
        return 25
 
    def _score_monetization(self, product: dict) -> float:
        value_ratio = product.get("value_to_price_ratio", 1)
        if value_ratio >= 10:
            return 100
        elif value_ratio >= 5:
            return 75
        elif value_ratio >= 3:
            return 50
        return 25
 
    def _score_moat(self, product: dict) -> float:
        moat_layers = product.get("moat_layers", 0)
        return min(100, moat_layers * 25)

jasper_strategy = {
    "initial_moat": {
        "description": "GPT-3の早期採用 + マーケティング特化",
        "strength": "高（先行者利益）",
        "durability": "低（API依存、模倣容易）"
    },
    "evolved_moat": {
        "brand_voice": "企業ごとのトーン学習 → 一貫性担保",
        "templates": "50+ マーケティングテンプレート",
        "workflows": "企画→生成→編集→公開の一気通貫",
        "team_features": "承認フロー、ブランドガイドライン統合",
        "strength": "中〜高",
        "durability": "中（切り替えコストが上昇）"
    },
    "key_lesson": "APIラッパーから始めても、ワークフロー統合で"
                  "差別化を積み上げることでモートを構築できる"
}

jasper_growth_hacks = {
    "affiliate_program": {
        "description": "アフィリエイト報酬30%の永続コミッション",
        "impact": "初期ユーザーの40%がアフィリエイト経由",
        "cost": "売上の12%程度（CACとして非常に安い）",
        "implementation": """
            # アフィリエイト追跡の概念的実装
            class AffiliateTracker:
                def track_referral(self, referrer_id, new_user_id):
                    # Cookieベースの30日間追跡
                    attribution = {
                        "referrer": referrer_id,
                        "new_user": new_user_id,
                        "commission_rate": 0.30,
                        "type": "recurring",  # 永続コミッション
                        "cookie_window": 30    # 日
                    }
                    self.save_attribution(attribution)
 
                def calculate_monthly_payout(self, referrer_id):
                    referred_users = self.get_active_referred(referrer_id)
                    total = sum(
                        u.monthly_payment * 0.30
                        for u in referred_users
                    )
                    return total
        """,
        "lesson": "アフィリエイターが「稼げる」仕組みを作ると自走する"
    },
    "template_marketplace": {
        "description": "ユーザーが作ったテンプレートを共有",
        "impact": "テンプレート数が10倍に増加、コミュニティ形成",
        "moat": "ユーザー生成コンテンツ = 移行困難",
        "lesson": "ユーザーに価値を作らせる仕組みが最強のモート"
    },
    "community_strategy": {
        "description": "Facebookグループ10万人のコミュニティ構築",
        "activities": [
            "週次のライブセッション（使い方指導）",
            "ユーザー同士のティップス共有",
            "新機能のベータテスト先行公開",
            "成功事例の表彰（月間ベストユーザー）"
        ],
        "impact": "解約率の大幅改善（コミュニティ参加者は50%低い解約率）",
        "lesson": "プロダクトの周りにコミュニティを作ると解約率が劇的に下がる"
    },
    "content_marketing": {
        "description": "SEOとYouTubeで教育コンテンツを大量生産",
        "channels": {
            "blog": "月20記事（AIコピーライティング関連）",
            "youtube": "週2本（チュートリアル、比較動画）",
            "webinar": "月2回（成功事例、使い方講座）"
        },
        "impact": "オーガニックトラフィック月間50万PV",
        "lesson": "教育コンテンツがCAC最小の獲得チャネル"
    }
}

jasper_crisis_response = {
    "chatgpt_impact": {
        "timing": "2022年11月 — ChatGPTリリース",
        "immediate_effect": "新規登録のペース鈍化、「Jasper不要論」がSNSで拡散",
        "stock_price_equivalent": "評価額の実質的な下落（次ラウンドが困難に）",
        "user_reaction": {
            "churned_users": "無料でChatGPTが使えるなら不要と考えた層",
            "retained_users": "チーム機能、ブランドボイス、ワークフローが必要な層"
        }
    },
    "strategic_response": {
        "step_1": {
            "action": "ポジショニングの変更",
            "before": "AIコピーライティングツール",
            "after": "AIマーケティングプラットフォーム",
            "reason": "ChatGPTとの直接比較を避ける"
        },
        "step_2": {
            "action": "エンタープライズ機能の強化",
            "features": [
                "ブランドボイスの全社統一管理",
                "承認ワークフロー（マネージャー承認機能）",
                "コンプライアンスチェック自動化",
                "SSO/SAML認証",
                "監査ログ"
            ],
            "reason": "個人ユーザーはChatGPTに流れるが、企業は「管理」が必要"
        },
        "step_3": {
            "action": "独自AI研究への投資",
            "initiatives": [
                "マーケティング特化のファインチューニングモデル",
                "ブランドボイス学習の独自アルゴリズム",
                "SEO最適化スコアリングエンジン"
            ],
            "reason": "GPT-4だけに依存しないAI能力の構築"
        }
    },
    "outcome": {
        "retained_revenue": "エンタープライズ契約の増加で売上を維持",
        "lesson": "ChatGPT衝撃に耐えたのは「ワークフロー統合」があったから。"
                  "単なるAI生成ツールだったら消滅していた。"
    }
}

copyai_lessons = {
    "pivot_timing": {
        "trigger": "ChatGPTの登場でコモディティ化",
        "decision": "汎用→特化（セールスワークフロー）",
        "result": "差別化回復、成長再加速"
    },
    "differentiation": {
        "before": "テキスト生成（誰でもできる）",
        "after": "セールスワークフロー統合（CRM連携が参入障壁）",
        "moat": "データ統合 + ワークフロー + 業界知識"
    },
    "key_metrics": {
        "before_pivot": {"growth": "停滞", "churn": "高"},
        "after_pivot": {"growth": "月20%+", "churn": "大幅改善"}
    }
}

class PivotFramework:
    """AI SaaSのピボット判断と実行フレームワーク"""
 
    def assess_pivot_signals(self, metrics: dict) -> dict:
        """ピボットすべきシグナルの検出"""
        signals = {
            "churn_increasing": {
                "threshold": "月次チャーン率が3ヶ月連続で悪化",
                "current": metrics.get("churn_trend", []),
                "severity": "高",
                "explanation": "プロダクトの根本的な価値提供に問題"
            },
            "commoditization": {
                "threshold": "競合が5社以上、価格競争が激化",
                "current": metrics.get("competitor_count", 0),
                "severity": "高",
                "explanation": "差別化が失われている"
            },
            "cac_increasing": {
                "threshold": "CACが3ヶ月連続で上昇",
                "current": metrics.get("cac_trend", []),
                "severity": "中",
                "explanation": "獲得効率の悪化は市場の飽和を示す"
            },
            "nps_declining": {
                "threshold": "NPSが20以下に低下",
                "current": metrics.get("nps", 0),
                "severity": "中",
                "explanation": "ユーザー満足度の根本的な問題"
            },
            "market_disruption": {
                "threshold": "ChatGPTのような破壊的プロダクトの登場",
                "current": metrics.get("disruptor_appeared", False),
                "severity": "最高",
                "explanation": "市場の前提条件が変わった"
            }
        }
 
        triggered = {k: v for k, v in signals.items()
                     if self._is_triggered(v, metrics)}
        should_pivot = len(triggered) >= 2
 
        return {
            "triggered_signals": triggered,
            "recommendation": "PIVOT" if should_pivot else "STAY",
            "confidence": len(triggered) / len(signals)
        }
 
    def design_pivot(self, current: dict, target: dict) -> dict:
        """ピボット計画の設計"""
        return {
            "phase_1_validate": {
                "duration": "2-4週間",
                "actions": [
                    "新しいターゲット市場の10人にインタビュー",
                    "MVPのプロトタイプ（UI/UXモック）を作成",
                    "価格感度の確認（払う意思があるか）",
                    "既存アセットの活用可能性を評価"
                ],
                "go_criteria": "10人中7人以上が「使いたい」と回答"
            },
            "phase_2_build": {
                "duration": "4-6週間",
                "actions": [
                    "既存コードベースから再利用できる部分を特定",
                    "新しいコアフロー（ワークフロー）の実装",
                    "CRM連携等の統合機能を最低1つ実装",
                    "価格設定の確定"
                ],
                "go_criteria": "10社がベータ利用に合意"
            },
            "phase_3_transition": {
                "duration": "2-3ヶ月",
                "actions": [
                    "既存ユーザーへの丁寧な移行案内",
                    "新プロダクトのPMF検証",
                    "旧プロダクトの段階的縮小",
                    "マーケティングメッセージの完全切り替え"
                ],
                "go_criteria": "新プロダクトのNRRが100%以上"
            }
        }
 
    def _is_triggered(self, signal: dict, metrics: dict) -> bool:
        """シグナルが発動しているかチェック"""
        # 実装は簡略化
        return False

copyai_sales_workflow = {
    "lead_research": {
        "description": "ターゲット企業のリサーチを自動化",
        "inputs": ["企業名", "担当者名", "LinkedIn URL"],
        "ai_process": [
            "企業の最新ニュース、プレスリリースを収集",
            "担当者のSNS投稿、登壇情報を分析",
            "企業の課題と購買シグナルを特定",
            "アプローチ角度の提案"
        ],
        "output": "構造化されたリサーチレポート",
        "time_saved": "1リード30分→3分（90%削減）"
    },
    "email_generation": {
        "description": "パーソナライズされたセールスメールの自動生成",
        "personalization_levels": {
            "level_1": "企業名・名前の差し込み（従来型）",
            "level_2": "業界特化の課題言及（AI分析）",
            "level_3": "個人の投稿・発言を引用（ディープパーソナライズ）"
        },
        "metrics": {
            "open_rate": "Level 1: 25% → Level 3: 55%",
            "reply_rate": "Level 1: 3% → Level 3: 15%",
            "meeting_rate": "Level 1: 0.5% → Level 3: 5%"
        }
    },
    "follow_up_sequence": {
        "description": "フォローアップの自動スケジュールと実行",
        "sequence": [
            {"day": 0, "action": "初回メール送信"},
            {"day": 3, "action": "LinkedIn接続リクエスト"},
            {"day": 5, "action": "フォローアップメール（新しい角度）"},
            {"day": 10, "action": "価値提供メール（事例/ホワイトペーパー）"},
            {"day": 15, "action": "最終フォロー（直接的なCTA）"}
        ],
        "ai_adaptation": "各ステップで反応を分析し、次のアクションを最適化"
    },
    "crm_integration": {
        "description": "Salesforce/HubSpotとのネイティブ連携",
        "sync_data": [
            "リサーチ結果→CRMのメモ欄",
            "メール履歴→活動ログ",
            "エンゲージメントスコア→リードスコアリング",
            "商談フェーズの自動更新"
        ],
        "moat_effect": "CRM連携は一度設定すると移行が困難 → 強力なスイッチングコスト"
    }
}

class AIIntegrationPatterns:
    """既存プロダクトへのAI統合パターン集"""
 
    def get_patterns(self) -> dict:
        return {
            "inline_assistance": {
                "description": "ユーザーの作業中にAIが補完・提案",
                "examples": [
                    "Notion AI: テキスト選択→AI編集メニュー",
                    "GitHub Copilot: コード入力中にリアルタイム補完",
                    "Grammarly: 文章入力中に自動校正・提案"
                ],
                "ux_principle": "ユーザーのフローを中断しない",
                "implementation_tip": "ショートカットキーで即起動、"
                                      "ESCで即非表示にする"
            },
            "workspace_qa": {
                "description": "蓄積されたデータに対するAI質問応答",
                "examples": [
                    "Notion AI Q&A: ワークスペース全体を検索・回答",
                    "Slack AI: チャンネル横断の質問応答",
                    "Confluence AI: ナレッジベース検索"
                ],
                "ux_principle": "「情報を探す」から「質問する」への転換",
                "implementation_tip": "RAG（検索拡張生成）で"
                                      "最新情報を反映させる"
            },
            "automated_workflows": {
                "description": "定型作業をAIが自動実行",
                "examples": [
                    "Notion AI: ミーティングノート→アクションアイテム自動抽出",
                    "HubSpot AI: リード情報→パーソナライズメール自動生成",
                    "Zapier AI: ワークフロー提案・自動構築"
                ],
                "ux_principle": "ユーザーが気づく前に終わっている",
                "implementation_tip": "最初はドラフト生成→確認→実行の"
                                      "3ステップで信頼を構築"
            },
            "intelligent_insights": {
                "description": "データを分析しインサイトを能動的に提示",
                "examples": [
                    "Amplitude AI: ユーザー行動の異常検知と要因分析",
                    "Datadog AI: インシデントの根本原因の自動推定",
                    "Tableau AI: ダッシュボードからの自動インサイト"
                ],
                "ux_principle": "データを見に行くのではなく、"
                                "インサイトが来る",
                "implementation_tip": "最初は精度重視、偽陽性が多いと"
                                      "信頼を失い無視されるようになる"
            }
        }
 
    def calculate_integration_roi(self, existing_product: dict) -> dict:
        """AI統合のROI試算"""
        users = existing_product["active_users"]
        arpu = existing_product["arpu"]
        ai_addon_price = existing_product.get("ai_addon_price", 1000)
        ai_adoption_rate = existing_product.get("ai_adoption_rate", 0.15)
 
        # 新規収益
        ai_revenue = users * ai_adoption_rate * ai_addon_price
        # チャーン改善効果
        churn_reduction = 0.02  # 2%ポイント改善想定
        retention_revenue = users * arpu * churn_reduction * 12
 
        # コスト
        development_cost = 5_000_000  # 開発費（初期）
        api_cost_monthly = users * ai_adoption_rate * 500  # 1ユーザー500円/月
 
        return {
            "monthly_ai_revenue": int(ai_revenue),
            "annual_retention_revenue": int(retention_revenue),
            "monthly_api_cost": int(api_cost_monthly),
            "development_cost": development_cost,
            "monthly_net": int(ai_revenue - api_cost_monthly),
            "payback_months": round(
                development_cost / (ai_revenue - api_cost_monthly), 1
            ),
            "year1_roi": round(
                ((ai_revenue - api_cost_monthly) * 12 +
                 retention_revenue - development_cost) /
                development_cost * 100, 1
            )
        }

failure_patterns = {
    "thin_wrapper": {
        "description": "APIの薄いラッパー",
        "examples": "多数の無名GPTラッパーサービス",
        "failure_rate": "90%以上",
        "reason": "ChatGPT/Claude直接利用で代替可能"
    },
    "no_focus": {
        "description": "あれもこれもAI機能を追加",
        "examples": "汎用AIアシスタント系",
        "failure_rate": "80%以上",
        "reason": "特定課題の深い解決に至らない"
    },
    "tech_first": {
        "description": "技術は凄いがユースケースが不明確",
        "examples": "先進的MLモデルのデモサイト",
        "failure_rate": "70%以上",
        "reason": "ユーザーの課題に紐づいていない"
    }
}

differentiation_checklist = {
    "must_have": {
        "workflow_integration": {
            "question": "ユーザーの既存ワークフローに組み込まれているか？",
            "good_example": "JasperのWordPress/Google Docs統合",
            "bad_example": "独立したWebアプリでコピペが必要",
            "weight": 5
        },
        "switching_cost": {
            "question": "ユーザーが蓄積したデータ/設定が移行障壁になっているか？",
            "good_example": "Notionのワークスペース全体がAIのコンテキスト",
            "bad_example": "履歴が保存されず毎回ゼロから",
            "weight": 5
        },
        "team_features": {
            "question": "チーム利用を前提とした機能があるか？",
            "good_example": "Jasperの承認フロー、ブランドボイス統一",
            "bad_example": "個人用途のみ",
            "weight": 4
        }
    },
    "should_have": {
        "data_moat": {
            "question": "使うほどAIの精度が上がる仕組みがあるか？",
            "good_example": "CursorはユーザーのコードベースでAIを改善",
            "bad_example": "全ユーザーに同じAI品質",
            "weight": 4
        },
        "community": {
            "question": "ユーザーコミュニティが形成されているか？",
            "good_example": "Midjourneyの1600万人Discordコミュニティ",
            "bad_example": "ユーザー同士の接点がない",
            "weight": 3
        },
        "unique_data": {
            "question": "独自のデータセットやナレッジベースを持っているか？",
            "good_example": "Writerの企業ブランドガイドライン学習",
            "bad_example": "GPT-4のプロンプトを変えただけ",
            "weight": 4
        }
    },
    "nice_to_have": {
        "api_platform": {
            "question": "他の開発者が上にサービスを構築できるか？",
            "good_example": "OpenAIのAPI → 数千のアプリが構築",
            "bad_example": "APIが公開されていない",
            "weight": 2
        },
        "marketplace": {
            "question": "ユーザー生成コンテンツのマーケットプレイスがあるか？",
            "good_example": "Jasperのテンプレートマーケットプレイス",
            "bad_example": "公式テンプレートのみ",
            "weight": 2
        }
    }
}

cursor_case_study = {
    "overview": {
        "name": "Cursor",
        "category": "AI統合IDE",
        "founding": "2022年",
        "arr": "$100M+（2025年推定）",
        "evaluation": "$2.5B",
        "team_size": "~50人",
        "funding": "$400M+"
    },
    "strategy": {
        "initial_approach": "VSCode Fork + AI統合",
        "key_innovation": "エディタ全体がAIと統合（単なる拡張機能ではない）",
        "target_user": "プロフェッショナル開発者",
        "pricing": "$20/月（Pro）"
    },
    "growth_drivers": {
        "word_of_mouth": {
            "mechanism": "開発者がTwitterで生産性向上を投稿 → バイラル",
            "impact": "ユーザーの70%以上がオーガニック獲得"
        },
        "vscode_familiarity": {
            "mechanism": "VSCodeフォークのため学習コストゼロ",
            "impact": "既存の設定、拡張機能がそのまま使える"
        },
        "codebase_context": {
            "mechanism": "プロジェクト全体をAIのコンテキストに",
            "impact": "ChatGPTにコードをコピペする手間を解消"
        }
    },
    "differentiation_vs_copilot": {
        "copilot": "行単位の補完、GitHub統合",
        "cursor": "プロジェクト全体理解、マルチファイル編集、チャット統合",
        "key_difference": "CopilotはAI機能の追加、CursorはAIファーストのIDE体験",
        "lesson": "同じ技術（GPT-4）でもUXの設計で全く異なる価値を生める"
    },
    "moat_building": {
        "layer_1": "AI品質（Composer、Tab補完の精度）",
        "layer_2": "開発者ワークフローへの深い統合",
        "layer_3": "カスタムモデル（Cursor独自のモデル開発開始）",
        "assessment": "VSCodeがAI機能を強化しても、Cursorの「AIファースト」設計は模倣困難"
    }
}

midjourney_case_study = {
    "overview": {
        "name": "Midjourney",
        "category": "画像生成AI",
        "founding": "2022年2月",
        "arr": "$200M+（2024年推定）",
        "evaluation": "$10B（推定）",
        "team_size": "~40人",
        "funding": "$0（外部資金調達なし）"
    },
    "unique_strategy": {
        "no_website": {
            "description": "2023年末まで公式Webサイトすら持たなかった",
            "reason": "Discord内で完結する体験に全リソースを集中",
            "lesson": "全てを捨てて1つのチャネルに集中する勇気"
        },
        "discord_first": {
            "description": "DiscordサーバーがプロダクトのUI",
            "advantages": [
                "開発コストゼロ（UIを作らなくてよい）",
                "ソーシャル体験（他人の生成物が見える）",
                "コミュニティ形成が自然に起きる",
                "バイラル：「この画像、Midjourneyで作った」"
            ],
            "disadvantages": [
                "Discordに依存（プラットフォームリスク）",
                "UXの制約（コマンドラインベース）",
                "エンタープライズ向けには不向き"
            ]
        },
        "aesthetic_focus": {
            "description": "技術的な正確性より美的な品質を優先",
            "vs_dalle": "DALL-E: プロンプトの忠実再現",
            "vs_sd": "Stable Diffusion: カスタマイズ性",
            "midjourney": "Midjourney: 「美しい」画像の生成",
            "lesson": "技術仕様ではなくユーザーの感情（美しい！）で差別化"
        }
    },
    "economics": {
        "revenue_per_employee": "$5M+/人/年",
        "comparison": {
            "google": "~$1.5M/人/年",
            "meta": "~$1.6M/人/年",
            "midjourney": "~$5M+/人/年"
        },
        "reason": "40人のチームでインフラと研究に集中。"
                  "マーケ、営業、サポートをほぼゼロに"
    },
    "key_lesson": "「最小のチーム、最大のフォーカス」で"
                  "10億ドル企業を作れることの証明"
}

# BAD: Jasperの機能リストをコピー
copycat = {
    "strategy": "Jasperと同じ機能を作る",
    "features": ["ブログ生成", "コピー生成", "テンプレート"],
    "result": "後発で差別化なし → ユーザー獲得困難"
}
 
# GOOD: 成功要因を抽象化して別市場に適用
inspired = {
    "strategy": "Jasperの戦略パターンを法務市場に適用",
    "insight": "特定業務 × ワークフロー統合 × テンプレート",
    "application": "法務契約書レビューAI",
    "differentiation": "法務特化データ + リスク検出 + 承認フロー"
}

# BAD: 「Googleが参入したから勝ち目がない」
give_up = {
    "trigger": "Google/Microsoft/OpenAI が類似機能リリース",
    "reaction": "プロジェクト中止",
    "reality": "大企業は汎用的、ニッチの深い課題は解けない"
}
 
# GOOD: 大企業が取れないポジションを取る
differentiate = {
    "trigger": "Google/Microsoft/OpenAI が類似機能リリース",
    "reaction": "更にニッチ化 + ワークフロー深化",
    "examples": [
        "Cursor → VSCodeにCopilotがあっても成長",
        "Jasper → ChatGPTがあってもB2Bマーケで差別化",
        "Otter.ai → Google/MSの文字起こしに勝てている"
    ],
    "principle": "大企業は80%のユースケースに対応。残り20%の深い課題こそチャンス"
}

# BAD: バニティメトリクスに騙される
vanity_metrics_trap = {
    "trap_1": {
        "metric": "登録ユーザー数100万人！",
        "reality": "アクティブユーザーは1%（1万人）",
        "real_metric": "WAU（週次アクティブユーザー）"
    },
    "trap_2": {
        "metric": "MRR月次成長率30%！",
        "reality": "新規は多いがチャーンも15%/月",
        "real_metric": "NRR（純収益維持率）"
    },
    "trap_3": {
        "metric": "プロダクトハント1位！",
        "reality": "ローンチ日だけ急増、翌週ゼロ",
        "real_metric": "7日後リテンション率"
    }
}
 
# GOOD: 健全な指標の追跡
healthy_metrics = {
    "north_star": "週次アクティブ有料ユーザー数",
    "retention": "Day 1/7/30 リテンション率",
    "revenue_quality": "NRR（目標: 110%以上）",
    "unit_economics": "LTV/CAC（目標: 3以上）",
    "engagement": "DAU/MAU（目標: 40%以上）"
}

class AIBusinessIdeaEvaluator:
    """成功事例から学んだAI SaaS事業アイデア評価"""
 
    CRITERIA = {
        "problem_severity": {
            "weight": 5,
            "description": "課題の深刻度",
            "scoring": {
                5: "年間$10K+の損失 or 週10時間+の浪費",
                4: "年間$5K or 週5時間",
                3: "年間$1K or 週2時間",
                2: "あると便利程度",
                1: "問題が曖昧"
            }
        },
        "ai_advantage": {
            "weight": 5,
            "description": "AIによる改善度",
            "scoring": {
                5: "AIなしでは不可能な体験（例: Midjourney）",
                4: "10倍以上の改善（例: Copilot）",
                3: "3-5倍の改善",
                2: "既存ツールでも80%は実現可能",
                1: "AIの意味が薄い"
            }
        },
        "market_size": {
            "weight": 3,
            "description": "ターゲット市場の規模",
            "scoring": {
                5: "SAM $1B+",
                4: "SAM $100M-$1B",
                3: "SAM $10M-$100M",
                2: "SAM $1M-$10M",
                1: "SAM < $1M"
            }
        },
        "competition": {
            "weight": 4,
            "description": "競争環境",
            "scoring": {
                5: "競合ゼロ（新カテゴリ創造）",
                4: "競合1-2社、明確な差別化可能",
                3: "競合あるが、特定セグメントで勝てる",
                2: "レッドオーシャンだが参入余地あり",
                1: "GAFAM+が参入済み、差別化困難"
            }
        },
        "execution_feasibility": {
            "weight": 4,
            "description": "実行可能性",
            "scoring": {
                5: "4週間以内にMVP可能、APIで実現",
                4: "2ヶ月以内、技術的に明確",
                3: "3-6ヶ月、一部技術的挑戦あり",
                2: "6ヶ月以上、高度な技術力必要",
                1: "技術的に未解決の課題あり"
            }
        },
        "monetization_clarity": {
            "weight": 4,
            "description": "収益化の明確さ",
            "scoring": {
                5: "既にお金を払っている代替手段が存在",
                4: "顧客が「払う」と明言",
                3: "類似サービスの価格相場が存在",
                2: "フリーミアムから転換できるか不明",
                1: "マネタイズ方法が不明確"
            }
        },
        "moat_potential": {
            "weight": 5,
            "description": "モート構築可能性",
            "scoring": {
                5: "データ×ワークフロー×コミュニティの3層",
                4: "2層のモートが構築可能",
                3: "1層のモートが構築可能",
                2: "モートが弱い（APIラッパー寄り）",
                1: "差別化不可能"
            }
        }
    }
 
    def evaluate(self, scores: dict) -> dict:
        """アイデアを評価"""
        total = 0
        max_total = 0
        details = {}
 
        for criterion, config in self.CRITERIA.items():
            score = scores.get(criterion, 3)
            weighted = score * config["weight"]
            max_weighted = 5 * config["weight"]
            total += weighted
            max_total += max_weighted
            details[criterion] = {
                "score": score,
                "weighted": weighted,
                "max": max_weighted,
                "description": config["description"]
            }
 
        percentage = round(total / max_total * 100, 1)
        recommendation = (
            "STRONG GO" if percentage >= 80 else
            "GO" if percentage >= 65 else
            "CONDITIONAL" if percentage >= 50 else
            "NO GO"
        )
 
        return {
            "total_score": total,
            "max_score": max_total,
            "percentage": percentage,
            "recommendation": recommendation,
            "details": details
        }

growth_stagnation_diagnosis = {
    "symptom_1": {
        "symptom": "新規登録は多いが有料転換しない",
        "possible_causes": [
            "無料プランが十分すぎる",
            "有料プランの価値が不明確",
            "オンボーディングが不十分",
            "価格が高すぎる（または安すぎて価値を疑われる）"
        ],
        "diagnosis_steps": [
            "無料→有料の遷移ポイントでの離脱率を分析",
            "「なぜ有料にしなかった？」の出口アンケート実施",
            "競合の無料/有料の境界を調査",
            "価格A/Bテストの実施"
        ],
        "reference_case": "Jasper: 無料5,000ワード→有料 のゲート設計が転換率最適化の鍵"
    },
    "symptom_2": {
        "symptom": "チャーン率が改善しない",
        "possible_causes": [
            "AI品質がユーザーの期待に達していない",
            "競合に乗り換えている",
            "一時的な需要（月1回しか使わない）",
            "ワークフローに組み込まれていない"
        ],
        "diagnosis_steps": [
            "解約理由の分析（過去3ヶ月のアンケート）",
            "アクティブユーザーの使用頻度分布を確認",
            "コホート別リテンションカーブを描く",
            "パワーユーザーとチャーンユーザーの行動差異を分析"
        ],
        "reference_case": "Copy.ai: チャーン率が高かったのは市場のミスマッチ→ピボットで解決"
    },
    "symptom_3": {
        "symptom": "CACが上昇し続ける",
        "possible_causes": [
            "ターゲット市場の飽和",
            "広告の疲弊（同じクリエイティブの反復）",
            "競合の広告費増加",
            "プロダクト・マーケット・フィットの劣化"
        ],
        "diagnosis_steps": [
            "チャネル別CACの推移を確認",
            "オーガニック vs 有料の比率を確認",
            "競合の広告出稿状況を調査",
            "既存ユーザーのリファラル率を確認"
        ],
        "reference_case": "Midjourney: 広告費ゼロでCACほぼゼロ→コミュニティの力"
    }
}

competitor_response_manual = {
    "scenario_1": {
        "situation": "ChatGPTのような無料の汎用AIが登場",
        "response_playbook": [
            "パニックにならない（最初の反応が過剰になりがち）",
            "既存の有料ユーザーに連絡し状況を確認",
            "汎用AIでは解決できない具体的な課題を明確化",
            "ワークフロー統合、業界特化、チーム機能を強化",
            "「ChatGPTとの違い」を明確にしたポジショニング"
        ],
        "case_reference": "Jasperの対ChatGPT戦略（セクション2.4参照）"
    },
    "scenario_2": {
        "situation": "直接競合のスタートアップが出現",
        "response_playbook": [
            "競合の弱みではなく自社の強みにフォーカス",
            "既存ユーザーのリテンションを最優先",
            "競合がいない「ニッチのニッチ」を見つける",
            "顧客の声（testimonials）を増やしソーシャルプルーフ強化",
            "価格競争には絶対に参加しない"
        ],
        "case_reference": "Copy.aiがJasperとの差別化に苦戦→ピボットで解決"
    },
    "scenario_3": {
        "situation": "大企業（Google、Microsoft等）が参入",
        "response_playbook": [
            "大企業の弱み（遅い、汎用的、顧客対応が弱い）を特定",
            "更にニッチを深堀りする",
            "カスタマーサクセスで圧倒的な差をつける",
            "オープンソースやAPIでエコシステムを構築",
            "場合によっては大企業との連携/統合を模索"
        ],
        "case_reference": "CursorのVSCode Copilotへの対応（AIファーストの体験で差別化）"
    }
}

# 演習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()