From Tech Startup to Capitalization Milestone: Anthropic's $9650B Valuation and the Arrival of AI Industry "Value Validation Era"

"""
Anthropic H-Round Funding Analysis
Demonstrates the capitalization structure and investor composition
"""

from dataclasses import dataclass
from typing import List, Dict
from decimal import Decimal

@dataclass
class FundingRound:
    """Represents a single funding round structure"""
    round_name: str
    total_amount_billions: Decimal
    pre_money_valuation: Decimal
    post_money_valuation: Decimal
    lead_investors: List[str]
    follow_on_investors: List[str]
    use_of_funds: List[str]
    
    def calculate_ownership_dilution(self) -> Decimal:
        """Calculate the percentage dilution from this round"""
        new_money = self.total_amount_billions
        pre_money = self.pre_money_valuation
        dilution = new_money / (pre_money + new_money)
        return dilution * Decimal('100')
    
    def get_investor_summary(self) -> Dict:
        """Get a summary of investor participation"""
        return {
            "lead_investors_count": len(self.lead_investors),
            "follow_on_count": len(self.follow_on_investors),
            "total_investors": len(self.lead_investors) + len(self.follow_on_investors),
            "avg_lead_allocation_billions": self.total_amount_billions / len(self.lead_investors) if self.lead_investors else Decimal('0')
        }

# H-Round Funding Structure
h_round = FundingRound(
    round_name="Series H",
    total_amount_billions=Decimal('650'),
    pre_money_valuation=Decimal('9000'),  # Pre-money: ~$9 trillion
    post_money_valuation=Decimal('9650'), # Post-money: ~$9.65 trillion
    lead_investors=[
        "Altimeter Capital",
        "Dragoneer Investment Group", 
        "Greenoaks Capital",
        "Sequoia Capital"
    ],
    follow_on_investors=[
        "Capital Group",
        "GIC (Singapore)",
        "Amazon Web Services ($50B cloud commitment)"
    ],
    use_of_funds=[
        "AI Safety Research & Development",
        "Compute Infrastructure Expansion",
        "Claude Product Ecosystem Growth",
        "Enterprise Sales & Support"
    ]
)

def analyze_h_round():
    """Comprehensive H-Round Analysis"""
    print("=" * 60)
    print("ANTHROPIC SERIES H FUNDING ANALYSIS")
    print("=" * 60)
    
    print(f"\n📊 ROUND STRUCTURE")
    print(f"   Total Amount Raised: ${h_round.total_amount_billions}B")
    print(f"   Pre-Money Valuation: ${h_round.pre_money_valuation}B")
    print(f"   Post-Money Valuation: ${h_round.post_money_valuation}B")
    
    dilution_pct = h_round.calculate_ownership_dilution()
    print(f"   Estimated Dilution: {dilution_pct:.2f}%")
    
    summary = h_round.get_investor_summary()
    print(f"\n👥 INVESTOR COMPOSITION")
    print(f"   Lead Investors: {', '.join(h_round.lead_investors)}")
    print(f"   Follow-on Investors: {', '.join(h_round.follow_on_investors)}")
    print(f"   Total Active Investors: {summary['total_investors']}")
    
    print(f"\n💰 USE OF FUNDS")
    for i, use in enumerate(h_round.use_of_funds, 1):
        print(f"   {i}. {use}")
    
    # Valuation multiple calculation
    valuation_multiple = h_round.post_money_valuation / Decimal('18')  # G-round was ~$18B
    print(f"\n📈 VALUATION JOURNEY")
    print(f"   G-Round Valuation: ~$18B (2024)")
    print(f"   H-Round Valuation: ${h_round.post_money_valuation}B (May 2026)")
    print(f"   Valuation Multiple: {valuation_multiple:.0f}x in ~2 years")
    
    return h_round

if __name__ == "__main__":
    h_round_result = analyze_h_round()

"""
Anthropic Financial Performance Analysis
Q2 2026 Annualized Revenue: $10.9B, YoY Growth: 130%
First Ever Quarterly Profit: $559M
"""

from dataclasses import dataclass
from typing import List, Tuple
import matplotlib.pyplot as plt
from datetime import datetime

@dataclass
class QuarterlyFinancials:
    """Quarterly financial performance metrics"""
    quarter: str
    revenue_annualized: float  # In billions
    year_over_year_growth: float  # Percentage
    operating_profit: float  # In billions
    net_margin: float  # Percentage
    enterprise_api_share: float  # Percentage of revenue from API calls
    
    def calculate_efficiency_ratio(self) -> float:
        """Calculate revenue per employee (simplified)"""
        # Assuming ~5000 employees and $10.9B revenue
        estimated_employees = 5000
        return (self.revenue_annualized * 1e9) / estimated_employees
    
    def is_profitable(self) -> bool:
        """Check if quarter is profitable"""
        return self.operating_profit > 0

class AnthropicFinancialAnalyzer:
    """Comprehensive financial analysis for Anthropic"""
    
    def __init__(self):
        self.quarterly_data = [
            QuarterlyFinancials(
                quarter="Q1 2025",
                revenue_annualized=4.5,
                year_over_year_growth=180,
                operating_profit=-2.1,
                net_margin=-46.7,
                enterprise_api_share=65
            ),
            QuarterlyFinancials(
                quarter="Q2 2025",
                revenue_annualized=5.8,
                year_over_year_growth=165,
                operating_profit=-1.8,
                net_margin=-31.0,
                enterprise_api_share=68
            ),
            QuarterlyFinancials(
                quarter="Q3 2025",
                revenue_annualized=7.2,
                year_over_year_growth=145,
                operating_profit=-1.2,
                net_margin=-16.7,
                enterprise_api_share=71
            ),
            QuarterlyFinancials(
                quarter="Q4 2025",
                revenue_annualized=8.5,
                year_over_year_growth=138,
                operating_profit=-0.5,
                net_margin=-5.9,
                enterprise_api_share=73
            ),
            QuarterlyFinancials(
                quarter="Q1 2026",
                revenue_annualized=9.8,
                year_over_year_growth=132,
                operating_profit=0.3,
                net_margin=3.1,
                enterprise_api_share=75
            ),
            QuarterlyFinancials(
                quarter="Q2 2026",
                revenue_annualized=10.9,
                year_over_year_growth=130,
                operating_profit=0.559,
                net_margin=5.1,
                enterprise_api_share=77
            ),
        ]
    
    def generate_profitability_timeline(self) -> List[Tuple[str, bool]]:
        """Generate timeline of profitability"""
        timeline = []
        for q in self.quarterly_data:
            timeline.append((q.quarter, q.is_profitable()))
        return timeline
    
    def calculate_revenue_run_rate(self) -> float:
        """Calculate forward revenue run rate"""
        latest = self.quarterly_data[-1]
        return latest.revenue_annualized * 1e9  # Convert to absolute dollars
    
    def project_future_revenue(self, quarters_ahead: int = 4) -> List[float]:
        """Project revenue for future quarters based on growth rate"""
        current_revenue = self.quarterly_data[-1].revenue_annualized
        current_growth = self.quarterly_data[-1].year_over_year_growth
        
        projections = []
        for i in range(quarters_ahead):
            # Assuming gradual deceleration of growth
            adjusted_growth = current_growth * (0.95 ** i)
            current_revenue *= (1 + adjusted_growth / 100)
            projections.append(current_revenue)
        
        return projections
    
    def analyze_unit_economics(self) -> dict:
        """Analyze unit economics and efficiency metrics"""
        latest = self.quarterly_data[-1]
        
        return {
            "revenue_per_employee_annual": f"${latest.calculate_efficiency_ratio():,.0f}",
            "revenue_growth_rate": f"{latest.year_over_year_growth}%",
            "enterprise_api_revenue_share": f"{latest.enterprise_api_share}%",
            "path_to_profitability": "Confirmed Profitable" if latest.is_profitable() else "Not Profitable",
            "net_margin": f"{latest.net_margin}%"
        }

