class GrowthStageStrategy:
    """成長ステージ別の戦略選択"""
 
    STAGES = {
        "pre_seed": {
            "mrr_range": "¥0 - ¥100,000",
            "users": "0 - 100",
            "focus": "PMF探索",
            "strategy": {
                "primary": "手動営業 + 個別ヒアリング",
                "secondary": "Twitter/X での発信",
                "budget": "¥0 - ¥50,000/月",
                "team": "創業者1-2人"
            },
            "key_metrics": [
                "週間アクティブユーザー数",
                "NPS（40以上が目標）",
                "利用継続率（月次80%以上）"
            ],
            "milestones": [
                "最初の10人の有料ユーザー獲得",
                "ユーザーインタビュー30件完了",
                "コア機能のProduct-Market Fit確認"
            ]
        },
        "seed": {
            "mrr_range": "¥100,000 - ¥1,000,000",
            "users": "100 - 1,000",
            "focus": "成長チャネル実験",
            "strategy": {
                "primary": "コンテンツマーケティング（SEO）",
                "secondary": "Product Hunt ローンチ",
                "budget": "¥100,000 - ¥500,000/月",
                "team": "3-5人"
            },
            "key_metrics": [
                "MRR成長率（月15-25%）",
                "CAC（¥15,000以下）",
                "チャーン率（月5%以下）"
            ],
            "milestones": [
                "MRR ¥500,000達成",
                "CAC回収期間6ヶ月以下",
                "2つの成長チャネル確立"
            ]
        },
        "series_a": {
            "mrr_range": "¥1,000,000 - ¥10,000,000",
            "users": "1,000 - 10,000",
            "focus": "スケーリング",
            "strategy": {
                "primary": "確立チャネルへの集中投資",
                "secondary": "営業チーム立ち上げ（エンプラ向け）",
                "budget": "¥1,000,000 - ¥5,000,000/月",
                "team": "10-30人"
            },
            "key_metrics": [
                "ARR成長率（年3倍）",
                "NRR（110%以上）",
                "LTV/CAC（3以上）"
            ],
            "milestones": [
                "ARR ¥100M達成",
                "エンタープライズ契約10社",
                "国際展開開始"
            ]
        },
        "growth": {
            "mrr_range": "¥10,000,000+",
            "users": "10,000+",
            "focus": "市場リーダーシップ",
            "strategy": {
                "primary": "マルチチャネル統合マーケティング",
                "secondary": "パートナーエコシステム構築",
                "budget": "¥5,000,000+/月",
                "team": "30-100人+"
            },
            "key_metrics": [
                "市場シェア",
                "効率的成長（Rule of 40）",
                "顧客満足度"
            ],
            "milestones": [
                "市場カテゴリのリーダーポジション",
                "黒字化またはユニットエコノミクス健全化",
                "IPOまたはM&A準備"
            ]
        }
    }
 
    def recommend_strategy(self, current_mrr: float,
                           user_count: int) -> dict:
        """現在のステージに合った戦略を推薦"""
        if current_mrr < 100000:
            stage = "pre_seed"
        elif current_mrr < 1000000:
            stage = "seed"
        elif current_mrr < 10000000:
            stage = "series_a"
        else:
            stage = "growth"
 
        return {
            "current_stage": stage,
            "strategy": self.STAGES[stage],
            "next_stage": self._next_stage(stage),
            "gap_analysis": self._analyze_gaps(
                stage, current_mrr, user_count
            )
        }
 
    def _next_stage(self, current: str) -> str:
        stages = list(self.STAGES.keys())
        idx = stages.index(current)
        if idx < len(stages) - 1:
            return stages[idx + 1]
        return current
 
    def _analyze_gaps(self, stage: str, mrr: float,
                      users: int) -> list[str]:
        """次のステージへのギャップ分析"""
        gaps = []
        config = self.STAGES[stage]
        milestones = config["milestones"]
        # 簡易分析
        if stage == "pre_seed" and users < 10:
            gaps.append("最初の10人の有料ユーザーが未達成")
        if stage == "seed" and mrr < 500000:
            gaps.append("MRR ¥500,000が未達成")
        return gaps

class PLGEngine:
    """Product-Led Growth エンジン"""
 
    def __init__(self):
        self.viral_features = {}
 
    def design_viral_loop(self) -> dict:
        """バイラルループ設計"""
        return {
            "output_branding": {
                "description": "生成物に「Made with OurApp」を付与",
                "implementation": "出力HTMLにリンク埋め込み",
                "viral_coefficient": 0.3,
                "example": "Canvaの「Canvaで作成」透かし"
            },
            "collaboration": {
                "description": "チーム招待でプラン拡張",
                "implementation": "招待1人→追加100クレジット",
                "viral_coefficient": 0.5,
                "example": "Dropboxの紹介プログラム"
            },
            "template_sharing": {
                "description": "テンプレートを公開・共有",
                "implementation": "公開ギャラリー + ワンクリック複製",
                "viral_coefficient": 0.8,
                "example": "Notion テンプレートギャラリー"
            },
            "api_integration": {
                "description": "他ツールとの統合でエコシステム拡大",
                "implementation": "Zapier/n8n統合、Webhook",
                "viral_coefficient": 0.2,
                "example": "Stripe統合によるフィンテック展開"
            }
        }
 
    def calculate_growth(self, initial_users: int,
                          viral_coefficient: float,
                          organic_growth_rate: float,
                          months: int) -> list[dict]:
        """成長予測シミュレーション"""
        results = []
        users = initial_users
 
        for month in range(1, months + 1):
            organic_new = int(users * organic_growth_rate)
            viral_new = int(users * viral_coefficient)
            total_new = organic_new + viral_new
            users += total_new
 
            results.append({
                "month": month,
                "total_users": users,
                "new_organic": organic_new,
                "new_viral": viral_new,
                "growth_rate": total_new / (users - total_new)
            })
 
        return results
 
