# AI SaaS プロダクト設計キャンバス
product_canvas = {
    "problem": {
        "who": "マーケティングチーム（5-50人規模）",
        "what": "月100本のブログ記事作成に週40時間費やしている",
        "why_now": "GPT-4の登場で実用的な品質が実現可能に",
        "alternatives": ["外注ライター", "テンプレート", "手動作成"]
    },
    "solution": {
        "core_value": "AI記事生成で作成時間を80%削減",
        "ai_role": "ドラフト生成 + SEO最適化 + トーン調整",
        "human_role": "最終レビュー + ファクトチェック + 承認",
        "moat": "業界特化の学習データ + ワークフロー統合"
    },
    "business_model": {
        "pricing": "フリーミアム → $49/月 → $199/月",
        "unit_economics": {
            "cac": 15000,       # 顧客獲得コスト（円）
            "ltv": 180000,      # 顧客生涯価値（円）
            "ltv_cac_ratio": 12, # 目標: 3以上
            "payback_months": 2  # 投資回収月数
        }
    }
}

class ProblemDiscovery:
    """AI SaaSの課題発見を体系化するフレームワーク"""
 
    def __init__(self):
        self.pain_point_categories = [
            "時間がかかりすぎる作業",
            "人手では品質にばらつきがある作業",
            "繰り返しが多く退屈な作業",
            "データが膨大で人間には処理しきれない作業",
            "専門知識が必要だがスケールしない作業",
        ]
 
    def evaluate_opportunity(self, problem: dict) -> dict:
        """ビジネス機会の評価"""
        score = 0
        evaluation = {}
 
        # 1. 市場サイズ
        tam = problem.get("total_addressable_market", 0)
        if tam > 100_000_000_000:  # 1000億円以上
            evaluation["market_size"] = {"score": 5, "label": "巨大市場"}
        elif tam > 10_000_000_000:
            evaluation["market_size"] = {"score": 4, "label": "大規模市場"}
        elif tam > 1_000_000_000:
            evaluation["market_size"] = {"score": 3, "label": "中規模市場"}
        else:
            evaluation["market_size"] = {"score": 2, "label": "ニッチ市場"}
        score += evaluation["market_size"]["score"]
 
        # 2. AIフィット度（AIで解決可能か）
        ai_fit_factors = [
            problem.get("data_available", False),
            problem.get("pattern_recognizable", False),
            problem.get("automation_possible", False),
            problem.get("quality_measurable", False),
            problem.get("feedback_loop_exists", False),
        ]
        ai_fit = sum(ai_fit_factors)
        evaluation["ai_fit"] = {"score": ai_fit, "label": f"{ai_fit}/5"}
        score += ai_fit
 
        # 3. 競合状況
        competitors = problem.get("competitors", [])
        if len(competitors) == 0:
            evaluation["competition"] = {"score": 3, "label": "ブルーオーシャン"}
        elif len(competitors) <= 3:
            evaluation["competition"] = {"score": 4, "label": "初期市場"}
        elif len(competitors) <= 10:
            evaluation["competition"] = {"score": 2, "label": "競争市場"}
        else:
            evaluation["competition"] = {"score": 1, "label": "過当競争"}
        score += evaluation["competition"]["score"]
 
        # 4. 支払い意思
        willingness = problem.get("willingness_to_pay", 0)
        if willingness >= 50000:
            evaluation["willingness"] = {"score": 5, "label": "高単価"}
        elif willingness >= 10000:
            evaluation["willingness"] = {"score": 3, "label": "中単価"}
        else:
            evaluation["willingness"] = {"score": 1, "label": "低単価"}
        score += evaluation["willingness"]["score"]
 
        evaluation["total_score"] = score
        evaluation["recommendation"] = (
            "強くGO" if score >= 15 else
            "GO" if score >= 12 else
            "要検討" if score >= 8 else
            "見送り"
        )
 
        return evaluation
 
    def generate_problem_statement(self, research: dict) -> str:
        """問題ステートメントの自動生成"""
        template = (
            f"{research['target_user']}は、"
            f"{research['current_process']}に"
            f"月{research['hours_spent']}時間を費やしており、"
            f"これは{research['cost_impact']}の損失につながっている。"
            f"既存の解決策（{', '.join(research['alternatives'])}）は"
            f"{research['alternative_limitation']}という課題があり、"
            f"AIを活用することで{research['ai_value_proposition']}が実現可能である。"
        )
        return template
 
 
# 使用例
discovery = ProblemDiscovery()
problem = {
    "total_addressable_market": 50_000_000_000,
    "data_available": True,
    "pattern_recognizable": True,
    "automation_possible": True,
    "quality_measurable": True,
    "feedback_loop_exists": True,
    "competitors": ["Jasper", "Copy.ai"],
    "willingness_to_pay": 30000,
}
result = discovery.evaluate_opportunity(problem)
print(f"評価スコア: {result['total_score']}")
print(f"推奨: {result['recommendation']}")