def run_financial_analysis():
    """Execute comprehensive financial analysis"""
    print("=" * 70)
    print("ANTHROPIC FINANCIAL PERFORMANCE ANALYSIS - Q2 2026")
    print("=" * 70)
    
    analyzer = AnthropicFinancialAnalyzer()
    
    # Current Performance
    print("\n📊 Q2 2026 PERFORMANCE HIGHLIGHTS")
    print("-" * 50)
    latest = analyzer.quarterly_data[-1]
    print(f"   Annualized Revenue: ${latest.revenue_annualized}B")
    print(f"   Year-over-Year Growth: {latest.year_over_year_growth}%")
    print(f"   Operating Profit: ${latest.operating_profit}B")
    print(f"   Net Margin: {latest.net_margin}%")
    print(f"   Enterprise API Share: {latest.enterprise_api_share}%")
    
    # Profitability Milestone
    print("\n🎯 PROFITABILITY MILESTONE")
    print("-" * 50)
    timeline = analyzer.generate_profitability_timeline()
    for quarter, profitable in timeline:
        status = "✅ PROFITABLE" if profitable else "❌ NOT PROFITABLE"
        print(f"   {quarter}: {status}")
    
    print("\n   📌 FIRST PROFITABLE QUARTER: Q1 2026")
    print("   📌 This marks Anthropic's first profit since founding in 2021!")
    
    # Unit Economics
    print("\n💰 UNIT ECONOMICS ANALYSIS")
    print("-" * 50)
    unit_economics = analyzer.analyze_unit_economics()
    for metric, value in unit_economics.items():
        print(f"   {metric}: {value}")
    
    # Revenue Projection
    print("\n📈 REVENUE PROJECTIONS (Next 4 Quarters)")
    print("-" * 50)
    projections = analyzer.project_future_revenue(4)
    quarters = ["Q3 2026", "Q4 2026", "Q1 2027", "Q2 2027"]
    for q, proj in zip(quarters, projections):
        print(f"   {q}: ${proj:.1f}B")
    
    # Key Insight
    print("\n💡 KEY INSIGHT")
    print("-" * 50)
    print("   Anthropic has achieved the rare combination of:")
    print("   ✓ Sustained 130%+ YoY growth")
    print("   ✓ Path to profitability")
    print("   ✓ High-value enterprise revenue mix (77% API)")
    print("   This validates the 'Value Validation Era' thesis!")
    
    return analyzer.quarterly_data

if __name__ == "__main__":
    data = run_financial_analysis()

"""
Claude Opus 4.8 Dynamic Workflows Architecture
Demonstrates parallel sub-agent scheduling and task orchestration
"""

import asyncio
import uuid
from dataclasses import dataclass, field
from typing import List, Dict, Callable, Any, Optional
from enum import Enum
from datetime import datetime
import heapq

class TaskStatus(Enum):
    PENDING = "pending"
    RUNNING = "running"
    COMPLETED = "completed"
    FAILED = "failed"
    CANCELLED = "cancelled"

class TaskPriority(Enum):
    LOW = 1
    MEDIUM = 2
    HIGH = 3
    CRITICAL = 4

@dataclass
class SubAgentTask:
    """Represents a single sub-task in the workflow"""
    task_id: str
    agent_name: str
    prompt: str
    priority: TaskPriority = TaskPriority.MEDIUM
    dependencies: List[str] = field(default_factory=list)
    status: TaskStatus = TaskStatus.PENDING
    result: Optional[Any] = None
    error: Optional[str] = None
    created_at: datetime = field(default_factory=datetime.now)
    started_at: Optional[datetime] = None
    completed_at: Optional[datetime] = None
    
    def __lt__(self, other):
        """Enable priority comparison for heap"""
        return self.priority.value > other.priority.value

class ClaudeSubAgent:
    """Simulated Claude sub-agent for task execution"""
    
    def __init__(self, name: str, model: str = "claude-opus-4.8"):
        self.name = name
        self.model = model
        self.tasks_completed = 0
    
    async def execute_task(self, task: SubAgentTask) -> Any:
        """Execute a sub-agent task (simulated)"""
        task.status = TaskStatus.RUNNING
        task.started_at = datetime.now()
        
        # Simulate processing time based on task complexity
        processing_time = len(task.prompt) / 100  # 1ms per 100 chars
        await asyncio.sleep(min(processing_time, 2.0))  # Max 2 seconds
        
        # Simulate result generation
        result = {
            "agent": self.name,
            "model": self.model,
            "task_id": task.task_id,
            "output": f"Processed by {self.name}: {task.prompt[:50]}...",
            "tokens_used": len(task.prompt) * 1.3,  # ~1.3x compression
            "confidence": 0.95
        }
        
        task.result = result
        task.status = TaskStatus.COMPLETED
        task.completed_at = datetime.now()
        self.tasks_completed += 1
        
        return result

class DynamicWorkflowScheduler:
    """
    Dynamic Workflow Scheduler for Claude Opus 4.8
    Implements parallel sub-agent scheduling with dependency management
    """
    
    def __init__(self, max_concurrent_agents: int = 100):
        self.max_concurrent_agents = max_concurrent_agents
        self.active_agents: Dict[str, ClaudeSubAgent] = {}
        self.task_queue: List[SubAgentTask] = []
        self.completed_tasks: Dict[str, SubAgentTask] = {}
        self.semaphore = asyncio.Semaphore(max_concurrent_agents)
        
    def add_agent(self, agent_name: str, model: str = "claude-opus-4.8"):
        """Register a new sub-agent"""
        self.active_agents[agent_name] = ClaudeSubAgent(agent_name, model)
        print(f"✅ Registered agent: {agent_name} (model: {model})")
    
    def create_task(
        self,
        agent_name: str,
        prompt: str,
        priority: TaskPriority = TaskPriority.MEDIUM,
        dependencies: List[str] = None
    ) -> SubAgentTask:
        """Create a new sub-agent task"""
        task = SubAgentTask(
            task_id=str(uuid.uuid4())[:8],
            agent_name=agent_name,
            prompt=prompt,
            priority=priority,
            dependencies=dependencies or []
        )
        self.task_queue.append(task)
        return task
    
    def _can_execute(self, task: SubAgentTask) -> bool:
        """Check if task dependencies are satisfied"""
        for dep_id in task.dependencies:
            if dep_id not in self.completed_tasks:
                return False
            if self.completed_tasks[dep_id].status != TaskStatus.COMPLETED:
                return False
        return True
    
    async def _execute_task_wrapper(self, task: SubAgentTask):
        """Wrapper for task execution with semaphore control"""
        async with self.semaphore:
            agent = self.active_agents.get(task.agent_name)
            if not agent:
                task.status = TaskStatus.FAILED
                task.error = f"Agent {task.agent_name} not found"
                return
            
            try:
                await agent.execute_task(task)
            except Exception as e:
                task.status = TaskStatus.FAILED
                task.error = str(e)
    
    async def execute_workflow(self) -> Dict[str, SubAgentTask]:
        """Execute all tasks in the workflow with parallel scheduling"""
        print("\n🚀 Starting Dynamic Workflow Execution")
        print(f"   Total tasks: {len(self.task_queue)}")
        print(f"   Max concurrent agents: {self.max_concurrent_agents}")
        print("-" * 60)
        
        start_time = datetime.now()
        execution_tasks = []
        pending_tasks = self.task_queue.copy()
        
        while pending_tasks or execution_tasks:
            # Find tasks ready to execute
            ready_tasks = [t for t in pending_tasks if self._can_execute(t)]
            
            # Launch ready tasks
            for task in ready_tasks:
                pending_tasks.remove(task)
                coro = self._execute_task_wrapper(task)
                execution_tasks.append(asyncio.create_task(coro))
                print(f"   📤 Launched: {task.task_id} → {task.agent_name}")
            
            # Wait for at least one task to complete
            if execution_tasks:
                done, pending = await asyncio.wait(
                    execution_tasks,
                    return_when=asyncio.FIRST_COMPLETED
                )
                execution_tasks = list(pending)
                
                for task_coro in done:
                    task = next((t for t in self.task_queue if asyncio.iscoroutine(task_coro._coro) == False), None)
                    # Mark completed tasks
                    for t in self.task_queue:
                        if t.status == TaskStatus.COMPLETED:
                            self.completed_tasks[t.task_id] = t
            
            # Small delay to prevent busy waiting
            await asyncio.sleep(0.01)
        
        elapsed = (datetime.now() - start_time).total_seconds()
        print("-" * 60)
        print(f"✅ Workflow completed in {elapsed:.2f}s")
        
        return self.completed_tasks
    
    def get_workflow_stats(self) -> Dict:
        """Get workflow execution statistics"""
        completed = sum(1 for t in self.completed_tasks.values() if t.status == TaskStatus.COMPLETED)
        failed = sum(1 for t in self.completed_tasks.values() if t.status == TaskStatus.FAILED)
        
        return {
            "total_tasks": len(self.task_queue),
            "completed": completed,
            "failed": failed,
            "success_rate": (completed / len(self.task_queue) * 100) if self.task_queue else 0,
            "active_agents": len(self.active_agents),
            "total_agent_tasks": sum(a.tasks_completed for a in self.active_agents.values())
        }