# シミュレーション
engine = PLGEngine()
growth = engine.calculate_growth(
    initial_users=100,
    viral_coefficient=0.3,
    organic_growth_rate=0.15,
    months=12
)
# Month 12: ~4,700ユーザー（月平均45%成長）

class OnboardingOptimizer:
    """PLGオンボーディング最適化"""
 
    ONBOARDING_STEPS = {
        "signup": {
            "step": 1,
            "description": "アカウント作成",
            "target_time": "30秒以内",
            "friction_reducers": [
                "Google/GitHub OAuth でワンクリック登録",
                "メール認証は後回し",
                "クレジットカード不要"
            ],
            "benchmark_completion": 0.95
        },
        "first_value": {
            "step": 2,
            "description": "最初の価値体験",
            "target_time": "2分以内",
            "friction_reducers": [
                "サンプルデータで即座にデモ実行",
                "テンプレートからワンクリック開始",
                "インタラクティブなチュートリアル"
            ],
            "benchmark_completion": 0.70
        },
        "aha_moment": {
            "step": 3,
            "description": "Aha!モーメント到達",
            "target_time": "初回セッション内",
            "friction_reducers": [
                "AI生成結果の品質を実感",
                "自分のデータでの成功体験",
                "Before/Afterの比較表示"
            ],
            "benchmark_completion": 0.50
        },
        "habit_formation": {
            "step": 4,
            "description": "習慣化（週3回以上利用）",
            "target_time": "最初の2週間",
            "friction_reducers": [
                "メールリマインダー（利用促進）",
                "新機能ハイライト通知",
                "利用状況ダッシュボード"
            ],
            "benchmark_completion": 0.30
        },
        "conversion": {
            "step": 5,
            "description": "有料転換",
            "target_time": "30日以内",
            "friction_reducers": [
                "制限到達時のスムーズなアップグレードUI",
                "14日間の無料トライアル",
                "初月割引オファー"
            ],
            "benchmark_completion": 0.05
        }
    }
 
    def analyze_funnel(self, actual_data: dict) -> dict:
        """オンボーディングファネル分析"""
        analysis = {}
        prev_rate = 1.0
 
        for step_name, config in self.ONBOARDING_STEPS.items():
            actual_rate = actual_data.get(step_name, 0)
            benchmark = config["benchmark_completion"]
            drop_off = prev_rate - actual_rate
 
            status = "good" if actual_rate >= benchmark else (
                "warning" if actual_rate >= benchmark * 0.7 else "critical"
            )
 
            analysis[step_name] = {
                "actual": f"{actual_rate*100:.1f}%",
                "benchmark": f"{benchmark*100:.1f}%",
                "drop_off": f"{drop_off*100:.1f}%",
                "status": status,
                "improvement": self._suggest_improvement(
                    step_name, actual_rate, benchmark
                )
            }
            prev_rate = actual_rate
 
        return analysis
 
    def _suggest_improvement(self, step: str,
                              actual: float,
                              benchmark: float) -> str:
        """改善提案"""
        if actual >= benchmark:
            return "ベンチマーク達成済み"
 
        suggestions = {
            "signup": "ソーシャルログインの追加、フォーム項目の削減",
            "first_value": "即座にデモ実行できるサンプルデータの提供",
            "aha_moment": "ガイド付きチュートリアルの改善",
            "habit_formation": "プッシュ通知とメールドリップの最適化",
            "conversion": "制限到達時のアップグレードUIの改善"
        }
        return suggestions.get(step, "ユーザーリサーチを実施")
 
    def design_activation_emails(self) -> list[dict]:
        """アクティベーションメール設計"""
        return [
            {
                "day": 0,
                "trigger": "signup",
                "subject": "ようこそ！最初のAI生成を試しましょう",
                "content": "ワンクリックで始められるテンプレートを3つ用意",
                "cta": "今すぐ試す",
                "goal": "first_value到達"
            },
            {
                "day": 1,
                "trigger": "no_first_value",
                "subject": "まだ試していませんか？2分で始められます",
                "content": "他のユーザーの成功事例 + デモ動画",
                "cta": "デモを見る",
                "goal": "first_value到達"
            },
            {
                "day": 3,
                "trigger": "first_value_achieved",
                "subject": "素晴らしい結果ですね！次はこれを試しましょう",
                "content": "高度な機能の紹介 + ユースケース",
                "cta": "次の機能を試す",
                "goal": "aha_moment到達"
            },
            {
                "day": 7,
                "trigger": "active_user",
                "subject": "今週のあなたの成果をまとめました",
                "content": "利用統計 + 節約時間の可視化",
                "cta": "ダッシュボードを見る",
                "goal": "habit_formation"
            },
            {
                "day": 10,
                "trigger": "approaching_limit",
                "subject": "無料枠の80%を使用しました",
                "content": "Proプランの紹介 + 特別割引",
                "cta": "Proプランを見る",
                "goal": "conversion"
            },
            {
                "day": 14,
                "trigger": "trial_ending",
                "subject": "トライアル残り3日！特別オファー",
                "content": "利用実績 + 継続しない場合の損失",
                "cta": "今すぐアップグレード",
                "goal": "conversion"
            }
        ]

