import openai

def generate_case_study_section(project_data, section_type):
    prompts = {
        "challenge": "Write a challenge section for a case study. "
                     "Focus on specific technical problems. "
                     "Keep it to 150 words.",
        "solution": "Write a solution section. "
                    "Explain the technical approach clearly.",
        "results": "Write a results section with specific metrics. "
                   "Use bullet points for key achievements."
    }

    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You write technical case studies."},
            {"role": "user", "content": f"{prompts[section_type]}\n\n{project_data}"}
        ],
        temperature=0.7
    )
    return response.choices[0].message.content

import anthropic

def generate_case_study_from_template(project_data: dict, template_name: str = "standard") -> str:
    """Generate case study sections using a predefined template."""

    client = anthropic.Anthropic()

    templates = {
        "standard": {
            "challenge": 200,
            "solution": 300,
            "results": 200,
            "conclusion": 150
        },
        "technical": {
            "problem_statement": 250,
            "technical_approach": 400,
            "architecture_decisions": 300,
            "lessons_learned": 200
        },
        "business": {
            "business_context": 200,
            "challenge": 250,
            "solution": 300,
            "metrics": 150,
            "roi": 100
        }
    }

    template = templates[template_name]
    sections = {}

    for section, word_count in template.items():
        prompt = f"""
        Write a {word_count}-word case study section titled "{section}".

        Project context:
        - Company: {project_data.get('company')}
        - Industry: {project_data.get('industry')}
        - Challenge: {project_data.get('challenge')}
        - Solution: {project_data.get('solution')}
        - Results: {project_data.get('results')}

        Section requirements:
        - Approximately {word_count} words
        - Technical but accessible tone
        - Include specific metrics where relevant
        """

        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=1500,
            messages=[{"role": "user", "content": prompt}]
        )

        sections[section] = response.content[0].text

    return sections

# Usage
project = {
    "company": "TechCorp Inc",
    "industry": "SaaS",
    "challenge": "Scaled from 10K to 100K users in 6 months",
    "solution": "Migrated to microservices on Kubernetes",
    "results": "99.99% uptime, 80% cost reduction"
}

sections = generate_case_study_from_template(project, template_name="technical")
for section, content in sections.items():
    print(f"\n## {section.title()}\n{content}")

def generate_case_study_variations(project_data: dict, num_variations: int = 3) -> list[str]:
    """Create multiple case study versions optimized for different audiences."""

    client = anthropic.Anthropic()

    audiences = [
        "CTOs and technical leaders",
        "Business decision-makers and CFOs",
        "Startup founders and entrepreneurs"
    ]

    variations = []

    for i, audience in enumerate(audiences[:num_variations]):
        prompt = f"""
        Write a compelling case study for {audience}.

        Project: {project_data['company']} - {project_data['industry']}
        Challenge: {project_data['challenge']}
        Solution: {project_data['solution']}
        Results: {project_data['results']}

        Optimization for {audience}:
        - Emphasize aspects most relevant to this audience
        - Use terminology they prefer
        - Highlight metrics they care about
        - Keep tone and depth appropriate for the audience

        Structure:
        1. Hook (compelling opening)
        2. Context (their situation)
        3. Challenge (what they faced)
        4. Solution (how you helped)
        5. Results (measurable outcomes)
        6. CTA (what's next)
        """

        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=2000,
            messages=[{"role": "user", "content": prompt}]
        )

        variations.append({
            "audience": audience,
            "content": response.content[0].text
        })

    return variations

# Usage
variations = generate_case_study_variations(project_data, num_variations=3)
for variation in variations:
    print(f"\n=== For {variation['audience']} ===\n{variation['content']}")

def batch_generate_case_studies(projects: list[dict]) -> dict:
    """Generate case studies for multiple projects in one workflow."""

    client = anthropic.Anthropic()
    results = {}

    for project in projects:
        prompt = f"""
        Generate a professional case study with these specifications:

        Company: {project['name']}
        Industry: {project['industry']}
        Challenge: {project['challenge']}
        Solution: {project['solution']}
        Results: {project['results']}
        Timeline: {project.get('timeline', 'Not specified')}

        Format as Markdown with these sections:
        ## Executive Summary
        ## The Challenge
        ## Our Approach
        ## Results
        ## Key Takeaways

        Include 1-2 relevant code snippets if applicable.
        Target length: 1,500-2,000 words.
        """

        response = client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=2500,
            messages=[{"role": "user", "content": prompt}]
        )

        results[project['name']] = response.content[0].text

    return results

# Usage
projects = [
    {"name": "Project A", "industry": "Finance", "challenge": "..."},
    {"name": "Project B", "industry": "Healthcare", "challenge": "..."},
]

case_studies = batch_generate_case_studies(projects)

# Save to individual files
for project_name, content in case_studies.items():
    with open(f"case-study-{project_name}.md", "w") as f:
        f.write(content)

def validate_case_study(content: str, original_project: dict) -> dict:
    """Check case study for accuracy and quality."""

    checks = {
        "mentions_client": project_name in content,
        "includes_metrics": any(metric in content for metric in original_project.get('metrics', [])),
        "has_structure": all(
            section in content.lower()
            for section in ['challenge', 'solution', 'results']
        ),
        "word_count": len(content.split()) >= 1200,
        "no_generic_language": not any(
            phrase in content.lower()
            for phrase in ['very effective', 'very important', 'unique approach']
        ),
        "specific_outcomes": bool(
            any(char.isdigit() for char in content)  # Contains numbers/metrics
        )
    }

    return {
        "valid": all(checks.values()),
        "passed": sum(checks.values()),
        "total": len(checks),
        "issues": [k for k, v in checks.items() if not v]
    }

# Usage
validation = validate_case_study(
    content=generated_case_study,
    original_project=project_data
)

if not validation["valid"]:
    print(f"Issues found: {validation['issues']}")
    print(f"Passed {validation['passed']}/{validation['total']} checks")

def publish_case_study(content: str, metadata: dict):
    """Save case study with metadata for publishing."""

    import json
    from datetime import datetime

    # Add front matter for static site generators
    front_matter = f"""---
title: {metadata['company']} Case Study
description: {metadata['challenge'][:150]}...
author: AI-assisted
date: {datetime.now().isoformat()}
industry: {metadata['industry']}---
"""

 full_content = f"{front_matter}\n\n{content}"

 # Save to file
 filename = f"case-study-{metadata['company'].lower().replace(' ', '-')}.md"
 with open(filename, "w") as f:
 f.write(full_content)

 # Track in JSON index for easy discovery
 with open("case-studies-index.json", "r") as f:
 index = json.load(f)

 index["case_studies"].append({
 "title": metadata['company'],
 "file": filename,
 "industry": metadata['industry'],
 "date_published": datetime.now().isoformat()
 })

 with open("case-studies-index.json", "w") as f:
 json.dump(index, f, indent=2)

 return filename