async def demo_dynamic_workflows():
    """Demonstration of Claude Opus 4.8 Dynamic Workflows"""
    print("=" * 70)
    print("CLAUDE OPUS 4.8 DYNAMIC WORKFLOWS DEMONSTRATION")
    print("=" * 70)
    
    # Initialize scheduler with 100 concurrent agents
    scheduler = DynamicWorkflowScheduler(max_concurrent_agents=100)
    
    # Register specialized sub-agents
    agents = [
        "code-generator",
        "code-reviewer", 
        "test-writer",
        "documentation-agent",
        "security-scanner",
        "performance-optimizer",
        "api-integrator",
        "data-analyst"
    ]
    
    for agent in agents:
        scheduler.add_agent(agent)
    
    print("\n📋 Creating Workflow Tasks...")
    print("-" * 60)
    
    # Create a complex multi-stage development workflow
    # Stage 1: Code generation (no dependencies)
    task1 = scheduler.create_task(
        agent_name="code-generator",
        prompt="Generate REST API endpoints for user management with CRUD operations",
        priority=TaskPriority.CRITICAL
    )
    
    # Stage 2: Parallel tasks depending on code generation
    task2 = scheduler.create_task(
        agent_name="code-reviewer",
        prompt="Review the generated code for best practices and potential bugs",
        priority=TaskPriority.HIGH,
        dependencies=[task1.task_id]
    )
    
    task3 = scheduler.create_task(
        agent_name="test-writer",
        prompt="Write comprehensive unit tests covering all edge cases",
        priority=TaskPriority.HIGH,
        dependencies=[task1.task_id]
    )
    
    task4 = scheduler.create_task(
        agent_name="security-scanner",
        prompt="Scan code for security vulnerabilities and OWASP compliance",
        priority=TaskPriority.CRITICAL,
        dependencies=[task1.task_id]
    )
    
    # Stage 3: Documentation and optimization (depends on review and tests)
    task5 = scheduler.create_task(
        agent_name="documentation-agent",
        prompt="Generate API documentation with examples and usage patterns",
        priority=TaskPriority.MEDIUM,
        dependencies=[task2.task_id, task3.task_id]
    )
    
    task6 = scheduler.create_task(
        agent_name="performance-optimizer",
        prompt="Analyze and optimize query performance and caching strategies",
        priority=TaskPriority.HIGH,
        dependencies=[task2.task_id]
    )
    
    # Stage 4: Final integration
    task7 = scheduler.create_task(
        agent_name="api-integrator",
        prompt="Integrate all components and verify end-to-end functionality",
        priority=TaskPriority.CRITICAL,
        dependencies=[task5.task_id, task6.task_id, task4.task_id]
    )
    
    print(f"   Created {len(scheduler.task_queue)} tasks with complex dependencies")
    print("\n🔗 Dependency Graph:")
    for task in scheduler.task_queue:
        deps = ", ".join(task.dependencies) if task.dependencies else "none"
        print(f"   {task.task_id} ({task.agent_name}) → depends on: [{deps}]")
    
    # Execute the workflow
    await scheduler.execute_workflow()
    
    # Print statistics
    print("\n📊 Workflow Statistics:")
    print("-" * 60)
    stats = scheduler.get_workflow_stats()
    for key, value in stats.items():
        print(f"   {key}: {value}")
    
    # Show completed task results
    print("\n📄 Task Results:")
    print("-" * 60)
    for task_id, task in scheduler.completed_tasks.items():
        status_icon = "✅" if task.status == TaskStatus.COMPLETED else "❌"
        print(f"   {status_icon} {task_id} ({task.agent_name})")
        if task.result:
            print(f"      Output: {task.result['output'][:60]}...")
    
    return scheduler

if __name__ == "__main__":
    asyncio.run(demo_dynamic_workflows())

"""
Claude API Enterprise Cost-Benefit Calculator
Helps enterprises evaluate ROI of Claude API integration
"""

from dataclasses import dataclass, field
from typing import Dict, List, Optional
from enum import Enum
from decimal import Decimal, ROUND_HALF_UP
import json

class ModelType(Enum):
    CLAUDE_OPUS_4_8 = "claude-opus-4.8"
    CLAUDE_SONNET_4_8 = "claude-sonnet-4.8"
    CLAUDE_HAIKU_4_8 = "claude-haiku-4.8"

class SubscriptionTier(Enum):
    """Enterprise subscription tiers"""
    STARTER = "starter"
    PROFESSIONAL = "professional"
    ENTERPRISE = "enterprise"
    UNLIMITED = "unlimited"

@dataclass
class PricingConfig:
    """Claude API Pricing Configuration (May 2026)"""
    # Input tokens per million
    input_price_per_million: Dict[ModelType, Decimal] = field(default_factory=lambda: {
        ModelType.CLAUDE_OPUS_4_8: Decimal('15.00'),
        ModelType.CLAUDE_SONNET_4_8: Decimal('3.00'),
        ModelType.CLAUDE_HAIKU_4_8: Decimal('0.25'),
    })
    # Output tokens per million
    output_price_per_million: Dict[ModelType, Decimal] = field(default_factory=lambda: {
        ModelType.CLAUDE_OPUS_4_8: Decimal('75.00'),
        ModelType.CLAUDE_SONNET_4_8: Decimal('15.00'),
        ModelType.CLAUDE_HAIKU_4_8: Decimal('1.25'),
    })
    # Enterprise subscription discounts
    subscription_discounts: Dict[SubscriptionTier, Decimal] = field(default_factory=lambda: {
        SubscriptionTier.STARTER: Decimal('0.0'),
        SubscriptionTier.PROFESSIONAL: Decimal('0.10'),
        SubscriptionTier.ENTERPRISE: Decimal('0.20'),
        SubscriptionTier.UNLIMITED: Decimal('0.30'),
    })