class AISaaSArchitecture:
    """AI SaaS設計のベストプラクティス"""
 
    @staticmethod
    def design_ai_layer():
        """AI処理レイヤーの設計パターン"""
        return {
            "prompt_management": {
                "description": "プロンプトのバージョン管理と最適化",
                "tools": ["Langfuse", "PromptLayer", "自作管理"],
                "best_practices": [
                    "プロンプトはコードと同様にバージョン管理",
                    "A/Bテストでプロンプト品質を継続改善",
                    "ユーザー入力のサニタイズ（インジェクション対策）",
                    "プロンプトテンプレート + 動的変数の分離",
                ]
            },
            "caching_strategy": {
                "description": "AI API呼び出しコスト削減のキャッシュ戦略",
                "layers": [
                    "L1: 完全一致キャッシュ（Redis、同一入力→同一出力）",
                    "L2: セマンティックキャッシュ（類似入力→キャッシュヒット）",
                    "L3: プリコンピュート（よくある入力を事前生成）",
                ],
                "cache_hit_target": "30-50%（コスト30-50%削減）",
            },
            "queue_processing": {
                "description": "長時間AI処理の非同期キュー",
                "tools": ["Bull/BullMQ", "Celery", "AWS SQS"],
                "pattern": "ユーザーリクエスト→キュー→ワーカー→WebSocket通知",
                "timeout": "30秒以上の処理は必ず非同期化",
            },
            "fallback_strategy": {
                "description": "AI APIダウン時のフォールバック",
                "strategies": [
                    "マルチプロバイダ: OpenAI→Anthropic→自社モデル",
                    "キャッシュフォールバック: 類似結果を返す",
                    "グレースフルデグレード: AI機能なしでも基本機能は動作",
                ],
            },
            "cost_control": {
                "description": "AI APIコストの制御",
                "measures": [
                    "ユーザーごとの使用量上限設定",
                    "モデルの使い分け（簡単な処理はGPT-3.5、複雑はGPT-4）",
                    "トークン数の事前推定と制限",
                    "バッチ処理による効率化",
                ],
            },
        }
 
    @staticmethod
    def design_data_pipeline():
        """データパイプラインの設計"""
        return {
            "ingestion": {
                "sources": ["ユーザーアップロード", "API連携", "Webスクレイピング"],
                "processing": ["バリデーション", "クリーニング", "変換"],
                "storage": "S3 + メタデータをPostgreSQLに保存",
            },
            "feature_store": {
                "purpose": "ユーザーごとのカスタマイズデータ管理",
                "examples": [
                    "ブランドボイス設定",
                    "業界特化知識ベース",
                    "過去の生成履歴と評価",
                    "カスタムテンプレート",
                ],
            },
            "feedback_loop": {
                "purpose": "AI品質の継続改善",
                "steps": [
                    "ユーザーフィードバック収集（いいね/よくない）",
                    "フィードバックデータの集約分析",
                    "プロンプト改善 or ファインチューニング",
                    "改善効果の測定（A/Bテスト）",
                ],
            },
        }

class AISaaSSecurity:
    """AI SaaSのセキュリティ設計"""
 
    SECURITY_CHECKLIST = {
        "data_privacy": {
            "items": [
                "ユーザーデータの暗号化（転送中・保存時）",
                "PII（個人情報）の検出と自動マスキング",
                "AIプロバイダへのデータ送信ポリシー明確化",
                "データ保持期間の設定と自動削除",
                "GDPR/個人情報保護法への準拠",
            ],
            "priority": "最高",
        },
        "prompt_security": {
            "items": [
                "プロンプトインジェクション対策",
                "システムプロンプトの漏洩防止",
                "ユーザー入力のサニタイズ",
                "出力内容のフィルタリング（有害コンテンツ）",
                "レート制限による悪用防止",
            ],
            "priority": "高",
        },
        "access_control": {
            "items": [
                "ロールベースアクセス制御（RBAC）",
                "APIキーのローテーション",
                "監査ログの記録",
                "SSO/SAML対応（エンタープライズ向け）",
                "IPホワイトリスト（オプション）",
            ],
            "priority": "高",
        },
        "operational_security": {
            "items": [
                "インフラのセキュリティ監査",
                "依存パッケージの脆弱性スキャン",
                "インシデントレスポンス計画",
                "バックアップとディザスタリカバリ",
                "ペネトレーションテスト",
            ],
            "priority": "中",
        },
    }
 
    @staticmethod
    def implement_prompt_guard(user_input: str) -> dict:
        """プロンプトインジェクション対策の実装例"""
        import re
 
        risks = []
        cleaned = user_input
 
        # 1. システムプロンプト漏洩の試み検出
        injection_patterns = [
            r"ignore\s+(previous|above|all)\s+instructions",
            r"system\s*prompt",
            r"reveal\s+(your|the)\s+(instructions|prompt)",
            r"忘れて|無視して|命令を変更",
        ]
        for pattern in injection_patterns:
            if re.search(pattern, user_input, re.IGNORECASE):
                risks.append(f"injection_attempt: {pattern}")
 
        # 2. 入力長の制限
        max_length = 10000
        if len(user_input) > max_length:
            cleaned = user_input[:max_length]
            risks.append("input_truncated")
 
        # 3. 特殊文字のエスケープ
        cleaned = cleaned.replace("{{", "").replace("}}", "")
 
        return {
            "cleaned_input": cleaned,
            "risks": risks,
            "is_safe": len(risks) == 0,
        }