class ReferralProgram:
    """リファラルプログラム"""
 
    REWARD_MODELS = {
        "one_sided": {
            "description": "紹介者のみ報酬",
            "referrer_reward": "追加500クレジット",
            "referee_reward": None,
            "pros": "コスト低い",
            "cons": "被紹介者のインセンティブ弱い",
            "expected_k": 0.2
        },
        "two_sided": {
            "description": "双方に報酬",
            "referrer_reward": "追加500クレジット",
            "referee_reward": "初月50%OFF",
            "pros": "転換率が高い",
            "cons": "コスト高い",
            "expected_k": 0.5
        },
        "tiered": {
            "description": "紹介数に応じて報酬増加",
            "tiers": [
                {"referrals": 1, "reward": "100クレジット"},
                {"referrals": 5, "reward": "1ヶ月無料"},
                {"referrals": 10, "reward": "Proプラン永久割引"},
                {"referrals": 25, "reward": "Enterpriseプラン1ヶ月"}
            ],
            "pros": "パワーユーザーの動機付け",
            "cons": "複雑",
            "expected_k": 0.4
        }
    }
 
    def calculate_referral_roi(
        self,
        referred_users: int,
        conversion_rate: float,
        arpu: float,
        avg_lifetime_months: float,
        reward_cost_per_referral: float
    ) -> dict:
        """リファラルプログラムのROI計算"""
        converted = int(referred_users * conversion_rate)
        total_revenue = converted * arpu * avg_lifetime_months
        total_cost = referred_users * reward_cost_per_referral
        roi = (total_revenue - total_cost) / total_cost * 100 if total_cost > 0 else 0
 
        return {
            "referred_users": referred_users,
            "converted_users": converted,
            "conversion_rate": f"{conversion_rate*100:.1f}%",
            "total_revenue": f"¥{total_revenue:,.0f}",
            "total_cost": f"¥{total_cost:,.0f}",
            "roi": f"{roi:.0f}%",
            "cac_via_referral": f"¥{total_cost/converted:,.0f}" if converted > 0 else "N/A",
            "verdict": "継続" if roi > 100 else "改善必要"
        }
 
    def generate_referral_link(self, user_id: str) -> dict:
        """リファラルリンク生成"""
        import hashlib
        code = hashlib.md5(f"ref_{user_id}".encode()).hexdigest()[:8]
 
        return {
            "referral_code": code,
            "referral_link": f"https://app.example.com/signup?ref={code}",
            "share_templates": {
                "twitter": f"AI自動化ツールで仕事が3倍速になりました！"
                          f"無料で試せます → https://app.example.com/signup?ref={code}",
                "email": {
                    "subject": "このAIツール、かなり使えます",
                    "body": f"最近使い始めたAI自動化ツールが良かったのでシェア。"
                           f"紹介リンクから登録すると特典あり。"
                },
                "slack": f"おすすめAIツール: https://app.example.com/signup?ref={code}"
            }
        }

class ContentMarketingEngine:
    """AI SaaS コンテンツマーケティングエンジン"""
 
    def create_content_strategy(self) -> dict:
        """コンテンツ戦略設計"""
        return {
            "pillar_content": {
                "frequency": "月2本",
                "type": "総合ガイド（3000-5000文字）",
                "purpose": "SEO権威性、リンク獲得",
                "examples": [
                    "AI自動化完全ガイド2025",
                    "AIでビジネスを変革する10の方法"
                ]
            },
            "blog_posts": {
                "frequency": "週2本",
                "type": "How-to記事（1500-2000文字）",
                "purpose": "ロングテールSEO、トラフィック",
                "examples": [
                    "ZapierでAI自動化を始める5ステップ",
                    "ChatGPT APIの費用を50%削減する方法"
                ]
            },
            "social_media": {
                "frequency": "毎日",
                "type": "Tips、事例、インサイト",
                "purpose": "認知、エンゲージメント",
                "platforms": ["Twitter", "LinkedIn"]
            },
            "case_studies": {
                "frequency": "月1本",
                "type": "顧客成功事例",
                "purpose": "信頼性、コンバージョン",
                "format": "課題→導入→成果の3部構成"
            },
            "free_tools": {
                "frequency": "四半期1個",
                "type": "無料AIツール",
                "purpose": "バイラル、リード獲得",
                "examples": [
                    "AI ROI計算ツール",
                    "プロンプトテンプレート集"
                ]
            }
        }
 
    def create_seo_content_plan(self) -> dict:
        """SEOコンテンツプラン"""
        return {
            "keyword_strategy": {
                "head_terms": {
                    "examples": ["AI自動化", "AI SaaS", "ChatGPT 活用"],
                    "difficulty": "高",
                    "approach": "ピラーページで長期的に狙う"
                },
                "long_tail": {
                    "examples": [
                        "AI 請求書 自動処理 方法",
                        "ChatGPT API 料金 比較",
                        "n8n AI ワークフロー 作り方"
                    ],
                    "difficulty": "低-中",
                    "approach": "How-to記事で個別に狙う"
                },
                "comparison": {
                    "examples": [
                        "Jasper vs Copy.ai 比較",
                        "AI文書作成ツール おすすめ"
                    ],
                    "difficulty": "中",
                    "approach": "比較記事で検討段階ユーザーを獲得"
                }
            },
            "content_calendar": {
                "week_1": {
                    "mon": "How-toブログ記事公開",
                    "wed": "ケーススタディ公開",
                    "fri": "ソーシャルメディアまとめ投稿"
                },
                "week_2": {
                    "mon": "How-toブログ記事公開",
                    "wed": "ピラーコンテンツ更新",
                    "fri": "ニュースレター配信"
                }
            }
        }
 
    def measure_content_roi(self, content: dict) -> dict:
        """コンテンツROI測定"""
        creation_cost = content["creation_hours"] * 5000  # ¥5,000/時間
        promotion_cost = content.get("promotion_cost", 0)
        total_cost = creation_cost + promotion_cost
 
        organic_traffic = content.get("monthly_traffic", 0)
        signup_rate = content.get("signup_rate", 0.02)
        signups = organic_traffic * signup_rate
        paid_conversion = content.get("paid_conversion_rate", 0.05)
        paid_users = signups * paid_conversion
        arpu = content.get("arpu", 9800)
        monthly_revenue = paid_users * arpu
 
        # 12ヶ月の累積価値
        total_value_12m = monthly_revenue * 12
 
        return {
            "total_cost": f"¥{total_cost:,.0f}",
            "monthly_traffic": organic_traffic,
            "monthly_signups": round(signups, 1),
            "monthly_paid": round(paid_users, 2),
            "monthly_revenue": f"¥{monthly_revenue:,.0f}",
            "12m_value": f"¥{total_value_12m:,.0f}",
            "roi_12m": f"{(total_value_12m/total_cost - 1)*100:.0f}%"
                       if total_cost > 0 else "N/A",
            "payback_months": round(total_cost / monthly_revenue, 1)
                             if monthly_revenue > 0 else "N/A"
        }