@dataclass
class UsagePattern:
    """Monthly usage pattern configuration"""
    daily_requests: int
    avg_input_tokens: int  # Per request
    avg_output_tokens: int  # Per request
    working_days_per_month: int = 22
    model: ModelType = ModelType.CLAUDE_SONNET_4_8
    subscription_tier: SubscriptionTier = SubscriptionTier.PROFESSIONAL

@dataclass
class CostBenefitAnalysis:
    """Results of cost-benefit analysis"""
    monthly_api_cost: Decimal
    annual_api_cost: Decimal
    implementation_cost: Decimal
    maintenance_cost_annual: Decimal
    productivity_gain_per_employee: Decimal  # Hours saved
    hourly_rate: Decimal
    total_annual_benefit: Decimal
    net_roi: Decimal
    payback_period_months: float
    cost_per_request: Decimal

class ClaudeAPICostCalculator:
    """Enterprise Claude API Cost Calculator"""
    
    def __init__(self):
        self.pricing = PricingConfig()
    
    def calculate_monthly_usage(self, pattern: UsagePattern) -> Dict:
        """Calculate monthly token usage"""
        monthly_requests = pattern.daily_requests * pattern.working_days_per_month
        total_input_tokens = monthly_requests * pattern.avg_input_tokens
        total_output_tokens = monthly_requests * pattern.avg_output_tokens
        
        return {
            "monthly_requests": monthly_requests,
            "total_input_tokens": total_input_tokens,
            "total_output_tokens": total_output_tokens,
            "total_tokens": total_input_tokens + total_output_tokens,
            "input_millions": Decimal(total_input_tokens) / Decimal('1000000'),
            "output_millions": Decimal(total_output_tokens) / Decimal('1000000'),
        }
    
    def calculate_api_cost(
        self,
        pattern: UsagePattern,
        apply_discount: bool = True
    ) -> Decimal:
        """Calculate monthly API cost"""
        usage = self.calculate_monthly_usage(pattern)
        
        input_cost = (
            usage["input_millions"] * 
            self.pricing.input_price_per_million[pattern.model]
        )
        output_cost = (
            usage["output_millions"] * 
            self.pricing.output_price_per_million[pattern.model]
        )
        
        total_cost = input_cost + output_cost
        
        if apply_discount and pattern.subscription_tier != SubscriptionTier.STARTER:
            discount = self.pricing.subscription_discounts[pattern.subscription_tier]
            total_cost = total_cost * (Decimal('1') - discount)
        
        return total_cost.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)
    
    def calculate_total_cost_of_ownership(
        self,
        pattern: UsagePattern,
        num_employees: int,
        implementation_months: int = 3
    ) -> CostBenefitAnalysis:
        """Calculate Total Cost of Ownership (TCO)"""
        monthly_api = self.calculate_api_cost(pattern)
        annual_api = monthly_api * Decimal('12')
        
        # Implementation costs (one-time)
        avg_developer_rate = Decimal('150')  # $150/hour
        implementation_hours = num_employees * 40 * implementation_months
        implementation_cost = implementation_hours * avg_developer_rate
        
        # Annual maintenance (20% of implementation cost)
        maintenance_cost_annual = implementation_cost * Decimal('0.20')
        
        # Productivity gains
        # Assume Claude saves 2-4 hours per employee per day
        hours_saved_per_day = 3
        hourly_rate = Decimal('75')  # Average knowledge worker rate
        work_days = pattern.working_days_per_month
        
        productivity_gain_annual = (
            hours_saved_per_day * 
            num_employees * 
            work_days * 
            12 * 
            hourly_rate
        )
        
        # Total annual benefit
        total_annual_benefit = productivity_gain_annual
        annual_cost = annual_api + maintenance_cost_annual
        
        # ROI calculation
        initial_investment = implementation_cost + annual_api
        net_roi = ((total_annual_benefit - annual_cost) / initial_investment) * 100
        
        # Payback period
        if annual_api + maintenance_cost_annual > 0:
            payback_months = (implementation_cost / 
                            ((total_annual_benefit / 12) - monthly_api))
        else:
            payback_months = 0
        
        # Cost per request
        usage = self.calculate_monthly_usage(pattern)
        cost_per_request = monthly_api / Decimal(usage["monthly_requests"])
        
        return CostBenefitAnalysis(
            monthly_api_cost=monthly_api,
            annual_api_cost=annual_api,
            implementation_cost=implementation_cost,
            maintenance_cost_annual=maintenance_cost_annual,
            productivity_gain_per_employee=Decimal(hours_saved_per_day * 22 * 12),
            hourly_rate=hourly_rate,
            total_annual_benefit=total_annual_benefit,
            net_roi=net_roi,
            payback_period_months=float(max(0, payback_months)),
            cost_per_request=cost_per_request
        )

def run_cost_benefit_analysis():
    """Execute comprehensive cost-benefit analysis"""
    print("=" * 70)
    print("CLAUDE API ENTERPRISE COST-BENEFIT ANALYSIS")
    print("=" * 70)
    
    calculator = ClaudeAPICostCalculator()
    
    # Define usage patterns for different scenarios
    scenarios = {
        "Startup (10 employees)": UsagePattern(
            daily_requests=500,
            avg_input_tokens=2000,
            avg_output_tokens=1500,
            model=ModelType.CLAUDE_HAIKU_4_8,
            subscription_tier=SubscriptionTier.PROFESSIONAL
        ),
        "Mid-Market (50 employees)": UsagePattern(
            daily_requests=2000,
            avg_input_tokens=3000,
            avg_output_tokens=2000,
            model=ModelType.CLAUDE_SONNET_4_8,
            subscription_tier=SubscriptionTier.ENTERPRISE
        ),
        "Enterprise (200 employees)": UsagePattern(
            daily_requests=10000,
            avg_input_tokens=5000,
            avg_output_tokens=3000,
            model=ModelType.CLAUDE_OPUS_4_8,
            subscription_tier=SubscriptionTier.UNLIMITED
        ),
    }
    
    for scenario_name, pattern in scenarios.items():
        num_employees = {
            "Startup (10 employees)": 10,
            "Mid-Market (50 employees)": 50,
            "Enterprise (200 employees)": 200,
        }[scenario_name]
        
        print(f"\n📊 SCENARIO: {scenario_name.upper()}")
        print("-" * 60)
        
        # Calculate TCO
        analysis = calculator.calculate_total_cost_of_ownership(
            pattern=pattern,
            num_employees=num_employees
        )
        
        print(f"\n💰 COST BREAKDOWN")
        print(f"   Monthly API Cost: ${analysis.monthly_api_cost:,}")
        print(f"   Annual API Cost: ${analysis.annual_api_cost:,}")
        print(f"   Implementation Cost: ${analysis.implementation_cost:,}")
        print(f"   Annual Maintenance: ${analysis.maintenance_cost_annual:,}")
        print(f"   Total Year 1 Cost: ${analysis.annual_api_cost + analysis.implementation_cost + analysis.maintenance_cost_annual:,}")
        
        print(f"\n📈 BENEFIT ANALYSIS")
        print(f"   Hours Saved/Employee/Year: {analysis.productivity_gain_per_employee}")
        print(f"   Hourly Rate: ${analysis.hourly_rate}")
        print(f"   Total Annual Benefit: ${analysis.total_annual_benefit:,.0f}")
        
        print(f"\n🎯 ROI METRICS")
        print(f"   Net ROI: {analysis.net_roi:.1f}%")
        print(f"   Payback Period: {analysis.payback_period_months:.1f} months")
        print(f"   Cost per Request: ${analysis.cost_per_request:.4f}")
        
        # Get model info
        print(f"\n🤖 MODEL: {pattern.model.value}")
        usage = calculator.calculate_monthly_usage(pattern)
        print(f"   Monthly Requests: {usage['monthly_requests']:,}")
        print(f"   Input Millions: {usage['input_millions']:.2f}M")
        print(f"   Output Millions: {usage['output_millions']:.2f}M")
    
    # Detailed pricing reference
    print("\n" + "=" * 70)
    print("📋 CLAUDE API PRICING REFERENCE (May 2026)")
    print("=" * 70)
    print("\nPer-Million Token Pricing:")
    print("-" * 40)
    print(f"{'Model':<25} {'Input':<12} {'Output':<12}")
    print("-" * 40)
    for model in ModelType:
        inp = calculator.pricing.input_price_per_million[model]
        out = calculator.pricing.output_price_per_million[model]
        print(f"{model.value:<25} ${inp:<10} ${out:<10}")
    
    print("\nEnterprise Subscription Discounts:")
    print("-" * 40)
    for tier in SubscriptionTier:
        disc = calculator.pricing.subscription_discounts[tier]
        print(f"{tier.value:<20} {disc * 100:.0f}% off")
    
    return calculator