# MVP スコープ定義フレームワーク
class MVPScope:
    """AI SaaS MVP のスコープを定義"""
 
    @staticmethod
    def define_mvp():
        return {
            "must_have": [
                "コア AI 機能（1つだけ、最も価値が高いもの）",
                "ユーザー認証（メール/Google OAuth）",
                "基本的なUI（入力→AI処理→出力）",
                "使用量トラッキング",
                "Stripe決済（1プランのみ）"
            ],
            "should_have": [
                "履歴保存",
                "出力のエクスポート",
                "基本的なダッシュボード"
            ],
            "wont_have_yet": [
                "チーム機能",
                "API提供",
                "カスタムモデル",
                "高度な分析",
                "モバイルアプリ"
            ],
            "timeline": "4-6週間",
            "budget": "50万円以下"
        }
 
    @staticmethod
    def define_weekly_milestones():
        """週次マイルストーン"""
        return {
            "week_1": {
                "goal": "基盤構築",
                "tasks": [
                    "Next.js + Supabase プロジェクトセットアップ",
                    "認証フロー実装（Google OAuth）",
                    "基本レイアウト・デザインシステム",
                    "OpenAI API接続の動作確認",
                ],
                "deliverable": "ログイン→AI呼び出し→結果表示のプロトタイプ",
            },
            "week_2": {
                "goal": "コアAI機能",
                "tasks": [
                    "プロンプトエンジニアリング＆最適化",
                    "入力フォーム設計・実装",
                    "AI生成結果の表示・編集UI",
                    "エラーハンドリング・ローディング",
                ],
                "deliverable": "コアAI機能が動作する状態",
            },
            "week_3": {
                "goal": "課金と使用量管理",
                "tasks": [
                    "Stripe連携（Checkout Session）",
                    "使用量カウント・制限ロジック",
                    "プランページ・アップグレードフロー",
                    "Webhook処理（支払い完了/失敗）",
                ],
                "deliverable": "フリーミアム→有料転換フローの完成",
            },
            "week_4": {
                "goal": "品質向上とローンチ準備",
                "tasks": [
                    "E2Eテスト・手動テスト",
                    "パフォーマンス最適化",
                    "ランディングページ作成",
                    "利用規約・プライバシーポリシー",
                    "Product Hunt / Twitter ローンチ準備",
                ],
                "deliverable": "ローンチ可能な状態",
            },
        }

# 推奨技術スタック（速度重視）
tech_stack = {
    "frontend": {
        "framework": "Next.js 14 (App Router)",
        "ui": "shadcn/ui + Tailwind CSS",
        "state": "Zustand",
        "reason": "最速のフルスタック開発"
    },
    "backend": {
        "runtime": "Next.js API Routes or FastAPI",
        "auth": "NextAuth.js / Clerk",
        "db": "Supabase (PostgreSQL + Auth + Storage)",
        "reason": "インフラ管理不要、即日デプロイ"
    },
    "ai": {
        "primary": "OpenAI GPT-4 API",
        "fallback": "Anthropic Claude API",
        "framework": "LangChain or Vercel AI SDK",
        "reason": "最も成熟したエコシステム"
    },
    "infra": {
        "hosting": "Vercel",
        "db_hosting": "Supabase",
        "monitoring": "Sentry + PostHog",
        "reason": "ゼロ運用コスト、自動スケール"
    },
    "billing": {
        "payment": "Stripe",
        "usage_tracking": "カスタム (DB)",
        "reason": "グローバル対応、豊富なSDK"
    }
}
 
# 代替技術スタック比較
alternative_stacks = {
    "python_fullstack": {
        "framework": "FastAPI + React",
        "pros": "Python AIエコシステムとの親和性",
        "cons": "フロントとバックの分離管理",
        "best_for": "AIのカスタマイズが重要な場合",
    },
    "firebase_stack": {
        "framework": "Next.js + Firebase",
        "pros": "リアルタイム機能、認証の簡単さ",
        "cons": "ベンダーロックイン、コスト予測困難",
        "best_for": "リアルタイムコラボ機能がある場合",
    },
    "rails_stack": {
        "framework": "Ruby on Rails + Hotwire",
        "pros": "高速プロトタイピング、フルスタック",
        "cons": "AIエコシステムの薄さ",
        "best_for": "CRUD中心でAIは付加価値の場合",
    },
    "go_stack": {
        "framework": "Go + htmx + PostgreSQL",
        "pros": "高パフォーマンス、低コスト",
        "cons": "開発速度、エコシステムの薄さ",
        "best_for": "大量トラフィック、低レイテンシ要件",
    },
}

# FastAPI バックエンド例
from fastapi import FastAPI, Depends, HTTPException
from pydantic import BaseModel
import openai
 
app = FastAPI()
 
class ArticleRequest(BaseModel):
    topic: str
    tone: str = "professional"
    length: str = "medium"  # short/medium/long
    keywords: list[str] = []
 
class ArticleResponse(BaseModel):
    title: str
    content: str
    seo_score: float
    word_count: int
    tokens_used: int
 
