Annual Planning Kickoff

import os
import json
import time
import csv
import statistics
import requests
from openai import OpenAI

MAVERA_API_KEY = os.environ["MAVERA_API_KEY"]
WORKSPACE_ID = os.environ["MAVERA_WORKSPACE_ID"]
PLAN_YEAR = os.environ.get("PLAN_YEAR", "2027")
BASE = "https://app.mavera.io/api/v1"
HEADERS = {
    "Authorization": f"Bearer {MAVERA_API_KEY}",
    "Content-Type": "application/json",
}
mavera = OpenAI(api_key=MAVERA_API_KEY, base_url=BASE)

COMPANY = {
    "name": "Acme",
    "category": "AI-powered market research platform",
    "current_arr": "$4.2M",
    "growth_rate": "120% YoY",
    "team_size": 35,
    "key_metrics": {
        "customers": 280,
        "avg_contract": "$15K",
        "win_rate": "32%",
        "churn_rate": "8%",
        "cac": "$4,200",
        "ltv": "$42,000",
        "nps": 48,
    },
}

CANDIDATE_THEMES = [
    {
        "theme": "Enterprise Expansion",
        "description": (
            "Move upmarket: build enterprise features (SSO, SCIM, audit logs), "
            "hire enterprise AEs, target companies with 1000+ employees. "
            "Goal: 20 enterprise deals at $50K+ ACV."
        ),
    },
    {
        "theme": "Product-Led Growth",
        "description": (
            "Launch a self-serve tier with freemium entry. Invest in onboarding, "
            "in-app guides, and viral loops. Goal: 1000 self-serve accounts, "
            "15% conversion to paid."
        ),
    },
    {
        "theme": "Content & Thought Leadership",
        "description": (
            "Become the definitive voice in AI-powered market research. "
            "Weekly blog, monthly webinar, quarterly research report, conference presence. "
            "Goal: 3x organic traffic, 2x inbound pipeline."
        ),
    },
    {
        "theme": "Integration Ecosystem",
        "description": (
            "Build deep integrations with HubSpot, Salesforce, Slack, Notion. "
            "Launch a partner program. Goal: 10 integration partners, "
            "30% of customers using 2+ integrations."
        ),
    },
    {
        "theme": "International Markets",
        "description": (
            "Expand to EU and APAC. Localize product and content. "
            "Hire regional marketing leads. Goal: 15% of new ARR from international."
        ),
    },
]

SAMPLE_CRM_DATA = [
    {"name": "TechCorp", "segment": "enterprise", "arr": 85000, "tenure_months": 18, "nps": 9, "usage": "heavy", "features_used": ["focus_groups", "chat", "mave", "video"]},
    {"name": "StartupX", "segment": "startup", "arr": 5000, "tenure_months": 4, "nps": 7, "usage": "moderate", "features_used": ["chat", "mave"]},
    {"name": "AgencyPro", "segment": "agency", "arr": 24000, "tenure_months": 12, "nps": 8, "usage": "heavy", "features_used": ["focus_groups", "chat", "generate", "brand_voice"]},
    {"name": "MidMarket Inc", "segment": "mid_market", "arr": 36000, "tenure_months": 8, "nps": 6, "usage": "light", "features_used": ["chat"]},
    {"name": "ChurnedCo", "segment": "churned", "arr": 0, "tenure_months": 6, "nps": 3, "usage": "none", "features_used": []},
]


def analyze_crm_data(data: list[dict]) -> dict:
    """Analyze CRM data to identify segments and patterns."""
    segments = {}
    for customer in data:
        seg = customer["segment"]
        if seg not in segments:
            segments[seg] = {"customers": [], "total_arr": 0, "nps_scores": [], "tenures": []}
        segments[seg]["customers"].append(customer)
        segments[seg]["total_arr"] += customer["arr"]
        segments[seg]["nps_scores"].append(customer["nps"])
        segments[seg]["tenures"].append(customer["tenure_months"])

    analysis = {}
    for seg, data in segments.items():
        analysis[seg] = {
            "count": len(data["customers"]),
            "total_arr": data["total_arr"],
            "avg_arr": data["total_arr"] / len(data["customers"]) if data["customers"] else 0,
            "avg_nps": statistics.mean(data["nps_scores"]) if data["nps_scores"] else 0,
            "avg_tenure": statistics.mean(data["tenures"]) if data["tenures"] else 0,
            "top_features": _most_common_features(data["customers"]),
        }

    print(f"✓ Analyzed {sum(a['count'] for a in analysis.values())} customers across {len(analysis)} segments")
    for seg, info in analysis.items():
        print(f"  {seg}: {info['count']} customers, ${info['avg_arr']:.0f} avg ARR, NPS {info['avg_nps']:.1f}")

    return analysis