class SocialMediaStrategy:
    """ソーシャルメディア戦略"""
 
    PLATFORM_STRATEGIES = {
        "twitter": {
            "posting_frequency": "1日2-3回",
            "content_mix": {
                "tips_and_tricks": 0.30,
                "product_updates": 0.15,
                "industry_insights": 0.25,
                "engagement": 0.15,  # 質問、投票
                "user_generated": 0.15  # リツイート、引用
            },
            "growth_tactics": [
                "AI関連のスレッドを週1投稿（バイラル狙い）",
                "インフルエンサーへのリプライで認知獲得",
                "デモ動画の投稿（30秒以内）",
                "ユーザーの成功事例をRT＋コメント"
            ],
            "optimal_times": ["8:00", "12:00", "18:00"],
            "kpi": "フォロワー増加率、エンゲージメント率2%以上"
        },
        "linkedin": {
            "posting_frequency": "週3-5回",
            "content_mix": {
                "thought_leadership": 0.30,
                "case_studies": 0.25,
                "product_updates": 0.15,
                "industry_news": 0.20,
                "behind_the_scenes": 0.10
            },
            "growth_tactics": [
                "創業者の個人ブランディング",
                "AI導入事例の詳細投稿",
                "LinkedInニュースレターの活用",
                "業界グループでの知見共有"
            ],
            "optimal_times": ["7:30", "12:00", "17:30"],
            "kpi": "リード獲得数、商談数"
        },
        "youtube": {
            "posting_frequency": "週1本",
            "content_mix": {
                "tutorials": 0.35,
                "product_demos": 0.25,
                "industry_analysis": 0.20,
                "customer_stories": 0.10,
                "live_streams": 0.10
            },
            "growth_tactics": [
                "検索最適化されたタイトルとサムネイル",
                "5-15分の実用的なチュートリアル",
                "ショート動画で認知拡大",
                "コメント欄での積極的なエンゲージメント"
            ],
            "optimal_times": ["土曜10:00", "水曜19:00"],
            "kpi": "視聴時間、登録者増加率、CTR"
        }
    }
 
    def create_posting_schedule(self, platform: str,
                                 timezone: str = "JST") -> list[dict]:
        """投稿スケジュール生成"""
        strategy = self.PLATFORM_STRATEGIES.get(platform)
        if not strategy:
            return []
 
        schedule = []
        days = ["月", "火", "水", "木", "金"]
        content_types = list(strategy["content_mix"].keys())
 
        for i, day in enumerate(days):
            content_type = content_types[i % len(content_types)]
            for time in strategy["optimal_times"]:
                schedule.append({
                    "day": day,
                    "time": time,
                    "content_type": content_type,
                    "platform": platform
                })
 
        return schedule