@app.post("/api/generate", response_model=ArticleResponse)
async def generate_article(
    request: ArticleRequest,
    user = Depends(get_current_user)
):
    """記事生成エンドポイント"""
    # 使用量チェック
    usage = await get_usage(user.id)
    if usage.articles_this_month >= user.plan.monthly_limit:
        raise HTTPException(402, "月間生成上限に達しました")
 
    # AI生成
    length_map = {"short": 500, "medium": 1000, "long": 2000}
    target_words = length_map[request.length]
 
    prompt = f"""
以下の条件で記事を生成:
- トピック: {request.topic}
- トーン: {request.tone}
- 目標文字数: {target_words}文字
- SEOキーワード: {', '.join(request.keywords)}
 
構成: タイトル、導入、本文（見出し付き）、まとめ
"""
 
    response = openai.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=target_words * 2
    )
 
    content = response.choices[0].message.content
    tokens = response.usage.total_tokens
 
    # 使用量記録
    await record_usage(user.id, tokens)
 
    return ArticleResponse(
        title=extract_title(content),
        content=content,
        seo_score=calculate_seo_score(content, request.keywords),
        word_count=len(content),
        tokens_used=tokens
    )

// Next.js App Router + Vercel AI SDK でのストリーミングUI例
 
// app/api/generate/route.ts
import { OpenAIStream, StreamingTextResponse } from 'ai';
import OpenAI from 'openai';
 
const openai = new OpenAI();
 
export async function POST(req: Request) {
  const { topic, tone, keywords } = await req.json();
 
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    stream: true,
    messages: [
      {
        role: 'system',
        content: `あなたはSEOに精通したプロのライターです。
トーン: ${tone}`,
      },
      {
        role: 'user',
        content: `以下のトピックで記事を生成してください:
トピック: ${topic}
キーワード: ${keywords.join(', ')}`,
      },
    ],
  });
 
  const stream = OpenAIStream(response);
  return new StreamingTextResponse(stream);
}
 
// app/generate/page.tsx
'use client';
 
import { useCompletion } from 'ai/react';
import { useState } from 'react';
 
export default function GeneratePage() {
  const [topic, setTopic] = useState('');
  const [tone, setTone] = useState('professional');
  const [keywords, setKeywords] = useState<string[]>([]);
 
  const { completion, isLoading, complete } = useCompletion({
    api: '/api/generate',
  });
 
  const handleGenerate = async () => {
    await complete('', {
      body: { topic, tone, keywords },
    });
  };
 
  return (
    <div className="max-w-4xl mx-auto p-6">
      <h1 className="text-2xl font-bold mb-6">AI記事生成</h1>
 
      {/* 入力フォーム */}
      <div className="space-y-4 mb-6">
        <input
          value={topic}
          onChange={(e) => setTopic(e.target.value)}
          placeholder="トピックを入力..."
          className="w-full p-3 border rounded-lg"
        />
        <select
          value={tone}
          onChange={(e) => setTone(e.target.value)}
          className="w-full p-3 border rounded-lg"
        >
          <option value="professional">プロフェッショナル</option>
          <option value="casual">カジュアル</option>
          <option value="academic">アカデミック</option>
        </select>
        <button
          onClick={handleGenerate}
          disabled={isLoading || !topic}
          className="px-6 py-3 bg-blue-600 text-white rounded-lg
                     disabled:opacity-50"
        >
          {isLoading ? '生成中...' : '記事を生成'}
        </button>
      </div>
 
      {/* ストリーミング出力 */}
      {completion && (
        <div className="prose max-w-none p-6 bg-white rounded-lg shadow">
          <div dangerouslySetInnerHTML={{
            __html: markdownToHtml(completion)
          }} />
        </div>
      )}
    </div>
  );
}

import stripe
from fastapi import FastAPI, Request, HTTPException
 
stripe.api_key = "sk_..."
 
# プラン定義
PLANS = {
    "free": {
        "name": "Free",
        "monthly_articles": 5,
        "price_id": None,
        "monthly_price": 0,
    },
    "pro": {
        "name": "Pro",
        "monthly_articles": 100,
        "price_id": "price_xxx_pro_monthly",
        "monthly_price": 4900,
    },
    "business": {
        "name": "Business",
        "monthly_articles": 500,
        "price_id": "price_xxx_business_monthly",
        "monthly_price": 19900,
    },
}
 
@app.post("/api/billing/checkout")
async def create_checkout(plan: str, user=Depends(get_current_user)):
    """Stripeチェックアウトセッション作成"""
    plan_data = PLANS.get(plan)
    if not plan_data or not plan_data["price_id"]:
        raise HTTPException(400, "無効なプラン")
 
    session = stripe.checkout.Session.create(
        customer_email=user.email,
        payment_method_types=["card"],
        line_items=[{
            "price": plan_data["price_id"],
            "quantity": 1,
        }],
        mode="subscription",
        success_url="https://app.example.com/billing?success=true",
        cancel_url="https://app.example.com/billing?canceled=true",
        metadata={"user_id": user.id, "plan": plan},
    )
 
    return {"checkout_url": session.url}
 