def _most_common_features(customers: list[dict]) -> list[str]:
    """Find most commonly used features across customers."""
    counts = {}
    for c in customers:
        for f in c.get("features_used", []):
            counts[f] = counts.get(f, 0) + 1
    return sorted(counts, key=counts.get, reverse=True)[:5]

def generate_persona_descriptions(crm_analysis: dict) -> list[dict]:
    """Use Chat to generate rich persona descriptions from CRM segment data."""
    PERSONA_SCHEMA = {"type": "json_schema", "json_schema": {
        "name": "personas", "strict": True,
        "schema": {
            "type": "object",
            "properties": {
                "personas": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string"},
                            "segment": {"type": "string"},
                            "title": {"type": "string"},
                            "description": {"type": "string"},
                        },
                        "required": ["name", "segment", "title", "description"],
                    },
                },
            },
            "required": ["personas"],
        },
    }}

    prompt = (
        f"Based on this CRM analysis for {COMPANY['name']} ({COMPANY['category']}), "
        f"create 5 detailed personas — one per segment.\n\n"
        f"## CRM Analysis\n{json.dumps(crm_analysis, indent=2)}\n\n"
        f"## Company Context\n{json.dumps(COMPANY, indent=2)}\n\n"
        "For each persona, include:\n"
        "- Realistic name and title\n"
        "- Company size and budget context\n"
        "- How they use (or stopped using) the product\n"
        "- Their priorities for next year\n"
        "- What would make them increase/decrease their investment\n"
        "Make each description 3-5 sentences."
    )

    resp = mavera.responses.create(
        model="mavera-1",
        input=[{"role": "user", "content": prompt}],
        extra_body={"response_format": PERSONA_SCHEMA},
    )

    return json.loads(resp.output[0].content[0].text)["personas"]


def create_personas_from_descriptions(persona_descs: list[dict]) -> list[str]:
    """Create personas in Mavera from generated descriptions."""
    persona_ids = []

    for p in persona_descs:
        resp = requests.post(
            f"{BASE}/personas",
            headers=HEADERS,
            json={
                "name": p["name"],
                "description": f"[{p['segment']}] {p['title']}\n\n{p['description']}",
                "workspace_id": WORKSPACE_ID,
            },
        ).json()

        if "error" in resp:
            raise Exception(f"Failed: {p['name']}: {resp['error']['message']}")

        persona_ids.append(resp["id"])
        print(f"✓ Created: {p['name']} ({p['segment']}) — {resp['id']}")

    return persona_ids

def run_theme_focus_group(persona_ids: list[str]) -> dict:
    """Run a focus group validating candidate themes for next year."""
    themes_block = "\n".join(
        f"{i+1}. **{t['theme']}**: {t['description']}"
        for i, t in enumerate(CANDIDATE_THEMES)
    )

    payload = {
        "name": f"{PLAN_YEAR} Annual Planning — Theme Validation",
        "sample_size": 30,
        "persona_ids": persona_ids,
        "workspace_id": WORKSPACE_ID,
        "questions": [
            {
                "question": (
                    f"As a current or potential customer, rank these {PLAN_YEAR} strategic themes "
                    f"from most important to you (1st) to least (5th):\n\n{themes_block}"
                ),
                "type": "RANKING",
                "options": [t["theme"] for t in CANDIDATE_THEMES],
                "order": 1,
            },
            {
                "question": (
                    f"For the theme you ranked #1, rate how much it would increase "
                    f"your likelihood to invest more in {COMPANY['name']}. (1-10)"
                ),
                "type": "LIKERT",
                "scale": 10,
                "order": 2,
            },
            {
                "question": (
                    "Which theme would you be most disappointed if we did NOT pursue? "
                    "Why?"
                ),
                "type": "OPEN_ENDED",
                "order": 3,
            },
            {
                "question": (
                    f"Is there a strategic direction NOT listed above that you think "
                    f"{COMPANY['name']} should prioritize in {PLAN_YEAR}?"
                ),
                "type": "OPEN_ENDED",
                "order": 4,
            },
            {
                "question": (
                    f"Rate your overall confidence that {COMPANY['name']} is heading "
                    f"in the right direction. (0 = no confidence, 10 = very confident)"
                ),
                "type": "NPS",
                "order": 5,
            },
        ],
    }

    resp = requests.post(f"{BASE}/focus-groups", headers=HEADERS, json=payload).json()
    if "error" in resp:
        raise Exception(resp["error"]["message"])

    print(f"✓ Theme focus group launched: {resp['id']}")
    return resp