class InboundSalesEngine:
    """インバウンドセールスエンジン"""
 
    LEAD_SCORING = {
        "behavioral": {
            "visited_pricing_page": 20,
            "started_free_trial": 30,
            "used_advanced_feature": 15,
            "invited_team_member": 25,
            "api_key_created": 20,
            "viewed_case_study": 10,
            "attended_webinar": 15,
            "downloaded_whitepaper": 10,
            "contacted_support": 5
        },
        "demographic": {
            "company_size_1_10": 5,
            "company_size_11_50": 10,
            "company_size_51_200": 15,
            "company_size_201_1000": 20,
            "company_size_1000_plus": 25,
            "decision_maker_title": 15,
            "target_industry": 10
        }
    }
 
    def score_lead(self, lead_data: dict) -> dict:
        """リードスコアリング"""
        behavioral_score = sum(
            self.LEAD_SCORING["behavioral"].get(action, 0)
            for action in lead_data.get("actions", [])
        )
        demographic_score = sum(
            self.LEAD_SCORING["demographic"].get(attr, 0)
            for attr in lead_data.get("attributes", [])
        )
        total_score = behavioral_score + demographic_score
 
        if total_score >= 80:
            qualification = "SQL"  # Sales Qualified Lead
            action = "営業担当者が即座にコンタクト"
        elif total_score >= 50:
            qualification = "MQL"  # Marketing Qualified Lead
            action = "ナーチャリングメール + 営業フォロー"
        elif total_score >= 20:
            qualification = "Prospect"
            action = "自動ナーチャリングメールシーケンス"
        else:
            qualification = "Visitor"
            action = "コンテンツマーケティングで教育"
 
        return {
            "lead_id": lead_data.get("id"),
            "behavioral_score": behavioral_score,
            "demographic_score": demographic_score,
            "total_score": total_score,
            "qualification": qualification,
            "recommended_action": action
        }
 
    def design_nurture_sequence(self, qualification: str) -> list[dict]:
        """ナーチャリングシーケンス設計"""
        sequences = {
            "MQL": [
                {"day": 0, "type": "email",
                 "content": "導入事例: 同業他社の成功ストーリー"},
                {"day": 3, "type": "email",
                 "content": "ROI計算: あなたの業界での期待効果"},
                {"day": 7, "type": "email",
                 "content": "デモ招待: 30分でわかる製品デモ"},
                {"day": 10, "type": "call",
                 "content": "電話フォロー: 課題のヒアリング"},
                {"day": 14, "type": "email",
                 "content": "特別オファー: 限定割引での導入提案"}
            ],
            "Prospect": [
                {"day": 0, "type": "email",
                 "content": "ウェルカムメール + 無料ガイド"},
                {"day": 7, "type": "email",
                 "content": "How-to: 最初の3ステップ"},
                {"day": 14, "type": "email",
                 "content": "ケーススタディ: 類似企業の事例"},
                {"day": 21, "type": "email",
                 "content": "ウェビナー招待"},
                {"day": 28, "type": "email",
                 "content": "無料トライアルの案内"}
            ]
        }
        return sequences.get(qualification, [])
 
 
class SalesPipeline:
    """セールスパイプライン管理"""
 
    PIPELINE_STAGES = {
        "lead": {
            "description": "リード",
            "avg_days": 0,
            "conversion_rate": 0.30,
            "actions": ["リードスコアリング", "初回メール送信"]
        },
        "qualified": {
            "description": "資格確認済み",
            "avg_days": 7,
            "conversion_rate": 0.50,
            "actions": ["ニーズヒアリング", "適合性確認"]
        },
        "demo": {
            "description": "デモ実施",
            "avg_days": 14,
            "conversion_rate": 0.60,
            "actions": ["製品デモ", "技術質問対応"]
        },
        "proposal": {
            "description": "提案中",
            "avg_days": 21,
            "conversion_rate": 0.50,
            "actions": ["見積書送付", "条件交渉"]
        },
        "negotiation": {
            "description": "交渉中",
            "avg_days": 30,
            "conversion_rate": 0.70,
            "actions": ["契約条件調整", "法務確認"]
        },
        "closed_won": {
            "description": "受注",
            "avg_days": 45,
            "conversion_rate": 1.0,
            "actions": ["契約締結", "オンボーディング開始"]
        }
    }
 
    def forecast_revenue(self, pipeline: list[dict]) -> dict:
        """パイプラインベースの収益予測"""
        forecasts = {
            "committed": 0,
            "best_case": 0,
            "pipeline": 0
        }
 
        for deal in pipeline:
            stage = deal["stage"]
            amount = deal["amount"]
            stage_config = self.PIPELINE_STAGES.get(stage, {})
            probability = stage_config.get("conversion_rate", 0)
 
            if stage == "closed_won":
                forecasts["committed"] += amount
            elif probability >= 0.6:
                forecasts["best_case"] += amount * probability
            else:
                forecasts["pipeline"] += amount * probability
 
        forecasts["total_weighted"] = (
            forecasts["committed"] +
            forecasts["best_case"] +
            forecasts["pipeline"]
        )
 
        return {
            "committed": f"¥{forecasts['committed']:,.0f}",
            "best_case": f"¥{forecasts['best_case']:,.0f}",
            "pipeline": f"¥{forecasts['pipeline']:,.0f}",
            "total_weighted": f"¥{forecasts['total_weighted']:,.0f}"
        }
 
    def calculate_pipeline_velocity(
        self,
        deals_in_pipeline: int,
        avg_deal_size: float,
        win_rate: float,
        avg_sales_cycle_days: int
    ) -> dict:
        """パイプライン速度の計算"""
        velocity = (
            deals_in_pipeline * avg_deal_size * win_rate
        ) / avg_sales_cycle_days
 
        return {
            "daily_velocity": f"¥{velocity:,.0f}/日",
            "monthly_velocity": f"¥{velocity * 30:,.0f}/月",
            "quarterly_velocity": f"¥{velocity * 90:,.0f}/四半期",
            "components": {
                "deals": deals_in_pipeline,
                "avg_size": f"¥{avg_deal_size:,.0f}",
                "win_rate": f"{win_rate*100:.0f}%",
                "cycle_days": avg_sales_cycle_days
            },
            "improvement_levers": [
                f"案件数を{int(deals_in_pipeline*1.2)}に増やす → +20%",
                f"平均単価を¥{avg_deal_size*1.15:,.0f}に → +15%",
                f"勝率を{(win_rate+0.05)*100:.0f}%に → +{0.05/win_rate*100:.0f}%",
                f"サイクルを{int(avg_sales_cycle_days*0.85)}日に → +18%"
            ]
        }