@app.post("/api/billing/webhook")
async def stripe_webhook(request: Request):
    """Stripe Webhook処理"""
    payload = await request.body()
    sig_header = request.headers.get("stripe-signature")
 
    try:
        event = stripe.Webhook.construct_event(
            payload, sig_header, "whsec_..."
        )
    except Exception as e:
        raise HTTPException(400, str(e))
 
    if event["type"] == "checkout.session.completed":
        session = event["data"]["object"]
        user_id = session["metadata"]["user_id"]
        plan = session["metadata"]["plan"]
        subscription_id = session["subscription"]
 
        await update_user_plan(user_id, plan, subscription_id)
 
    elif event["type"] == "customer.subscription.deleted":
        subscription = event["data"]["object"]
        await downgrade_to_free(subscription["id"])
 
    elif event["type"] == "invoice.payment_failed":
        subscription = event["data"]["object"]
        await handle_payment_failure(subscription["customer"])
 
    return {"received": True}
 
 
class UsageTracker:
    """使用量トラッキングと制限"""
 
    async def check_and_increment(self, user_id: str,
                                   resource: str = "articles") -> bool:
        """使用量チェックとインクリメント"""
        user = await get_user(user_id)
        plan = PLANS[user.plan]
        usage = await get_monthly_usage(user_id, resource)
 
        if usage >= plan[f"monthly_{resource}"]:
            return False  # 上限到達
 
        await increment_usage(user_id, resource)
        return True
 
    async def get_usage_summary(self, user_id: str) -> dict:
        """使用量サマリー"""
        user = await get_user(user_id)
        plan = PLANS[user.plan]
 
        return {
            "plan": user.plan,
            "articles": {
                "used": await get_monthly_usage(user_id, "articles"),
                "limit": plan["monthly_articles"],
            },
            "billing_period_end": user.billing_period_end,
            "next_reset": user.next_usage_reset,
        }

class PMFTracker:
    """PMF達成度を自動トラッキング"""
 
    def __init__(self, db, analytics):
        self.db = db
        self.analytics = analytics
 
    async def calculate_pmf_score(self) -> dict:
        """全PMFメトリクスを計算"""
        metrics = {}
 
        # 1. Sean Ellis Test
        survey = await self.db.get_latest_survey("sean_ellis")
        if survey:
            disappointed = survey["very_disappointed_count"]
            total = survey["total_responses"]
            metrics["sean_ellis"] = {
                "value": round(disappointed / total * 100, 1),
                "target": 40,
                "passed": disappointed / total >= 0.40,
            }
 
        # 2. 月次チャーン率
        active_start = await self.db.count_active_users(days_ago=30)
        churned = await self.db.count_churned_users(days=30)
        churn_rate = churned / max(active_start, 1) * 100
        metrics["monthly_churn"] = {
            "value": round(churn_rate, 1),
            "target": 5,
            "passed": churn_rate <= 5,
        }
 
        # 3. NPS
        nps_data = await self.db.get_nps_scores(days=90)
        promoters = sum(1 for s in nps_data if s >= 9)
        detractors = sum(1 for s in nps_data if s <= 6)
        total_nps = len(nps_data)
        nps = (promoters - detractors) / max(total_nps, 1) * 100
        metrics["nps"] = {
            "value": round(nps),
            "target": 40,
            "passed": nps >= 40,
        }
 
        # 4. 週次アクティブ率
        wau = await self.db.count_active_users(days=7)
        total_users = await self.db.count_total_users()
        wau_rate = wau / max(total_users, 1) * 100
        metrics["weekly_active_rate"] = {
            "value": round(wau_rate, 1),
            "target": 50,
            "passed": wau_rate >= 50,
        }
 
        # 5. オーガニック流入比率
        organic = await self.analytics.get_organic_signups(days=30)
        total_signups = await self.analytics.get_total_signups(days=30)
        organic_rate = organic / max(total_signups, 1) * 100
        metrics["organic_ratio"] = {
            "value": round(organic_rate, 1),
            "target": 30,
            "passed": organic_rate >= 30,
        }
 
        # 6. LTV/CAC
        ltv = await self.calculate_ltv()
        cac = await self.calculate_cac()
        ltv_cac = ltv / max(cac, 1)
        metrics["ltv_cac"] = {
            "value": round(ltv_cac, 1),
            "target": 3.0,
            "passed": ltv_cac >= 3.0,
        }
 
        # 総合判定
        passed_count = sum(
            1 for m in metrics.values() if m.get("passed", False)
        )
        metrics["overall"] = {
            "passed": passed_count,
            "total": len(metrics) - 1,  # overall自身を除く
            "pmf_achieved": passed_count >= 5,
        }
 
        return metrics
 
    async def calculate_ltv(self) -> float:
        """LTV計算"""
        avg_revenue = await self.db.get_avg_monthly_revenue_per_user()
        avg_lifetime = await self.db.get_avg_customer_lifetime_months()
        return avg_revenue * avg_lifetime
 
    async def calculate_cac(self) -> float:
        """CAC計算"""
        marketing_spend = await self.db.get_marketing_spend(days=30)
        new_customers = await self.db.count_new_paying_customers(days=30)
        return marketing_spend / max(new_customers, 1)