if __name__ == "__main__":
    calc = run_cost_benefit_analysis()

"""
Claude API Enterprise Integration SDK
Production-ready Python SDK for enterprise Claude API integration
"""

import asyncio
import aiohttp
import json
import time
import logging
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Union, AsyncIterator, Any, Callable
from enum import Enum
from datetime import datetime, timedelta
import hashlib
import hmac
from functools import wraps
import backoff

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)


class APIError(Exception):
    """Base exception for API errors"""
    def __init__(self, message: str, status_code: int = None, response: dict = None):
        self.message = message
        self.status_code = status_code
        self.response = response
        super().__init__(self.message)


class RateLimitError(APIError):
    """Rate limit exceeded error"""
    pass


class AuthenticationError(APIError):
    """Authentication failed error"""
    pass


class ModelType(Enum):
    """Available Claude models"""
    OPUS = "claude-opus-4.8"
    SONNET = "claude-sonnet-4.8"
    HAIKU = "claude-haiku-4.8"


class Role(Enum):
    """Message roles"""
    USER = "user"
    ASSISTANT = "assistant"
    SYSTEM = "system"


@dataclass
class Message:
    """Chat message structure"""
    role: Role
    content: str
    timestamp: datetime = field(default_factory=datetime.now)
    
    def to_dict(self) -> Dict:
        return {
            "role": self.role.value,
            "content": self.content
        }


@dataclass
class UsageStats:
    """Token usage statistics"""
    input_tokens: int
    output_tokens: int
    total_tokens: int
    
    @property
    def cost_estimate(self) -> float:
        """Estimate cost in USD (approximate)"""
        # Using Claude Sonnet pricing as reference
        input_cost = (self.input_tokens / 1_000_000) * 3.0
        output_cost = (self.output_tokens / 1_000_000) * 15.0
        return input_cost + output_cost


@dataclass
class APIResponse:
    """API response structure"""
    content: str
    model: str
    stop_reason: str
    usage: UsageStats
    request_id: str
    latency_ms: float
    cached: bool = False
    
    def to_dict(self) -> Dict:
        return {
            "content": self.content,
            "model": self.model,
            "stop_reason": self.stop_reason,
            "usage": {
                "input_tokens": self.usage.input_tokens,
                "output_tokens": self.usage.output_tokens,
                "total_tokens": self.usage.total_tokens,
                "cost_estimate": self.usage.cost_estimate
            },
            "request_id": self.request_id,
            "latency_ms": self.latency_ms,
            "cached": self.cached
        }


@dataclass
class StreamChunk:
    """Streaming response chunk"""
    type: str
    content: str = ""
    delta: str = ""
    usage: Optional[UsageStats] = None
    stop_reason: Optional[str] = None