class GrowthMetrics:
    """成長メトリクス計算"""
 
    def calculate_mrr(self, subscriptions: list[dict]) -> float:
        """MRR（月次経常収益）"""
        return sum(s["monthly_amount"] for s in subscriptions
                   if s["status"] == "active")
 
    def calculate_nrr(self, start_mrr: float,
                       expansion: float,
                       contraction: float,
                       churn: float) -> float:
        """NRR（純収益維持率）"""
        return (start_mrr + expansion - contraction - churn) / start_mrr * 100
 
    def calculate_quick_ratio(self, new_mrr: float,
                                expansion_mrr: float,
                                churned_mrr: float,
                                contraction_mrr: float) -> float:
        """SaaS Quick Ratio（4以上が健全）"""
        return (new_mrr + expansion_mrr) / (churned_mrr + contraction_mrr)
 
    def calculate_payback_period(self, cac: float,
                                   arpu: float,
                                   gross_margin: float) -> float:
        """CAC回収期間（月）"""
        return cac / (arpu * gross_margin)
 
    def calculate_ltv(self, arpu: float,
                       gross_margin: float,
                       monthly_churn: float) -> float:
        """LTV（顧客生涯価値）"""
        return arpu * gross_margin / monthly_churn
 
    def rule_of_40(self, revenue_growth_rate: float,
                    profit_margin: float) -> dict:
        """Rule of 40 計算"""
        score = revenue_growth_rate + profit_margin
 
        return {
            "growth_rate": f"{revenue_growth_rate:.0f}%",
            "profit_margin": f"{profit_margin:.0f}%",
            "rule_of_40_score": f"{score:.0f}%",
            "status": "健全" if score >= 40 else "要改善",
            "interpretation": (
                "成長率と利益率の合計が40%以上 = 健全な成長"
                if score >= 40
                else "成長率を上げるか、コスト効率を改善する必要あり"
            )
        }
 
    def cohort_retention_analysis(
        self, cohorts: dict
    ) -> dict:
        """コホート別リテンション分析"""
        analysis = {}
        for cohort_name, data in cohorts.items():
            initial = data["initial_users"]
            retention = data["monthly_active"]
 
            rates = [r / initial * 100 for r in retention]
            avg_retention = sum(rates) / len(rates) if rates else 0
 
            # リテンションカーブの安定化チェック
            if len(rates) >= 3:
                recent_change = rates[-1] - rates[-2]
                stabilized = abs(recent_change) < 2.0
            else:
                stabilized = False
 
            analysis[cohort_name] = {
                "initial_users": initial,
                "retention_rates": [f"{r:.1f}%" for r in rates],
                "avg_retention": f"{avg_retention:.1f}%",
                "stabilized": stabilized,
                "latest_retention": f"{rates[-1]:.1f}%" if rates else "N/A"
            }
 
        return analysis

class MetricsDashboard:
    """メトリクスダッシュボード自動化"""
 
    def __init__(self, db, analytics):
        self.db = db
        self.analytics = analytics
 
    def generate_weekly_report(self) -> dict:
        """週次レポート自動生成"""
        return {
            "period": "今週",
            "north_star": {
                "metric": "週間アクティブ有料ユーザー",
                "current": self._get_wapu(),
                "change": self._get_wapu_change(),
                "trend": self._get_trend("wapu", 4)
            },
            "revenue": {
                "mrr": self._get_mrr(),
                "mrr_growth": self._get_mrr_growth(),
                "new_mrr": self._get_new_mrr(),
                "churned_mrr": self._get_churned_mrr(),
                "expansion_mrr": self._get_expansion_mrr()
            },
            "growth": {
                "new_signups": self._get_new_signups(),
                "activation_rate": self._get_activation_rate(),
                "conversion_rate": self._get_conversion_rate()
            },
            "health": {
                "churn_rate": self._get_churn_rate(),
                "nps": self._get_nps(),
                "support_tickets": self._get_support_tickets()
            },
            "alerts": self._generate_alerts()
        }
 
    def _generate_alerts(self) -> list[dict]:
        """アラート生成"""
        alerts = []
        churn = self._get_churn_rate()
        if churn > 0.07:
            alerts.append({
                "severity": "critical",
                "metric": "churn_rate",
                "message": f"チャーン率{churn*100:.1f}%が閾値7%を超過",
                "action": "解約理由の緊急調査が必要"
            })
 
        activation = self._get_activation_rate()
        if activation < 0.50:
            alerts.append({
                "severity": "warning",
                "metric": "activation_rate",
                "message": f"アクティベーション率{activation*100:.1f}%が"
                          f"目標50%を下回っている",
                "action": "オンボーディングフローの見直し"
            })
 
        return alerts
 
    # プレースホルダーメソッド
    def _get_wapu(self): return 340
    def _get_wapu_change(self): return "+21%"
    def _get_trend(self, metric, weeks): return "上昇"
    def _get_mrr(self): return 2450000
    def _get_mrr_growth(self): return 0.15
    def _get_new_mrr(self): return 450000
    def _get_churned_mrr(self): return 120000
    def _get_expansion_mrr(self): return 80000
    def _get_new_signups(self): return 1200
    def _get_activation_rate(self): return 0.62
    def _get_conversion_rate(self): return 0.042
    def _get_churn_rate(self): return 0.038
    def _get_nps(self): return 48
    def _get_support_tickets(self): return 85