def poll_focus_group(fg_id: str, timeout_min: int = 15) -> dict:
    for _ in range(timeout_min * 6):
        resp = requests.get(f"{BASE}/focus-groups/{fg_id}", headers=HEADERS).json()
        if "error" in resp:
            raise Exception(resp["error"]["message"])
        if resp.get("status") == "COMPLETED":
            print("✓ Theme focus group completed")
            return resp
        if resp.get("status") == "FAILED":
            raise Exception("Focus group failed")
        time.sleep(10)
    raise TimeoutError("Focus group timed out")

def research_market_context() -> dict:
    """Use Mave to research market trends, competitive landscape, and benchmarks."""
    research_prompts = [
        {
            "label": "market_trends",
            "message": (
                f"Research the top trends in the {COMPANY['category']} market for {PLAN_YEAR}. "
                f"Focus on: technology shifts, buyer behavior changes, "
                f"emerging competitors, and market size projections. Cite sources."
            ),
        },
        {
            "label": "competitive_landscape",
            "message": (
                f"What are {COMPANY['name']}'s main competitors doing for {PLAN_YEAR}? "
                f"Any recent funding, product launches, acquisitions, or pivots? "
                f"How are they positioning for next year? Cite sources."
            ),
        },
        {
            "label": "industry_benchmarks",
            "message": (
                f"What are typical SaaS benchmarks for a company at {COMPANY['current_arr']} ARR "
                f"growing at {COMPANY['growth_rate']}? Include: ideal CAC:LTV ratio, "
                f"net revenue retention targets, magic number, and marketing spend as % of revenue. "
                f"Cite sources."
            ),
        },
    ]

    thread_id = None
    research = {}

    for prompt in research_prompts:
        payload = {"message": prompt["message"]}
        if thread_id:
            payload["thread_id"] = thread_id

        resp = requests.post(
            f"{BASE}/mave/chat",
            headers=HEADERS,
            json=payload,
            timeout=120,
        ).json()

        if "error" in resp:
            raise Exception(resp["error"]["message"])

        if not thread_id:
            thread_id = resp.get("thread_id")

        research[prompt["label"]] = {
            "content": resp.get("content", ""),
            "sources": resp.get("sources", []),
        }
        print(f"✓ Mave: {prompt['label']} ({len(resp.get('content', ''))} chars)")
        time.sleep(2)

    return {"thread_id": thread_id, "research": research}

PLAN_SECTIONS = [
    "executive_summary",
    "market_context",
    "strategic_themes",
    "target_segments",
    "channel_strategy",
    "budget_allocation",
    "okrs_and_kpis",
    "quarterly_roadmap",
    "risks_and_mitigations",
]


def generate_annual_plan(
    crm_analysis: dict, fg_results: dict, market_research: dict
) -> dict:
    """Generate each section of the annual plan using Generate API."""
    # Compile all inputs into context
    context = (
        f"# {PLAN_YEAR} Annual Marketing Plan Inputs\n\n"
        f"## Company\n{json.dumps(COMPANY, indent=2)}\n\n"
        f"## CRM Analysis\n{json.dumps(crm_analysis, indent=2)}\n\n"
        f"## Focus Group Results (Theme Validation)\n"
    )

    for result in fg_results.get("results", []):
        context += f"### {result.get('type')}: {result.get('question', '')[:80]}\n"
        if result.get("summary"):
            context += f"{result['summary']}\n"
        if result.get("ranking_distribution"):
            context += f"Rankings: {json.dumps(result['ranking_distribution'])}\n"
        if result.get("mean_score"):
            context += f"Mean: {result['mean_score']}\n"
        context += "\n"

    context += "## Market Research\n"
    for label, data in market_research["research"].items():
        context += f"### {label}\n{data['content'][:1000]}\n\n"

    plan_sections = {}

    for section in PLAN_SECTIONS:
        resp = requests.post(
            f"{BASE}/generate",
            headers=HEADERS,
            json={
                "prompt": (
                    f"Write the '{section.replace('_', ' ').title()}' section of the "
                    f"{PLAN_YEAR} annual marketing plan for {COMPANY['name']}.\n\n"
                    f"Use the data and insights below. Be specific — include numbers, "
                    f"timelines, and owners where appropriate. "
                    f"Write in a professional tone suitable for a board presentation.\n\n"
                    f"{context}"
                ),
                "workspace_id": WORKSPACE_ID,
                "max_tokens": 2000,
            },
        ).json()

        if "error" in resp:
            raise Exception(f"Generate failed for {section}: {resp['error']['message']}")

        plan_sections[section] = resp.get("content", resp.get("text", ""))
        print(f"✓ Generated: {section.replace('_', ' ').title()}")
        time.sleep(2)

    return plan_sections

SPEAK_QUESTIONS = [
    f"I'm going to share our top strategic theme for {PLAN_YEAR}. Tell me honestly — does this resonate with your needs?",
    "What's missing from this plan? What would make you more excited about our direction?",
    "If you had to bet, would this plan make you increase your investment with us, keep it the same, or decrease it?",
    "What's the one thing we could do next year that would make the biggest difference for you?",
]