class PivotDecision:
    """ピボットすべきかの判断フレームワーク"""
 
    SIGNALS_TO_PIVOT = [
        "3ヶ月以上PMFメトリクスが改善しない",
        "有料転換率が1%以下",
        "チャーンが月15%以上",
        "NPS -20以下",
        "ユーザーインタビューで課題共感が30%以下",
    ]
 
    SIGNALS_TO_PERSIST = [
        "PMFメトリクスが毎月改善している",
        "小さいがエンゲージメントの高いユーザー群がいる",
        "ユーザーが自発的に紹介してくれる",
        "解約ユーザーに「戻りたい」と言われる",
    ]
 
    @staticmethod
    def evaluate(metrics: dict) -> dict:
        """ピボット判断"""
        pivot_signals = 0
        persist_signals = 0
 
        # チャーン率チェック
        if metrics.get("monthly_churn", 0) > 15:
            pivot_signals += 1
        elif metrics.get("monthly_churn", 0) < 8:
            persist_signals += 1
 
        # 成長率チェック
        if metrics.get("mrr_growth_rate", 0) < 0:
            pivot_signals += 1
        elif metrics.get("mrr_growth_rate", 0) > 10:
            persist_signals += 1
 
        # PMFスコア推移
        if metrics.get("pmf_trend", "flat") == "declining":
            pivot_signals += 1
        elif metrics.get("pmf_trend", "flat") == "improving":
            persist_signals += 1
 
        if pivot_signals >= 3:
            return {
                "recommendation": "PIVOT",
                "reason": "複数のネガティブシグナルが検出",
                "next_steps": [
                    "ユーザーインタビュー20件実施",
                    "解約理由の深掘り分析",
                    "隣接市場の機会評価",
                    "MVPの再定義",
                ],
            }
        elif persist_signals >= 3:
            return {
                "recommendation": "PERSIST",
                "reason": "ポジティブシグナルあり、継続改善",
                "next_steps": [
                    "最もエンゲージメントの高いセグメントに集中",
                    "チャーン原因の改善",
                    "バイラル機能の実装",
                ],
            }
        else:
            return {
                "recommendation": "ITERATE",
                "reason": "シグナル混在、小さな改善を繰り返す",
                "next_steps": [
                    "2週間スプリントで仮説検証",
                    "ユーザーフィードバックの優先度付け",
                    "A/Bテストの実施",
                ],
            }

# ユニットエコノミクス計算
class UnitEconomics:
    def calculate(self):
        return {
            "revenue_per_user": {
                "monthly_price": 4900,  # ¥4,900/月
                "annual_discount": 0.8,  # 年払い20%OFF
                "effective_monthly": 3920
            },
            "cost_per_user": {
                "ai_api_cost": 800,      # OpenAI API
                "infrastructure": 200,    # サーバー按分
                "support": 300,           # サポート按分
                "payment_processing": 150, # Stripe手数料
                "total": 1450
            },
            "gross_margin": {
                "amount": 4900 - 1450,    # ¥3,450
                "percentage": 70.4         # 70.4%（目標: 70%以上）
            },
            "cac": {
                "paid_ads": 8000,
                "content_marketing": 3000,
                "referral": 2000,
                "blended": 5000
            },
            "ltv": {
                "avg_lifetime_months": 18,
                "monthly_margin": 3450,
                "total": 3450 * 18  # ¥62,100
            },
            "ltv_cac_ratio": 62100 / 5000  # 12.4（目標: 3以上）
        }
 
    def project_mrr(self, months: int = 12,
                     initial_users: int = 10,
                     monthly_growth_rate: float = 0.15,
                     churn_rate: float = 0.05,
                     arpu: int = 4900) -> list:
        """MRR予測"""
        projections = []
        users = initial_users
 
        for month in range(1, months + 1):
            new_users = int(users * monthly_growth_rate)
            churned_users = int(users * churn_rate)
            users = users + new_users - churned_users
            mrr = users * arpu
 
            projections.append({
                "month": month,
                "total_users": users,
                "new_users": new_users,
                "churned_users": churned_users,
                "mrr": mrr,
                "arr": mrr * 12,
            })
 
        return projections