class ClaudeAPIClient:
    """
    Production-ready Claude API client with:
    - Automatic retry with exponential backoff
    - Rate limiting
    - Streaming support
    - Request/response caching
    - Comprehensive error handling
    - Usage tracking
    """
    
    BASE_URL = "https://api.anthropic.com/v1"
    MAX_RETRIES = 3
    DEFAULT_TIMEOUT = 60
    
    def __init__(
        self,
        api_key: str,
        base_url: str = None,
        max_requests_per_minute: int = 1000,
        enable_caching: bool = True,
        cache_ttl_seconds: int = 3600,
        default_model: ModelType = ModelType.SONNET
    ):
        self.api_key = api_key
        self.base_url = base_url or self.BASE_URL
        self.max_rpm = max_requests_per_minute
        self.enable_caching = enable_caching
        self.cache_ttl = cache_ttl_seconds
        self.default_model = default_model
        
        # Rate limiting
        self.request_times: List[float] = []
        
        # Usage tracking
        self.total_requests = 0
        self.total_input_tokens = 0
        self.total_output_tokens = 0
        self.total_cost = 0.0
        
        # Cache storage
        self._cache: Dict[str, tuple] = {}  # key -> (response, timestamp)
        
        # Session management
        self._session: Optional[aiohttp.ClientSession] = None
    
    async def _get_session(self) -> aiohttp.ClientSession:
        """Get or create aiohttp session"""
        if self._session is None or self._session.closed:
            self._session = aiohttp.ClientSession(
                headers={
                    "x-api-key": self.api_key,
                    "anthropic-version": "2023-06-01",
                    "Content-Type": "application/json"
                },
                timeout=aiohttp.ClientTimeout(total=self.DEFAULT_TIMEOUT)
            )
        return self._session
    
    def _check_rate_limit(self):
        """Check and enforce rate limiting"""
        current_time = time.time()
        
        # Remove requests older than 1 minute
        self.request_times = [
            t for t in self.request_times 
            if current_time - t < 60
        ]
        
        if len(self.request_times) >= self.max_rpm:
            sleep_time = 60 - (current_time - self.request_times[0])
            if sleep_time > 0:
                logger.warning(f"Rate limit reached. Sleeping for {sleep_time:.1f}s")
                time.sleep(sleep_time)
        
        self.request_times.append(current_time)
    
    def _generate_cache_key(
        self,
        messages: List[Message],
        model: ModelType,
        **kwargs
    ) -> str:
        """Generate cache key for request"""
        content = json.dumps({
            "messages": [m.to_dict() for m in messages],
            "model": model.value,
            **kwargs
        }, sort_keys=True)
        return hashlib.sha256(content.encode()).hexdigest()
    
    def _get_cached_response(self, cache_key: str) -> Optional[APIResponse]:
        """Get cached response if available and not expired"""
        if not self.enable_caching or cache_key not in self._cache:
            return None
        
        response, timestamp = self._cache[cache_key]
        if time.time() - timestamp < self.cache_ttl:
            logger.info(f"Cache hit for key: {cache_key[:16]}...")
            response.cached = True
            return response
        
        del self._cache[cache_key]
        return None
    
    def _cache_response(self, cache_key: str, response: APIResponse):
        """Cache a response"""
        if self.enable_caching:
            self._cache[cache_key] = (response, time.time())
            logger.info(f"Cached response: {cache_key[:16]}...")
    
    @backoff.on_exception(
        backoff.expo,
        (aiohttp.ClientError, asyncio.TimeoutError),
        max_tries=3,
        max_time=30
    )
    async def _make_request(
        self,
        endpoint: str,
        payload: Dict
    ) -> Dict:
        """Make HTTP request with retry logic"""
        self._check_rate_limit()
        
        session = await self._get_session()
        url = f"{self.base_url}{endpoint}"
        
        async with session.post(url, json=payload) as response:
            if response.status == 429:
                raise RateLimitError(
                    "Rate limit exceeded",
                    status_code=429
                )
            elif response.status == 401:
                raise AuthenticationError(
                    "Invalid API key",
                    status_code=401
                )
            elif response.status >= 400:
                error_text = await response.text()
                raise APIError(
                    f"API error: {error_text}",
                    status_code=response.status
                )
            
            return await response.json()
    
    async def chat(
        self,
        messages: List[Message],
        model: ModelType = None,
        max_tokens: int = 4096,
        temperature: float = 1.0,
        system_prompt: str = None,
        stop_sequences: List[str] = None,
        stream: bool = False,
        **kwargs
    ) -> Union[APIResponse, AsyncIterator[StreamChunk]]:
        """
        Send a chat request to Claude API
        
        Args:
            messages: List of conversation messages
            model: Claude model to use
            max_tokens: Maximum tokens in response
            temperature: Sampling temperature (0-1)
            system_prompt: System prompt for context
            stop_sequences: Sequences that stop generation
            stream: Enable streaming response
            **kwargs: Additional parameters
        
        Returns:
            APIResponse or AsyncIterator of StreamChunks
        """
        model = model or self.default_model
        
        # Check cache for non-streaming requests
        if not stream and self.enable_caching:
            cache_key = self._generate_cache_key(
                messages, model, 
                max_tokens=max_tokens,
                temperature=temperature,
                **kwargs
            )
            cached = self._get_cached_response(cache_key)
            if cached:
                return cached
        
        # Build request payload
        payload = {
            "model": model.value,
            "messages": [m.to_dict() for m in messages],
            "max_tokens": max_tokens,
            "temperature": temperature,
            **kwargs
        }
        
        if system_prompt:
            payload["system"] = system_prompt
        
        if stop_sequences:
            payload["stop_sequences"] = stop_sequences
        
        start_time = time.time()
        
        try:
            if stream:
                return self._stream_response(payload)
            else:
                return await self._non_stream_response(payload, start_time, cache_key if self.enable_caching else None)
        
        except APIError as e:
            logger.error(f"API Error: {e.message}")
            raise
    
    async def _non_stream_response(
        self,
        payload: Dict,
        start_time: float,
        cache_key: str = None
    ) -> APIResponse:
        """Handle non-streaming response"""
        response_data = await self._make_request("/messages", payload)
        
        latency_ms = (time.time() - start_time) * 1000
        
        # Parse response
        content = response_data["content"][0]["text"]
        usage = response_data["usage"]
        
        response = APIResponse(
            content=content,
            model=payload["model"],
            stop_reason=response_data["stop_reason"],
            usage=UsageStats(
                input_tokens=usage["input_tokens"],
                output_tokens=usage["output_tokens"],
                total_tokens=usage["input_tokens"] + usage["output_tokens"]
            ),
            request_id=response_data["id"],
            latency_ms=latency_ms
        )
        
        # Update stats
        self._update_stats(response)
        
        # Cache response
        if cache_key:
            self._cache_response(cache_key, response)
        
        return response
    
    async def _stream_response(self, payload: Dict) -> AsyncIterator[StreamChunk]:
        """Handle streaming response"""
        payload["stream"] = True
        
        session = await self._get_session()
        url = f"{self.base_url}/messages"
        
        self._check_rate_limit()
        
        async with session.post(url, json=payload) as response:
            if response.status >= 400:
                error_text = await response.text()
                raise APIError(f"Stream error: {error_text}", status_code=response.status)
            
            async for line in response.content:
                line = line.decode('utf-8').strip()
                
                if not line or not line.startswith('data: '):
                    continue
                
                data = line[6:]  # Remove 'data: ' prefix
                
                if data == '[DONE]':
                    break
                
                try:
                    event = json.loads(data)
                    event_type = event.get("type")
                    
                    if event_type == "content_block_delta":
                        yield StreamChunk(
                            type=event_type,
                            delta=event["delta"].get("text", ""),
                            content=event["delta"].get("text", "")
                        )
                    elif event_type == "message_delta":
                        yield StreamChunk(
                            type=event_type,
                            stop_reason=event["delta"].get("stop_reason")
                        )
                    elif event_type == "message_stop":
                        break
                
                except json.JSONDecodeError:
                    continue
    
    def _update_stats(self, response: APIResponse):
        """Update usage statistics"""
        self.total_requests += 1
        self.total_input_tokens += response.usage.input_tokens
        self.total_output_tokens += response.usage.output_tokens
        self.total_cost += response.usage.cost_estimate
    
    def get_usage_report(self) -> Dict:
        """Get comprehensive usage report"""
        return {
            "total_requests": self.total_requests,
            "total_input_tokens": self.total_input_tokens,
            "total_output_tokens": self.total_output_tokens,
            "total_tokens": self.total_input_tokens + self.total_output_tokens,
            "estimated_cost": self.total_cost,
            "cache_hit_rate": len([k for k, v in self._cache.items() if time.time() - v[1] < 3600]) / max(1, self.total_requests) * 100
        }
    
    async def close(self):
        """Close the client session"""
        if self._session and not self._session.closed:
            await self._session.close()


# Example usage and demonstration
async def demo_claude_sdk():
    """Demonstrate Claude SDK usage"""
    print("=" * 70)
    print("CLAUDE API ENTERPRISE SDK DEMONSTRATION")
    print("=" * 70)
    
    # Initialize client (in production, use environment variable for API key)
    api_key = "sk-ant-api03-demo-key"  # Demo key placeholder
    
    client = ClaudeAPIClient(
        api_key=api_key,
        max_requests_per_minute=1000,
        enable_caching=True,
        default_model=ModelType.SONNET
    )
    
    print("\n✅ Claude API Client initialized")
    print(f"   Base URL: {client.base_url}")
    print(f"   Max RPM: {client.max_rpm}")
    print(f"   Caching: {'Enabled' if client.enable_caching else 'Disabled'}")
    
    # Example 1: Simple chat completion
    print("\n📝 Example 1: Simple Chat Completion")
    print("-" * 50)
    
    messages = [
        Message(role=Role.USER, content="Explain quantum computing in simple terms")
    ]
    
    try:
        response = await client.chat(
            messages=messages,
            max_tokens=500,
            temperature=0.7
        )
        
        print(f"   Model: {response.model}")
        print(f"   Latency: {response.latency_ms:.0f}ms")
        print(f"   Tokens: {response.usage.total_tokens}")
        print(f"   Cost: ${response.usage.cost_estimate:.6f}")
        print(f"   Cached: {response.cached}")
        print(f"\n   Response:\n   {response.content[:200]}...")
        
    except APIError as e:
        print(f"   Error: {e.message}")
    
    # Example 2: Multi-turn conversation
    print("\n💬 Example 2: Multi-turn Conversation")
    print("-" * 50)
    
    conversation = [
        Message(role=Role.SYSTEM, content="You are a helpful Python coding assistant."),
        Message(role=Role.USER, content="Write a function to calculate fibonacci numbers"),
        Message(role=Role.ASSISTANT, content="Here's a Python function to calculate fibonacci numbers:"),
    ]
    
    # Add continuation
    conversation.append(
        Message(role=Role.USER, content="Now optimize it with memoization")
    )
    
    try:
        response = await client.chat(
            messages=conversation,
            max_tokens=800,
            system_prompt="Provide efficient, well-documented code"
        )
        
        print(f"   Tokens Used: {response.usage.total_tokens}")
        print(f"   Response:\n   {response.content[:300]}...")
        
    except APIError as e:
        print(f"   Error: {e.message}")
    
    # Example 3: Streaming response
    print("\n🌊 Example 3: Streaming Response")
    print("-" * 50)
    
    messages = [
        Message(role=Role.USER, content="Count from 1 to 5, one number per line")
    ]
    
    try:
        print("   Streaming: ", end="", flush=True)
        response_stream = client.chat(
            messages=messages,
            max_tokens=100,
            stream=True
        )
        
        full_response = ""
        async for chunk in response_stream:
            if chunk.content:
                print(chunk.content, end="", flush=True)
                full_response += chunk.content
        
        print("\n   ✅ Streaming complete!")
        
    except APIError as e:
        print(f"   Error: {e.message}")
    
    # Example 4: Usage report
    print("\n📊 Usage Report")
    print("-" * 50)
    report = client.get_usage_report()
    for key, value in report.items():
        if isinstance(value, float):
            print(f"   {key}: {value:.2f}")
        else:
            print(f"   {key}: {value}")
    
    # Cleanup
    await client.close()
    print("\n✅ Client session closed")
    
    return client