class InternationalExpansion:
    """国際展開戦略"""
 
    MARKET_PRIORITIZATION = {
        "tier_1": {
            "markets": ["US", "UK", "EU"],
            "rationale": "最大市場 + 英語圏 + 高い支払い意思",
            "entry_strategy": "デジタルマーケティング主導",
            "localization_level": "フル（言語 + 通貨 + 決済）",
            "expected_timeline": "6-12ヶ月で収益化",
            "investment": "高"
        },
        "tier_2": {
            "markets": ["JP", "KR", "AU", "CA"],
            "rationale": "中規模市場 + AI需要高い",
            "entry_strategy": "パートナー経由 + ローカルマーケティング",
            "localization_level": "言語 + 通貨 + 決済方法",
            "expected_timeline": "12-18ヶ月で収益化",
            "investment": "中"
        },
        "tier_3": {
            "markets": ["BR", "IN", "SEA"],
            "rationale": "大規模ポテンシャル + PPP対応が必要",
            "entry_strategy": "PLG + コミュニティ主導",
            "localization_level": "言語 + 地域別価格",
            "expected_timeline": "18-24ヶ月で収益化",
            "investment": "低-中"
        }
    }
 
    def evaluate_market(self, market: dict) -> dict:
        """市場評価"""
        scores = {
            "market_size": market.get("tam", 0) / 1000000,  # 百万ドル規模
            "growth_rate": market.get("yoy_growth", 0) * 10,
            "competition": (10 - market.get("competitors", 5)),
            "accessibility": market.get("ease_of_entry", 5),
            "payment_infrastructure": market.get("payment_score", 5)
        }
 
        total_score = sum(scores.values())
        max_score = 50  # 各5項目×10点
 
        return {
            "market": market["name"],
            "total_score": round(total_score, 1),
            "max_score": max_score,
            "percentage": f"{total_score/max_score*100:.0f}%",
            "breakdown": scores,
            "recommendation": (
                "即座に参入" if total_score >= 35
                else "パイロット参入" if total_score >= 25
                else "様子見" if total_score >= 15
                else "参入見送り"
            )
        }
 
    def create_localization_checklist(self, market: str) -> dict:
        """ローカライゼーションチェックリスト"""
        return {
            "language": {
                "ui_translation": "UIテキストの翻訳",
                "documentation": "ドキュメントの翻訳",
                "support": "現地語でのサポート対応",
                "marketing_content": "マーケティングコンテンツ",
                "status": "必須"
            },
            "payment": {
                "local_currency": "現地通貨での表示・決済",
                "payment_methods": "現地で主流の決済手段対応",
                "tax_compliance": "現地の税制対応（消費税/VAT等）",
                "invoicing": "現地の請求書フォーマット",
                "status": "必須"
            },
            "legal": {
                "privacy_policy": "現地のプライバシー法対応（GDPR等）",
                "terms_of_service": "利用規約の現地法準拠",
                "data_residency": "データ保管場所の要件",
                "licensing": "必要なライセンスの取得",
                "status": "必須"
            },
            "cultural": {
                "ux_adaptation": "UXの文化的適応",
                "color_and_imagery": "色使い・画像の文化的配慮",
                "date_format": "日付・数値フォーマット",
                "name_format": "氏名の入力順序",
                "status": "推奨"
            }
        }

class OrganizationScaling:
    """組織スケーリング"""
 
    HIRING_ROADMAP = {
        "stage_0_10": {
            "mrr": "~¥500,000",
            "headcount": "1-3人",
            "roles": [
                {"role": "創業者（CEO/CTO）", "priority": "存在"},
                {"role": "フルスタックエンジニア", "priority": "最優先"},
                {"role": "デザイナー（業務委託）", "priority": "推奨"}
            ],
            "culture_focus": "スピードと実験"
        },
        "stage_10_30": {
            "mrr": "¥500,000 - ¥3,000,000",
            "headcount": "5-10人",
            "roles": [
                {"role": "MLエンジニア", "priority": "最優先"},
                {"role": "フロントエンドエンジニア", "priority": "高"},
                {"role": "カスタマーサクセス", "priority": "高"},
                {"role": "マーケター", "priority": "中"},
                {"role": "インフラエンジニア", "priority": "中"}
            ],
            "culture_focus": "プロセスの導入と専門化"
        },
        "stage_30_100": {
            "mrr": "¥3,000,000 - ¥30,000,000",
            "headcount": "15-50人",
            "roles": [
                {"role": "VP of Engineering", "priority": "最優先"},
                {"role": "VP of Sales", "priority": "高"},
                {"role": "プロダクトマネージャー", "priority": "高"},
                {"role": "セールスチーム（3-5人）", "priority": "高"},
                {"role": "データエンジニア", "priority": "中"},
                {"role": "HR/People Ops", "priority": "中"}
            ],
            "culture_focus": "マネジメント層の構築"
        },
        "stage_100_plus": {
            "mrr": "¥30,000,000+",
            "headcount": "50-200人+",
            "roles": [
                {"role": "CFO", "priority": "最優先"},
                {"role": "VP of Marketing", "priority": "高"},
                {"role": "VP of Customer Success", "priority": "高"},
                {"role": "Legal Counsel", "priority": "高"},
                {"role": "部門マネージャー群", "priority": "高"}
            ],
            "culture_focus": "スケーラブルな組織文化"
        }
    }
 
    def calculate_hiring_budget(
        self,
        target_mrr: float,
        revenue_per_employee: float = 300000
    ) -> dict:
        """採用予算の計算"""
        target_headcount = int(target_mrr / revenue_per_employee)
        avg_salary = 6000000  # 年間平均給与
        hiring_cost = avg_salary * 0.20  # 採用コスト（年収の20%）
        onboarding_cost = 500000  # オンボーディングコスト
 
        return {
            "target_mrr": f"¥{target_mrr:,.0f}",
            "target_headcount": target_headcount,
            "revenue_per_employee": f"¥{revenue_per_employee:,.0f}/月",
            "annual_salary_budget": f"¥{avg_salary * target_headcount:,.0f}",
            "hiring_cost": f"¥{hiring_cost * target_headcount:,.0f}",
            "total_people_cost": f"¥{(avg_salary + hiring_cost + onboarding_cost) * target_headcount:,.0f}"
        }
 
    def design_team_structure(self, headcount: int) -> dict:
        """チーム構造設計"""
        if headcount <= 5:
            return {
                "structure": "フラット",
                "teams": ["全員がジェネラリスト"],
                "communication": "全体ミーティング（毎日）",
                "decision_making": "創業者が最終決定"
            }
        elif headcount <= 20:
            return {
                "structure": "機能別チーム",
                "teams": [
                    "プロダクト/エンジニアリング（60%）",
                    "Go-to-Market（25%）",
                    "オペレーション（15%）"
                ],
                "communication": "週次全体 + 日次チーム",
                "decision_making": "チームリードに委譲開始"
            }
        elif headcount <= 50:
            return {
                "structure": "部門制",
                "teams": [
                    "エンジニアリング部門",
                    "プロダクト部門",
                    "セールス/マーケティング部門",
                    "カスタマーサクセス部門",
                    "管理部門"
                ],
                "communication": "月次全体 + 週次部門 + 日次チーム",
                "decision_making": "部門長に権限委譲"
            }
        else:
            return {
                "structure": "事業部制またはマトリクス",
                "teams": [
                    "プロダクトライン別チーム",
                    "地域別チーム",
                    "横断機能チーム"
                ],
                "communication": "四半期全体 + 月次部門 + 週次チーム",
                "decision_making": "OKRによる自律的意思決定"
            }