class CostOptimizer:
    """AI APIコスト最適化"""
 
    STRATEGIES = {
        "model_routing": {
            "description": "リクエストの複雑さに応じてモデルを使い分け",
            "implementation": "GPT-3.5で十分な処理はGPT-3.5へ、"
                             "品質が重要な処理のみGPT-4へ",
            "savings": "40-60%",
        },
        "semantic_caching": {
            "description": "類似リクエストのキャッシュ",
            "implementation": "埋め込みベクトルの類似度で判定、"
                             "閾値0.95以上でキャッシュヒット",
            "savings": "20-40%",
        },
        "prompt_optimization": {
            "description": "プロンプトの最適化でトークン削減",
            "implementation": "不要な指示の削除、Few-shotの最小化、"
                             "出力フォーマットの簡素化",
            "savings": "15-30%",
        },
        "batch_processing": {
            "description": "リアルタイム不要な処理のバッチ化",
            "implementation": "夜間バッチ処理でBatch API利用（50%OFF）",
            "savings": "50%（対象処理のみ）",
        },
    }
 
    @staticmethod
    def route_model(request_complexity: str, quality_requirement: str) -> str:
        """リクエストに最適なモデルを選択"""
        routing_table = {
            ("low", "standard"):  "gpt-3.5-turbo",
            ("low", "high"):      "gpt-4o-mini",
            ("medium", "standard"): "gpt-4o-mini",
            ("medium", "high"):    "gpt-4o",
            ("high", "standard"):  "gpt-4o",
            ("high", "high"):      "gpt-4o",
        }
        return routing_table.get(
            (request_complexity, quality_requirement),
            "gpt-4o-mini"
        )
 
    @staticmethod
    def estimate_monthly_cost(
        daily_requests: int,
        avg_input_tokens: int = 500,
        avg_output_tokens: int = 1000,
    ) -> dict:
        """月間AI APIコストの試算"""
        models = {
            "gpt-3.5-turbo": {
                "input": 0.0005, "output": 0.0015,  # per 1K tokens
            },
            "gpt-4o-mini": {
                "input": 0.00015, "output": 0.0006,
            },
            "gpt-4o": {
                "input": 0.005, "output": 0.015,
            },
        }
 
        monthly_requests = daily_requests * 30
        costs = {}
 
        for model, pricing in models.items():
            input_cost = (
                avg_input_tokens / 1000 * pricing["input"]
                * monthly_requests
            )
            output_cost = (
                avg_output_tokens / 1000 * pricing["output"]
                * monthly_requests
            )
            total = (input_cost + output_cost) * 150  # USD→JPY概算
            costs[model] = {
                "monthly_usd": round(input_cost + output_cost, 2),
                "monthly_jpy": round(total),
            }
 
        return costs

class GoToMarketStrategy:
    """AI SaaS の Go-to-Market 戦略"""
 
    LAUNCH_CHANNELS = {
        "product_hunt": {
            "effort": "高",
            "potential_users": "500-5000",
            "cost": "無料",
            "timeline": "準備2週間、当日集中",
            "tips": [
                "火曜日00:01 PST にローンチ",
                "Hunter（推薦者）を事前確保",
                "コミュニティに事前告知",
                "ローンチ日は全力でコメント対応",
            ],
        },
        "twitter_x": {
            "effort": "中",
            "potential_users": "100-1000",
            "cost": "無料",
            "timeline": "ローンチ前2週間からビルドインパブリック",
            "tips": [
                "開発過程をスレッドで共有",
                "before/afterの具体的数値を示す",
                "インフルエンサーにDMで紹介依頼",
            ],
        },
        "hacker_news": {
            "effort": "中",
            "potential_users": "100-500",
            "cost": "無料",
            "timeline": "Show HN投稿",
            "tips": [
                "技術的なストーリーを重視",
                "正直な開発ジャーニーを書く",
                "コメントには真摯に返答",
            ],
        },
        "content_marketing": {
            "effort": "高（継続的）",
            "potential_users": "月100-500",
            "cost": "時間のみ",
            "timeline": "ローンチ前1ヶ月から開始",
            "tips": [
                "ターゲットKWで5-10記事を準備",
                "AI活用のノウハウ記事が効果的",
                "事例紹介でソーシャルプルーフ",
            ],
        },
        "cold_outreach": {
            "effort": "高",
            "potential_users": "10-50（高品質）",
            "cost": "ツール費月1-3万円",
            "timeline": "ローンチ後すぐ開始",
            "tips": [
                "理想顧客のLinkedInリストを作成",
                "パーソナライズしたメッセージ",
                "無料トライアルのオファー",
            ],
        },
    }
 
    @staticmethod
    def create_launch_timeline() -> dict:
        """ローンチタイムライン"""
        return {
            "D-30": [
                "ランディングページ公開",
                "ウェイトリスト受付開始",
                "Twitter/Xでビルドインパブリック開始",
            ],
            "D-14": [
                "ベータユーザー10人に先行提供",
                "Product Huntの推薦者確保",
                "プレスリリース準備",
            ],
            "D-7": [
                "ベータフィードバック反映",
                "ローンチ記事執筆",
                "SNS投稿スケジュール設定",
            ],
            "D-1": [
                "最終動作確認",
                "サポート体制確認",
                "モニタリングアラート設定",
            ],
            "D-Day": [
                "Product Huntローンチ",
                "Twitter/Xでローンチ告知",
                "Hacker Newsに投稿",
                "ウェイトリストにメール送信",
                "全日コメント・問い合わせ対応",
            ],
            "D+7": [
                "ローンチ結果分析",
                "ユーザーフィードバック集約",
                "次の改善スプリント計画",
            ],
        }