# Run demonstration
if __name__ == "__main__":
    asyncio.run(demo_claude_sdk())

"""
AI Investment ROI Analysis Model
Comprehensive framework for evaluating AI investments and projects
"""

import numpy as np
import pandas as pd
from dataclasses import dataclass, field
from typing import List, Dict, Tuple, Optional
from datetime import datetime, timedelta
import json

@dataclass
class InvestmentParameters:
    """Parameters for AI investment analysis"""
    # Capital Expenditure
    initial_investment: float  # Initial CAPEX
    annual_operating_cost: float  # Annual OPEX
    
    # Revenue Parameters
    baseline_revenue_per_user: float  # Revenue per user without AI
    enhanced_revenue_per_user: float  # Revenue per user with AI
    num_users: int  # Number of users/customers
    annual_user_growth_rate: float  # YoY user growth %
    
    # Efficiency Gains
    hours_saved_per_employee_annually: float
    num_employees: int
    average_hourly_cost: float  # Fully loaded cost per hour
    
    # Time Parameters
    project_duration_years: int
    discount_rate: float  # WACC or required return %
    
    # Risk Parameters
    probability_of_success: float  # 0-1
    probability_of_market_adoption: float  # 0-1

@dataclass
class ROIMetrics:
    """Calculated ROI metrics"""
    # Basic Metrics
    total_investment: float
    total_benefits: float
    net_benefit: float
    simple_roi: float
    annualized_roi: float
    
    # NPV Analysis
    npv: float
    discounted_payback_years: Optional[float]
    
    # Internal Rate of Return
    irr: float
    
    # Risk-Adjusted Metrics
    expected_npv: float
    risk_adjusted_roi: float
    
    # Additional Metrics
    break_even_month: int
    cost_per_user_acquired: float
    lifetime_value_impact: float

class AIInvestmentAnalyzer:
    """Comprehensive AI Investment ROI Analysis"""
    
    def __init__(self, params: InvestmentParameters):
        self.params = params
        self.annual_cash_flows = []
        self.cumulative_cash_flows = []
    
    def calculate_annual_cash_flows(self) -> List[Tuple[int, float]]:
        """Calculate year-by-year cash flows"""
        self.annual_cash_flows = []
        
        initial_cost = self.params.initial_investment
        
        for year in range(1, self.params.project_duration_years + 1):
            # Calculate user base growth
            user_multiplier = (1 + self.params.annual_user_growth_rate / 100) ** (year - 1)
            current_users = self.params.num_users * user_multiplier
            
            # Revenue impact
            revenue_diff_per_user = (
                self.params.enhanced_revenue_per_user - 
                self.params.baseline_revenue_per_user
            )
            total_revenue_impact = revenue_diff_per_user * current_users
            
            # Efficiency gains
            total_efficiency_savings = (
                self.params.hours_saved_per_employee_annually *
                self.params.num_employees *
                self.params.average_hourly_cost
            )
            
            # Total benefits
            total_benefits = total_revenue_impact + total_efficiency_savings
            
            # Operating costs (grow with inflation)
            inflation_factor = 1.03 ** (year - 1)  # 3% annual inflation
            current_opex = self.params.annual_operating_cost * inflation_factor
            
            # Net cash flow
            if year == 1:
                net_cash_flow = -initial_cost + total_benefits - current_opex
            else:
                net_cash_flow = total_benefits - current_opex
            
            self.annual_cash_flows.append((year, net_cash_flow))
        
        return self.annual_cash_flows
    
    def calculate_npv(self) -> float:
        """Calculate Net Present Value"""
        self.calculate_annual_cash_flows()
        
        npv = 0
        discount_factor = 1 + self.params.discount_rate / 100
        
        for year, cash_flow in self.annual_cash_flows:
            npv += cash_flow / (discount_factor ** year)
        
        return npv
    
    def calculate_irr(self) -> float:
        """Calculate Internal Rate of Return using Newton-Raphson"""
        self.calculate_annual_cash_flows()
        
        # Initial guess
        irr = 0.1
        
        for _ in range(1000):
            # Calculate NPV at current IRR guess
            npv = 0
            npv_derivative = 0
            
            for year, cash_flow in self.annual_cash_flows:
                discount_factor = (1 + irr) ** year
                npv += cash_flow / discount_factor
                npv_derivative -= year * cash_flow / (discount_factor * (1 + irr))
            
            # Newton-Raphson update
            if abs(npv_derivative) < 1e-10:
                break
            
            new_irr = irr - npv / npv_derivative
            
            if abs(new_irr - irr) < 1e-8:
                irr = new_irr
                break
            
            irr = new_irr
        
        return irr * 100  # Return as percentage
    
    def calculate_payback_period(self) -> Tuple[float, int]:
        """Calculate payback period in years and months"""
        self.calculate_annual_cash_flows()
        
        cumulative = -self.params.initial_investment
        
        for year, cash_flow in self.annual_cash_flows:
            cumulative += cash_flow
            
            if cumulative >= 0:
                # Calculate fractional year
                prev_cumulative = cumulative - cash_flow
                fractional_year = abs(prev_cumulative) / cash_flow
                return (year - 1 + fractional_year, (year - 1) * 12 + int(fractional_year * 30))
        
        return (-1, -1)  # Never pays back
    
    def calculate_break_even_analysis(self) -> Dict:
        """Calculate break-even analysis"""
        # Break-even: Total Benefits = Total Costs
        # Solve for number of users
        
        total_fixed_costs = self.params.initial_investment
        annual_opex = self.params.annual_operating_cost
        
        revenue_per_user = (
            self.params.enhanced_revenue_per_user - 
            self.params.baseline_revenue_per_user
        )
        efficiency_benefit = (
            self.params.hours_saved_per_employee_annually *
            self.params.num_employees *
            self.params.average_hourly_cost
        )
        
        # Annual benefit per user
        benefit_per_user = revenue_per_user + (efficiency_benefit / self.params.num_users)
        
        # Break-even users
        break_even_users = total_fixed_costs / (benefit_per_user - annual_opex / self.params.num_users)
        
        return {
            "break_even_users": int(break_even_users),
            "current_users": self.params.num_users,
            "months_to_break_even": self.calculate_payback_period()[1],
            "margin_of_safety": ((self.params.num_users - break_even_users) / self.params.num_users) * 100
        }
    
    def run_full_analysis(self) -> ROIMetrics:
        """Run complete ROI analysis"""
        # Calculate base metrics
        self.calculate_annual_cash_flows()
        
        total_investment = (
            self.params.initial_investment + 
            self.params.annual_operating_cost * self.params.project_duration_years
        )
        
        total_benefits = sum(cf for _, cf in self.annual_cash_flows) + self.params.initial_investment
        
        net_benefit = total_benefits - total_investment
        simple_roi = (net_benefit / total_investment) * 100
        
        # Time-adjusted metrics
        years = self.params.project_duration_years
        annualized_roi = (((1 + simple_roi / 100) ** (1 / years)) - 1) * 100
        
        npv = self.calculate_npv()
        irr = self.calculate_irr()
        payback = self.calculate_payback_period()
        
        # Risk-adjusted metrics
        expected_npv = npv * self.params.probability_of_success * self.params.probability_of_market_adoption
        risk_adjusted_roi = (expected_npv / total_investment) * 100
        
        # Break-even
        break_even = self.calculate_break_even_analysis()
        
        return ROIMetrics(
            total_investment=total_investment,
            total_benefits=total_benefits,
            net_benefit=net_benefit,
            simple_roi=simple_roi,
            annualized_roi=annualized_roi,
            npv=npv,
            discounted_payback_years=payback[0],
            irr=irr,
            expected_npv=expected_npv,
            risk_adjusted_roi=risk_adjusted_roi,
            break_even_month=payback[1],
            cost_per_user_acquired=total_investment / self.params.num_users,
            lifetime_value_impact=net_benefit / self.params.num_users
        )
    
    def generate_sensitivity_analysis(
        self,
        variable: str,
        range_pct: float = 20,
        steps: int = 5
    ) -> pd.DataFrame:
        """Generate sensitivity analysis for a variable"""
        original_value = getattr(self.params, variable)
        
        results = []
        step_size = original_value * (range_pct / 100) / steps
        
        for i in range(-steps, steps + 1):
            setattr(self.params, variable, original_value + (i * step_size))
            
            npv = self.calculate_npv()
            irr = self.calculate_irr()
            
            results.append({
                "value": getattr(self.params, variable),
                "npv": npv,
                "irr": irr,
                "change_pct": (i * step_size / original_value) * 100
            })
        
        # Restore original value
        setattr(self.params, variable, original_value)
        
        return pd.DataFrame(results)