# BAD: PMF達成前にマーケティングに大量投資
premature_scaling = {
    "stage": "Pre-PMF (チャーン率 15%/月)",
    "action": "Google Ads に月100万円投入",
    "result": "ユーザーは増えるが即解約。広告費が焼失。",
    "lesson": "穴の空いたバケツに水を注ぐのと同じ"
}
 
# GOOD: PMF確認後にスケーリング
proper_scaling = {
    "stage_1": {
        "focus": "PMF達成（チャーン率 5%以下）",
        "budget": "月10万円（コンテンツのみ）",
        "goal": "有料ユーザー50人、NPS 40+"
    },
    "stage_2": {
        "focus": "チャネル実験",
        "budget": "月30万円（5チャネル×6万円）",
        "goal": "CAC最良チャネルを特定"
    },
    "stage_3": {
        "focus": "スケーリング",
        "budget": "月100万円+（最良チャネルに集中）",
        "goal": "月次MRR成長 20%"
    }
}

# BAD: 10チャネルを同時に展開
spread_thin = {
    "channels": ["SEO", "Google Ads", "Facebook", "Twitter",
                 "LinkedIn", "YouTube", "TikTok", "PR",
                 "イベント", "パートナー"],
    "budget_each": "月10万円",
    "result": "どのチャネルも中途半端、効果測定困難"
}
 
# GOOD: 1-2チャネルに集中→成功後に拡大
focused_growth = {
    "phase_1": {
        "channels": ["SEO/ブログ", "Twitter"],
        "budget": "月50万円",
        "期間": "3ヶ月",
        "目標": "月間1000訪問、50登録"
    },
    "phase_2": {
        "channels": ["+ YouTube", "+ Product Hunt"],
        "budget": "月80万円",
        "condition": "Phase 1でCAC ¥15,000以下達成後"
    }
}

# BAD: 感覚で成長戦略を決定
no_metrics = {
    "decision_basis": "創業者の直感",
    "tracking": "ユーザー数のみ",
    "result": "チャーンが見えない、CAC不明、LTV不明",
    "consequence": "資金が尽きるまで問題に気づかない"
}
 
# GOOD: データ駆動の成長戦略
data_driven = {
    "weekly_metrics": [
        "MRR、MRR成長率",
        "新規登録数、アクティベーション率",
        "チャーン率、NRR",
        "CAC、LTV/CAC比"
    ],
    "monthly_review": "メトリクスレビューミーティング",
    "quarterly_strategy": "データに基づく戦略調整",
    "result": "問題の早期発見、効率的なリソース配分"
}

# BAD: PMF前に大量採用
premature_hiring = {
    "stage": "MRR ¥200,000",
    "headcount": 15,
    "burn_rate": "月¥5,000,000",
    "runway": "8ヶ月",
    "result": "PMFが見つからないまま資金枯渇"
}
 
# GOOD: 段階的採用
staged_hiring = {
    "rule": "MRR = 月間人件費の1.5倍以上で次の採用",
    "stages": [
        {"mrr": 300000, "hire": "フルスタックエンジニア1名"},
        {"mrr": 800000, "hire": "カスタマーサクセス1名"},
        {"mrr": 1500000, "hire": "マーケター1名"},
        {"mrr": 3000000, "hire": "セールス1名"}
    ],
    "result": "常にキャッシュフローポジティブを維持"
}