def run_speak_conversations(persona_ids: list[str], plan_summary: str) -> list[dict]:
    """Run Speak conversations with each persona to validate the plan."""
    conversations = []

    for pid in persona_ids[:3]:  # Top 3 personas for voice validation
        resp = requests.post(
            f"{BASE}/speak/conversations",
            headers=HEADERS,
            json={
                "persona_id": pid,
                "workspace_id": WORKSPACE_ID,
                "context": (
                    f"You are reviewing the {PLAN_YEAR} annual marketing plan for {COMPANY['name']}. "
                    f"Here is the plan summary:\n\n{plan_summary}"
                ),
                "initial_message": SPEAK_QUESTIONS[0],
            },
        ).json()

        if "error" in resp:
            print(f"  Warning: Speak failed for persona {pid}: {resp['error']['message']}")
            continue

        conversation_id = resp.get("id")
        conversations.append({
            "persona_id": pid,
            "conversation_id": conversation_id,
            "initial_response": resp.get("response", ""),
        })
        print(f"✓ Speak conversation started: {conversation_id}")

        # Follow-up questions
        for question in SPEAK_QUESTIONS[1:]:
            time.sleep(3)
            follow_up = requests.post(
                f"{BASE}/speak/conversations/{conversation_id}/messages",
                headers=HEADERS,
                json={"message": question},
            ).json()

            if "error" not in follow_up:
                conversations[-1][f"response_{question[:30]}"] = follow_up.get("response", "")

        time.sleep(2)

    print(f"✓ Completed {len(conversations)} Speak conversations")
    return conversations

def run_annual_planning():
    print("=" * 60)
    print(f"{PLAN_YEAR} ANNUAL PLANNING KICKOFF")
    print("=" * 60)

    # Stage 1: CRM Analysis
    print("\n--- Stage 1: CRM Data Analysis ---")
    crm_analysis = analyze_crm_data(SAMPLE_CRM_DATA)

    # Stage 2: Create Personas
    print("\n--- Stage 2: Creating Personas from CRM Data ---")
    persona_descs = generate_persona_descriptions(crm_analysis)
    persona_ids = create_personas_from_descriptions(persona_descs)

    # Stage 3: Theme Focus Group
    print("\n--- Stage 3: Theme Validation Focus Group ---")
    fg = run_theme_focus_group(persona_ids)
    fg_results = poll_focus_group(fg["id"])

    # Stage 4: Market Research
    print("\n--- Stage 4: Mave Market Research ---")
    market_research = research_market_context()

    # Stage 5: Generate Plan
    print("\n--- Stage 5: Generating Annual Plan ---")
    plan_sections = generate_annual_plan(crm_analysis, fg_results, market_research)

    # Compile plan document
    plan_doc = f"# {COMPANY['name']} — {PLAN_YEAR} Annual Marketing Plan\n\n"
    for section, content in plan_sections.items():
        plan_doc += f"## {section.replace('_', ' ').title()}\n\n{content}\n\n---\n\n"

    with open(f"annual_plan_{PLAN_YEAR}.md", "w") as f:
        f.write(plan_doc)
    print(f"\n✓ Draft plan saved to annual_plan_{PLAN_YEAR}.md")

    # Stage 6: Speak Validation
    print("\n--- Stage 6: Speak Validation Conversations ---")
    plan_summary = plan_sections.get("executive_summary", plan_doc[:2000])
    speak_results = run_speak_conversations(persona_ids, plan_summary)

    # Save everything
    output = {
        "crm_analysis": crm_analysis,
        "personas": persona_descs,
        "persona_ids": persona_ids,
        "theme_validation": {
            "results": fg_results.get("results", []),
        },
        "market_research": {
            label: data["content"][:500]
            for label, data in market_research["research"].items()
        },
        "plan_sections": list(plan_sections.keys()),
        "speak_conversations": len(speak_results),
    }

    with open(f"planning_data_{PLAN_YEAR}.json", "w") as f:
        json.dump(output, f, indent=2)

    print(f"\n{'='*60}")
    print(f"{PLAN_YEAR} ANNUAL PLAN — COMPLETE")
    print(f"{'='*60}")
    print(f"  Plan document: annual_plan_{PLAN_YEAR}.md")
    print(f"  Supporting data: planning_data_{PLAN_YEAR}.json")
    print(f"  Personas created: {len(persona_ids)}")
    print(f"  Themes validated: {len(CANDIDATE_THEMES)}")
    print(f"  Plan sections: {len(plan_sections)}")
    print(f"  Speak conversations: {len(speak_results)}")

    return plan_sections


if __name__ == "__main__":
    run_annual_planning()