class PricingStrategy:
    """AI SaaSのプライシング"""
 
    MODELS = {
        "usage_based": {
            "description": "使った分だけ課金",
            "example": "1生成あたり¥100、または1000トークンあたり¥10",
            "pros": ["低い参入障壁", "使用量に比例したコスト"],
            "cons": ["収益予測困難", "重要顧客の突然の解約リスク"],
            "best_for": "API型サービス、変動的な使用パターン",
        },
        "tiered_subscription": {
            "description": "段階的な月額プラン",
            "example": "Free / Pro ¥4,900 / Business ¥19,900",
            "pros": ["予測可能な収益", "アップセル経路が明確"],
            "cons": ["プラン設計の難しさ", "中間ユーザーの不満"],
            "best_for": "B2C/B2B、明確な機能差がある場合",
        },
        "per_seat": {
            "description": "ユーザー数ベースの課金",
            "example": "1ユーザーあたり¥2,000/月",
            "pros": ["拡大に伴い自然に収益増", "わかりやすい"],
            "cons": ["シート削減圧力", "AI使用量と無関係"],
            "best_for": "チームツール、コラボレーション機能あり",
        },
        "hybrid": {
            "description": "基本料金 + 使用量課金",
            "example": "基本¥4,900/月 + 超過分¥50/生成",
            "pros": ["安定収益 + アップサイド"],
            "cons": ["複雑さ", "超過料金への抵抗"],
            "best_for": "使用量の分散が大きいサービス",
        },
    }
 
    @staticmethod
    def calculate_optimal_price(
        value_delivered: int,
        competitor_price: int,
        cost_per_user: int,
    ) -> dict:
        """最適価格の算出"""
        # バリューベース: 提供価値の10-20%
        value_based = value_delivered * 0.15
        # コストプラス: コストの3-5倍
        cost_plus = cost_per_user * 4
        # 競合ベース: 競合の80-120%
        competitive = competitor_price * 1.0
 
        optimal = (value_based + cost_plus + competitive) / 3
 
        return {
            "value_based_price": round(value_based),
            "cost_plus_price": round(cost_plus),
            "competitive_price": round(competitive),
            "recommended_price": round(optimal),
            "range": {
                "floor": round(cost_per_user * 2),  # 最低でもコストの2倍
                "ceiling": round(value_delivered * 0.25),  # 最大で価値の25%
            },
        }

# BAD: OpenAI APIの薄いラッパー（差別化ゼロ）
@app.post("/generate")
def generate(prompt: str):
    return openai.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": prompt}]
    )
# → ChatGPTでよい。月$20で同じことができる。
 
# GOOD: 独自価値の積み上げ
@app.post("/generate-article")
def generate_article(topic: str, user_id: str):
    # 1. 業界特化のコンテキスト
    industry_context = get_industry_data(user.industry)
    # 2. 過去の成功記事パターン
    top_articles = get_top_performing_articles(user_id)
    # 3. 競合分析
    competitor_content = analyze_competitors(topic)
    # 4. ブランドボイス
    brand_voice = get_brand_voice(user_id)
    # 5. SEO最適化
    seo_data = get_keyword_data(topic)
 
    # これら全てを統合したプロンプト → 独自価値
    result = generate_with_context(
        topic, industry_context, top_articles,
        competitor_content, brand_voice, seo_data
    )
    return result

# BAD: 6ヶ月かけて全機能を実装してからローンチ
features_v1 = [
    "記事生成", "SEO最適化", "画像生成", "SNS投稿",
    "チーム管理", "API", "分析ダッシュボード",
    "多言語対応", "カスタムモデル", "ブランドボイス",
    # ... 50機能 → ローンチ時に市場が変わっている
]
 
# GOOD: 4週間で1機能にフォーカスしてローンチ
features_mvp = ["記事生成（1トピック→1記事）"]
# → ユーザーフィードバックで次を決める

# BAD: 感覚でプロダクト改善
def bad_improvement():
    # 「なんとなくこの機能が必要そう」→ 2週間かけて実装
    # → 使われない機能が増殖
    pass
 
# GOOD: データドリブンな改善サイクル
def good_improvement():
    # 1. 仮説を立てる
    hypothesis = "記事のテンプレート機能を追加すれば、" \
                 "生成回数が20%増える"
 
    # 2. 最小限の実装（1週間以内）
    feature = implement_templates_v1()
 
    # 3. A/Bテスト
    ab_test = create_ab_test(
        control="テンプレートなし",
        variant="テンプレートあり",
        metric="articles_generated_per_user",
        duration_days=14,
        min_sample_size=200,
    )
 
    # 4. 結果に基づき判断
    if ab_test.is_significant and ab_test.improvement > 0.10:
        ship_to_all_users(feature)
    else:
        revert_or_iterate(feature)

# BAD: ユーザー10人の段階でマイクロサービス
bad_architecture = {
    "services": [
        "API Gateway", "Auth Service", "AI Service",
        "Billing Service", "Analytics Service",
        "Notification Service", "Content Service",
    ],
    "infra": "Kubernetes + Terraform + Istio",
    "problem": "運用コストだけで月30万円。ユーザー10人。"
}
 
# GOOD: モノリスから始める
good_architecture = {
    "phase_1": {
        "users": "0-1000",
        "architecture": "Next.js モノリス + Supabase",
        "infra": "Vercel（月0円〜5000円）",
    },
    "phase_2": {
        "users": "1000-10000",
        "architecture": "AI処理のみ分離（FastAPI）",
        "infra": "Vercel + Railway/Fly.io",
    },
    "phase_3": {
        "users": "10000+",
        "architecture": "段階的にサービス分割",
        "infra": "AWS/GCP",
    },
}