def demo_ai_investment_analysis():
    """Demonstrate AI investment analysis"""
    print("=" * 70)
    print("AI INVESTMENT ROI ANALYSIS MODEL")
    print("=" * 70)
    
    # Scenario: Mid-sized enterprise investing in Claude API
    params = InvestmentParameters(
        initial_investment=500000,  # $500K initial CAPEX
        annual_operating_cost=200000,  # $200K annual OPEX
        baseline_revenue_per_user=100,  # $100/user/month without AI
        enhanced_revenue_per_user=180,  # $180/user/month with AI
        num_users=5000,  # 5,000 customers
        annual_user_growth_rate=15,  # 15% annual growth
        hours_saved_per_employee_annually=500,  # 500 hours per employee
        num_employees=100,  # 100 employees
        average_hourly_cost=75,  # $75/hour fully loaded
        project_duration_years=5,
        discount_rate=12,  # 12% WACC
        probability_of_success=0.85,
        probability_of_market_adoption=0.75
    )
    
    # Run analysis
    analyzer = AIInvestmentAnalyzer(params)
    metrics = analyzer.run_full_analysis()
    
    print("\n📊 INVESTMENT PARAMETERS")
    print("-" * 50)
    print(f"   Initial Investment: ${params.initial_investment:,}")
    print(f"   Annual Operating Cost: ${params.annual_operating_cost:,}")
    print(f"   Current Users: {params.num_users:,}")
    print(f"   User Growth Rate: {params.annual_user_growth_rate}%")
    print(f"   Project Duration: {params.project_duration_years} years")
    print(f"   Discount Rate: {params.discount_rate}%")
    
    print("\n💰 CASH FLOW PROJECTIONS")
    print("-" * 50)
    print(f"{'Year':<8} {'Cash Flow':<18} {'Cumulative':<18}")
    print("-" * 50)
    cumulative = 0
    for year, cf in analyzer.annual_cash_flows:
        cumulative += cf
        print(f"{year:<8} ${cf:>14,.0f}    ${cumulative:>14,.0f}")
    
    print("\n🎯 KEY ROI METRICS")
    print("-" * 50)
    print(f"   Net Present Value (NPV): ${metrics.npv:,.0f}")
    print(f"   Internal Rate of Return (IRR): {metrics.irr:.1f}%")
    print(f"   Simple ROI: {metrics.simple_roi:.1f}%")
    print(f"   Annualized ROI: {metrics.annualized_roi:.1f}%")
    print(f"   Payback Period: {metrics.discounted_payback_years:.1f} years ({metrics.break_even_month} months)")
    
    print("\n⚠️ RISK-ADJUSTED METRICS")
    print("-" * 50)
    print(f"   Success Probability: {params.probability_of_success * 100:.0f}%")
    print(f"   Market Adoption Probability: {params.probability_of_market_adoption * 100:.0f}%")
    print(f"   Expected NPV: ${metrics.expected_npv:,.0f}")
    print(f"   Risk-Adjusted ROI: {metrics.risk_adjusted_roi:.1f}%")
    
    # Break-even analysis
    break_even = analyzer.calculate_break_even_analysis()
    print("\n📈 BREAK-EVEN ANALYSIS")
    print("-" * 50)
    print(f"   Break-Even Users Required: {break_even['break_even_users']:,}")
    print(f"   Current Users: {break_even['current_users']:,}")
    print(f"   Margin of Safety: {break_even['margin_of_safety']:.1f}%")
    
    # Investment summary
    print("\n💎 INVESTMENT SUMMARY")
    print("-" * 50)
    print(f"   Total Investment (5 years): ${metrics.total_investment:,.0f}")
    print(f"   Total Benefits: ${metrics.total_benefits:,.0f}")
    print(f"   Net Benefit: ${metrics.net_benefit:,.0f}")
    print(f"   Cost per User Acquired: ${metrics.cost_per_user_acquired:.2f}")
    print(f"   LTV Impact per User: ${metrics.lifetime_value_impact:.2f}")
    
    # Sensitivity analysis
    print("\n📉 SENSITIVITY ANALYSIS: User Growth Rate")
    print("-" * 50)
    sensitivity = analyzer.generate_sensitivity_analysis("annual_user_growth_rate", 30, 6)
    print(f"{'Growth Rate':<15} {'NPV':<18} {'IRR':<10}")
    for _, row in sensitivity.iterrows():
        print(f"{row['change_pct']:>+8.0f}%       ${row['npv']:>14,.0f}    {row['irr']:>7.1f}%")
    
    # Recommendation
    print("\n" + "=" * 70)
    print("📋 INVESTMENT RECOMMENDATION")
    print("=" * 70)
    
    if metrics.expected_npv > 0 and metrics.irr > params.discount_rate:
        print("\n   ✅ RECOMMENDATION: PROCEED WITH INVESTMENT")
        print(f"   • Positive Expected NPV: ${metrics.expected_npv:,.0f}")
        print(f"   • IRR ({metrics.irr:.1f}%) exceeds required return ({params.discount_rate}%)")
        print(f"   • Payback period of {metrics.break_even_month} months is acceptable")
    else:
        print("\n   ❌ RECOMMENDATION: DO NOT PROCEED")
        print("   • Negative Expected NPV indicates investment destruction")
    
    return analyzer, metrics


if __name__ == "__main__":
    analyzer, metrics = demo_ai_investment_analysis()