app.py

import streamlit as st
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import numpy as np
from datetime import datetime

# Page configuration
st.set_page_config(
    page_title="GPT-4o mini Pricing Calculator",
    page_icon="🤖",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom styling
st.markdown("""
<style>
    .main {
        background-color: #f9f9f9;
        padding: 1rem;
    }
    .title-container {
        background-color: #f0f2f6;
        padding: 1rem;
        border-radius: 10px;
        margin-bottom: 1rem;
    }
    .metric-container {
        background-color: white;
        padding: 1rem;
        border-radius: 10px;
        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
        margin-bottom: 1rem;
    }
    .sub-header {
        font-weight: bold;
        color: #3366CC;
        margin-bottom: 0.5rem;
    }
    .footer {
        text-align: center;
        margin-top: 2rem;
        font-size: 0.8rem;
        color: #666;
    }
    .stTabs [data-baseweb="tab-list"] {
        gap: 24px;
    }
    .stTabs [data-baseweb="tab"] {
        height: 50px;
        white-space: pre-wrap;
        background-color: #f9f9f9;
        border-radius: 4px 4px 0px 0px;
        padding: 10px;
    }
    .stTabs [aria-selected="true"] {
        background-color: #3366CC;
        color: white;
    }
</style>
""", unsafe_allow_html=True)

# Title section
st.markdown('<div class="title-container">', unsafe_allow_html=True)
st.title("GPT-4o mini Pricing Calculator")
st.markdown("Interactive cost analysis for text and audio processing using GPT-4o mini")
st.markdown('</div>', unsafe_allow_html=True)

# Sidebar navigation
st.sidebar.title("Navigation")
page = st.sidebar.radio("Select Page", ["Dashboard", "Text Analysis", "Audio Analysis", "Comparative Analysis", "Cost Calculator", "Documentation"])

# GPT-4o mini pricing constants
TEXT_INPUT_PRICE = 0.60  # $ per 1M tokens
TEXT_OUTPUT_PRICE = 2.40  # $ per 1M tokens
TEXT_CACHED_PRICE = 0.30  # $ per 1M tokens

AUDIO_INPUT_PRICE = 10.00  # $ per 1M tokens
AUDIO_OUTPUT_PRICE = 20.00  # $ per 1M tokens
AUDIO_CACHED_PRICE = 0.30  # $ per 1M tokens

# Helper functions for calculations
def calculate_text_costs(users, msgs_per_user, input_tokens, output_tokens, cached_pct=0):
    # Calculate total token counts
    total_input_tokens = users * msgs_per_user * input_tokens
    total_output_tokens = users * msgs_per_user * output_tokens
    
    # Apply caching
    cached_input_tokens = total_input_tokens * (cached_pct / 100)
    standard_input_tokens = total_input_tokens - cached_input_tokens
    
    # Calculate costs
    input_cost = (standard_input_tokens * TEXT_INPUT_PRICE / 1000000) + (cached_input_tokens * TEXT_CACHED_PRICE / 1000000)
    output_cost = total_output_tokens * TEXT_OUTPUT_PRICE / 1000000
    total_cost = input_cost + output_cost
    
    return {
        'input_tokens': total_input_tokens,
        'output_tokens': total_output_tokens,
        'input_cost': input_cost,
        'output_cost': output_cost,
        'total_cost': total_cost,
        'cost_per_message': total_cost / (users * msgs_per_user) if users * msgs_per_user > 0 else 0
    }

def calculate_audio_costs(users, audio_minutes, tokens_per_sec=600, output_ratio=0.05, cached_pct=0):
    # Calculate token counts
    seconds = audio_minutes * 60
    total_input_tokens = users * seconds * tokens_per_sec
    total_output_tokens = total_input_tokens * output_ratio
    
    # Apply caching
    cached_input_tokens = total_input_tokens * (cached_pct / 100)
    standard_input_tokens = total_input_tokens - cached_input_tokens
    
    # Calculate costs
    input_cost = (standard_input_tokens * AUDIO_INPUT_PRICE / 1000000) + (cached_input_tokens * AUDIO_CACHED_PRICE / 1000000)
    output_cost = total_output_tokens * AUDIO_OUTPUT_PRICE / 1000000
    total_cost = input_cost + output_cost
    
    return {
        'input_tokens': total_input_tokens,
        'output_tokens': total_output_tokens,
        'input_cost': input_cost,
        'output_cost': output_cost,
        'total_cost': total_cost,
        'cost_per_minute': total_cost / audio_minutes if audio_minutes > 0 else 0
    }

# Dashboard page
if page == "Dashboard":
    # Key metrics overview
    st.header("GPT-4o mini Pricing Overview")
    col1, col2, col3 = st.columns(3)
    
    with col1:
        st.markdown('<div class="metric-container">', unsafe_allow_html=True)
        st.markdown('<p class="sub-header">Text Processing</p>', unsafe_allow_html=True)
        st.metric("Input Cost", f"${TEXT_INPUT_PRICE:.2f}/1M tokens")
        st.metric("Output Cost", f"${TEXT_OUTPUT_PRICE:.2f}/1M tokens")
        st.metric("Cached Input", f"${TEXT_CACHED_PRICE:.2f}/1M tokens")
        st.markdown('</div>', unsafe_allow_html=True)
    
    with col2:
        st.markdown('<div class="metric-container">', unsafe_allow_html=True)
        st.markdown('<p class="sub-header">Audio Processing</p>', unsafe_allow_html=True)
        st.metric("Input Cost", f"${AUDIO_INPUT_PRICE:.2f}/1M tokens")
        st.metric("Output Cost", f"${AUDIO_OUTPUT_PRICE:.2f}/1M tokens")
        st.metric("Cached Input", f"${AUDIO_CACHED_PRICE:.2f}/1M tokens")
        st.markdown('</div>', unsafe_allow_html=True)
    
    with col3:
        st.markdown('<div class="metric-container">', unsafe_allow_html=True)
        st.markdown('<p class="sub-header">Average Costs</p>', unsafe_allow_html=True)
        
        # Calculate example costs
        text_example = calculate_text_costs(1, 100, 15, 20)
        audio_example = calculate_audio_costs(1, 10)
        
        st.metric("Avg Text Cost/Message", f"${text_example['cost_per_message']:.6f}")
        st.metric("Avg Audio Cost/Minute", f"${audio_example['cost_per_minute']:.4f}")
        st.metric("Audio/Text Cost Ratio", f"{audio_example['cost_per_minute'] / (text_example['cost_per_message'] * 60):.1f}x")
        st.markdown('</div>', unsafe_allow_html=True)
    
    # Quick comparison chart
    st.subheader("Cost Comparison: Text vs. Audio")
    
    comparison_data = pd.DataFrame({
        'Model Type': ['Text', 'Text', 'Audio', 'Audio'],
        'Cost Component': ['Input', 'Output', 'Input', 'Output'],
        'Cost per 1M Tokens': [TEXT_INPUT_PRICE, TEXT_OUTPUT_PRICE, AUDIO_INPUT_PRICE, AUDIO_OUTPUT_PRICE]
    })
    
    fig = px.bar(comparison_data, x='Model Type', y='Cost per 1M Tokens', color='Cost Component',
                barmode='group', title="Cost Comparison per 1M Tokens",
                color_discrete_sequence=["#3366CC", "#FF9900"])
    fig.update_layout(yaxis_title="Cost ($)")
    st.plotly_chart(fig, use_container_width=True)
    
    # Usage scenarios
    st.subheader("Common Usage Scenarios")
    scenarios = pd.DataFrame({
        'Scenario': ['Customer Support Chat', 'Document Analysis', 'Meeting Transcription', 'Podcast Analysis', 'Phone Call Analysis'],
        'Type': ['Text', 'Text', 'Audio', 'Audio', 'Audio'],
        'Avg Monthly Cost': [10.50, 25.75, 185.00, 740.00, 370.00],
        'Suitable Plan': ['Basic', 'Basic', 'Premium', 'Enterprise', 'Premium']
    })
    
    st.dataframe(scenarios, use_container_width=True)

# Text Model Analysis
elif page == "Text Analysis":
    st.header("GPT-4o mini Text Model Analysis")
    
    st.info(f"""
    **Text Model Pricing**:
    - Input: ${TEXT_INPUT_PRICE:.2f} per 1M tokens
    - Output: ${TEXT_OUTPUT_PRICE:.2f} per 1M tokens
    - Cached Input: ${TEXT_CACHED_PRICE:.2f} per 1M tokens
    """)
    
    # Parameters section with input widgets
    st.subheader("Usage Parameters")
    
    col1, col2 = st.columns(2)
    with col1:
        users = st.number_input("Number of Users", min_value=100, value=5000, step=100)
        free_pct = st.slider("% Free Tier Users", min_value=0, max_value=100, value=80)
        basic_pct = st.slider("% Basic Tier Users (\$12.99)", min_value=0, max_value=100, value=15)
        pro_pct = st.slider("% Pro Tier Users (\$24.99)", min_value=0, max_value=100, value=5)
        
    with col2:
        msgs_per_user_free = st.number_input("Free Tier Messages/Month", min_value=10, value=100, step=10)
        msgs_per_user_basic = st.number_input("Basic Tier Messages/Month", min_value=10, value=300, step=10)
        msgs_per_user_pro = st.number_input("Pro Tier Messages/Month", min_value=10, value=500, step=10)
        input_tokens = st.slider("Input Tokens per Message", min_value=5, max_value=100, value=15)
        output_tokens = st.slider("Output Tokens per Message", min_value=5, max_value=100, value=20)
        cached_pct = st.slider("% Cached Input Tokens", min_value=0, max_value=100, value=0)
    
    # Calculate user distribution
    total_pct = free_pct + basic_pct + pro_pct
    
    if total_pct != 100:
        st.warning(f"Tier percentages sum to {total_pct}%. Please adjust to equal 100%.")
    
    free_users = int(users * free_pct / 100)
    basic_users = int(users * basic_pct / 100)
    pro_users = int(users * pro_pct / 100)
    
    # Token cost calculations
    free_costs = calculate_text_costs(free_users, msgs_per_user_free, input_tokens, output_tokens, cached_pct)
    basic_costs = calculate_text_costs(basic_users, msgs_per_user_basic, input_tokens, output_tokens, cached_pct)
    pro_costs = calculate_text_costs(pro_users, msgs_per_user_pro, input_tokens, output_tokens, cached_pct)
    
    # Calculate revenue
    free_revenue = 0
    basic_revenue = basic_users * 12.99
    pro_revenue = pro_users * 24.99
    total_revenue = free_revenue + basic_revenue + pro_revenue
    total_cost = free_costs['total_cost'] + basic_costs['total_cost'] + pro_costs['total_cost']
    
    # Display metrics
    st.subheader("Cost Analysis")
    
    col1, col2, col3 = st.columns(3)
    
    with col1:
        st.metric("Total Monthly Cost", f"${total_cost:.2f}")
        st.metric("Total Monthly Revenue", f"${total_revenue:.2f}")
    
    with col2:
        profit = total_revenue - total_cost
        margin = (profit / total_revenue * 100) if total_revenue > 0 else 0
        st.metric("Monthly Profit", f"${profit:.2f}")
        st.metric("Profit Margin", f"{margin:.1f}%")
    
    with col3:
        avg_cost_per_user = total_cost / users if users > 0 else 0
        st.metric("Avg. Cost per User", f"${avg_cost_per_user:.4f}")
        st.metric("Total Messages/Month", f"{free_users * msgs_per_user_free + basic_users * msgs_per_user_basic + pro_users * msgs_per_user_pro:,}")
    
    # Create visualizations
    st.subheader("Cost Distribution")
    
    # Cost breakdown by tier
    tier_costs = pd.DataFrame({
        'Tier': ['Free', 'Basic', 'Pro'],
        'Cost': [free_costs['total_cost'], basic_costs['total_cost'], pro_costs['total_cost']],
        'Users': [free_users, basic_users, pro_users]
    })
    
    col1, col2 = st.columns(2)
    
    with col1:
        fig = px.pie(tier_costs, values='Cost', names='Tier', title="Cost Distribution by Tier",
                    color_discrete_sequence=px.colors.qualitative.Plotly)
        st.plotly_chart(fig, use_container_width=True)
    
    with col2:
        # Create revenue vs cost comparison
        comparison_data = pd.DataFrame({
            'Tier': ['Free', 'Basic', 'Pro'],
            'Revenue': [free_revenue, basic_revenue, pro_revenue],
            'Cost': [free_costs['total_cost'], basic_costs['total_cost'], pro_costs['total_cost']]
        })
        
        fig = px.bar(comparison_data, x='Tier', y=['Revenue', 'Cost'], barmode='group',
                    title="Revenue vs Cost by Tier",
                    color_discrete_sequence=["#3366CC", "#FF9900"])
        st.plotly_chart(fig, use_container_width=True)
    
    # Token usage breakdown
    st.subheader("Token Usage Analysis")
    
    token_data = pd.DataFrame({
        'Tier': ['Free', 'Basic', 'Pro'],
        'Input Tokens (M)': [free_costs['input_tokens']/1000000, basic_costs['input_tokens']/1000000, pro_costs['input_tokens']/1000000],
        'Output Tokens (M)': [free_costs['output_tokens']/1000000, basic_costs['output_tokens']/1000000, pro_costs['output_tokens']/1000000]
    })
    
    fig = px.bar(token_data, x='Tier', y=['Input Tokens (M)', 'Output Tokens (M)'], barmode='group',
                title="Monthly Token Usage by Tier (Millions)",
                color_discrete_sequence=["#4CAF50", "#2196F3"])
    st.plotly_chart(fig, use_container_width=True)
    
    # Break-even analysis
    st.subheader("Break-even Analysis")
    
    # Calculate fixed costs (assumed)
    fixed_costs = 2000
    
    # Calculate contribution margin per user type
    cm_basic = 12.99 - (basic_costs['total_cost'] / basic_users if basic_users > 0 else 0)
    cm_pro = 24.99 - (pro_costs['total_cost'] / pro_users if pro_users > 0 else 0)
    
    # Calculate break-even point
    total_cm = (cm_basic * basic_users) + (cm_pro * pro_users)
    break_even_users = int(fixed_costs / (total_cm / (basic_users + pro_users))) if basic_users + pro_users > 0 else 0
    
    col1, col2 = st.columns(2)
    
    with col1:
        st.metric("Fixed Monthly Costs", f"${fixed_costs:.2f}")
        st.metric("Contribution Margin (Basic)", f"${cm_basic:.2f}/user")
        st.metric("Contribution Margin (Pro)", f"${cm_pro:.2f}/user")
    
    with col2:
        st.metric("Break-even Point", f"{break_even_users:,} paid users")
        be_conversion = break_even_users / (users * (basic_pct + pro_pct) / 100) if users * (basic_pct + pro_pct) / 100 > 0 else 0
        st.metric("Required Conversion Rate", f"{be_conversion:.1%}")

# Audio Model Analysis
elif page == "Audio Analysis":
    st.header("GPT-4o mini Audio Model Analysis")
    
    st.info(f"""
    **Audio Model Pricing**:
    - Input: ${AUDIO_INPUT_PRICE:.2f} per 1M tokens
    - Output: ${AUDIO_OUTPUT_PRICE:.2f} per 1M tokens
    - Cached Input: ${AUDIO_CACHED_PRICE:.2f} per 1M tokens
    """)
    
    # Audio model parameters
    st.subheader("Audio Processing Parameters")
    
    col1, col2 = st.columns(2)
    with col1:
        audio_minutes = st.number_input("Average Minutes of Audio/Month/User", min_value=1, value=10, step=1)
        tokens_per_sec = st.number_input("Audio Tokens per Second", min_value=100, value=600, step=10)
        users = st.number_input("Number of Users", min_value=10, value=1000, step=10)
        
    with col2:
        output_tokens_ratio = st.slider("Output:Input Token Ratio", min_value=0.01, max_value=0.20, value=0.05, step=0.01)
        cached_ratio = st.slider("% Input Tokens Cached", min_value=0, max_value=100, value=20)
        pricing_tier = st.selectbox("Pricing Model", ["B2C App (\$12.99/month)", 
                                                     "B2B Service (\$299/month)",
                                                     "Enterprise (\$2500/month)"])
    
    # Calculate costs
    audio_costs = calculate_audio_costs(users, audio_minutes, tokens_per_sec, output_tokens_ratio, cached_ratio)
    
    # Pricing model revenue
    if pricing_tier == "B2C App (\$12.99/month)":
        price_per_user = 12.99
    elif pricing_tier == "B2B Service (\$299/month)":
        price_per_user = 299
    else:  # Enterprise
        price_per_user = 2500
    
    revenue = users * price_per_user
    cost_per_user = audio_costs['total_cost'] / users if users > 0 else 0
    
    profit = revenue - audio_costs['total_cost']
    margin = (profit / revenue) * 100 if revenue > 0 else 0
    
    # Display metrics and charts
    st.subheader("Cost Metrics")
    
    col1, col2, col3 = st.columns(3)
    with col1:
        st.metric("Cost per Minute", f"${(audio_costs['total_cost']/audio_minutes/users):.4f}")
        st.metric("Total Monthly Cost", f"${audio_costs['total_cost']:.2f}")
    with col2:
        st.metric("Monthly Revenue", f"${revenue:.2f}")
        st.metric("Monthly Profit", f"${profit:.2f}")
    with col3:
        st.metric("Profit Margin", f"{margin:.1f}%")
        st.metric("Cost per User", f"${cost_per_user:.2f}")
    
    # Visualization - Cost breakdown
    st.subheader("Cost Breakdown")
    
    # Calculate components
    standard_input_cost = audio_costs['input_tokens'] * (1 - cached_ratio/100) * AUDIO_INPUT_PRICE / 1000000
    cached_input_cost = audio_costs['input_tokens'] * (cached_ratio/100) * AUDIO_CACHED_PRICE / 1000000
    output_cost = audio_costs['output_cost']
    
    cost_components = pd.DataFrame({
        'Component': ['Standard Input Cost', 'Cached Input Cost', 'Output Cost'],
        'Cost': [standard_input_cost, cached_input_cost, output_cost]
    })
    
    col1, col2 = st.columns(2)
    
    with col1:
        fig = px.pie(cost_components, values='Cost', names='Component', title="Audio Processing Cost Distribution",
                    color_discrete_sequence=px.colors.qualitative.Pastel)
        st.plotly_chart(fig, use_container_width=True)
    
    with col2:
        fig = px.bar(cost_components, x='Component', y='Cost', title="Cost Component Comparison",
                    color_discrete_sequence=["#4CAF50", "#2196F3", "#FF9800"])
        st.plotly_chart(fig, use_container_width=True)
    
    # Caching impact analysis
    st.subheader("Impact of Caching on Costs")
    
    cache_options = [0, 20, 40, 60, 80, 100]
    cache_costs = []
    
    for cache_pct in cache_options:
        cache_result = calculate_audio_costs(users, audio_minutes, tokens_per_sec, output_tokens_ratio, cache_pct)
        cache_costs.append(cache_result['total_cost'])
    
    cache_data = pd.DataFrame({
        'Cache Percentage': cache_options,
        'Total Cost': cache_costs,
        'Savings': [audio_costs['total_cost'] - cost for cost in cache_costs],
        'Savings Percentage': [(audio_costs['total_cost'] - cost) / audio_costs['total_cost'] * 100 if audio_costs['total_cost'] > 0 else 0 for cost in cache_costs]
    })
    
    fig = px.line(cache_data, x='Cache Percentage', y='Total Cost', markers=True,
                 title="Effect of Caching on Total Cost",
                 labels={'Cache Percentage': 'Cached Input Tokens (%)', 'Total Cost': 'Total Cost ($)'},
                 color_discrete_sequence=["#FF5722"])
    st.plotly_chart(fig, use_container_width=True)
    
    # Optimization recommendations
    if margin < 50:
        st.warning("Warning: Low profit margin detected. Consider optimization strategies below.")
        
    with st.expander("📈 Cost Optimization Strategies"):
        st.markdown("""
        1. **Increase Caching**: Boost cached input ratio to reduce costs by up to 97%
        2. **Hybrid Processing**: Use specialized audio services for initial transcription
        3. **Input Token Optimization**: Filter silence and implement smart chunking
        4. **Tiered Processing**: Apply different processing depths based on user needs
        """)
        
        # Calculate hybrid model savings
        hybrid_cost = (audio_costs['input_tokens'] * 0.006 / 1000000) + (audio_costs['output_tokens'] * TEXT_OUTPUT_PRICE / 1000000)
        hybrid_savings = audio_costs['total_cost'] - hybrid_cost
        hybrid_savings_pct = (hybrid_savings / audio_costs['total_cost']) * 100 if audio_costs['total_cost'] > 0 else 0
        
        st.info(f"""
        **Hybrid Model Potential Savings**: ${hybrid_savings:.2f} ({hybrid_savings_pct:.1f}%)
        
        By using specialized transcription services (like Whisper) at \$0.006/min and processing the resulting text with GPT-4o mini text pricing.
        """)

# Comparative Analysis
elif page == "Comparative Analysis":
    st.header("Text vs. Audio Comparative Analysis")
    
    # Cost comparison by use case
    st.subheader("Cost Analysis by Use Case")
    
    use_cases = pd.DataFrame({
        'Use Case': ['Customer Service', 'Content Creation', 'Data Analysis', 'Meeting Transcription'],
        'Text Cost ($)': [0.05, 0.12, 0.08, 0.15],
        'Audio Cost ($)': [1.85, 4.20, 2.10, 11.10],
        'Cost Ratio': [37, 35, 26, 74],
        'Recommended Model': ['Text', 'Text', 'Text', 'Hybrid']
    })
    
    st.dataframe(use_cases, use_container_width=True)
    
    # Cost scaling visualization
    st.subheader("Cost Scaling with User Count")
    
    # Toggle for linear/log scale
    scale_type = st.radio("Scale Type", ["Linear", "Logarithmic"], horizontal=True)
    
    # Generate data for comparison
    users_range = [100, 500, 1000, 5000, 10000, 50000, 100000]
    
    text_costs = [users * 0.0001 * 300 for users in users_range]  # 300 msgs avg
    audio_costs = [users * 0.37 * 10 for users in users_range]  # 10 minutes avg
    
    scaling_data = pd.DataFrame({
        'Users': users_range,
        'Text Processing Cost': text_costs,
        'Audio Processing Cost': audio_costs
    })
    
    # Create the chart
    fig = px.line(scaling_data, x='Users', y=['Text Processing Cost', 'Audio Processing Cost'], 
                 markers=True, title="Cost Scaling by User Count",
                 color_discrete_sequence=["#3366CC", "#FF9900"])
    
    if scale_type == "Logarithmic":
        fig.update_layout(yaxis_type="log")
    
    st.plotly_chart(fig, use_container_width=True)
    
    # Break-even analysis
    st.subheader("Break-even Analysis")
    
    col1, col2 = st.columns(2)
    
    with col1:
        monthly_subscription = st.slider("Monthly Subscription ($)", 
                                       min_value=5.0, max_value=50.0, value=12.99, step=0.99)
        text_usage = st.slider("Avg. Messages per User", 
                              min_value=50, max_value=1000, value=300, step=50)
        
    with col2:
        audio_mins = st.slider("Avg. Audio Minutes per User", 
                              min_value=1, max_value=60, value=10, step=1)
        fixed_costs = st.number_input("Monthly Fixed Costs ($)", 
                                    min_value=0, value=2000, step=100)
    
    # Calculate break-even points
    text_cost_per_user = calculate_text_costs(1, text_usage, 15, 20)['total_cost']
    audio_cost_per_user = calculate_audio_costs(1, audio_mins)['total_cost']
    
    text_contribution = monthly_subscription - text_cost_per_user
    audio_contribution = monthly_subscription - audio_cost_per_user
    
    text_break_even = fixed_costs / text_contribution if text_contribution > 0 else float('inf')
    audio_break_even = fixed_costs / audio_contribution if audio_contribution > 0 else float('inf')
    
    # Display break-even metrics
    col1, col2 = st.columns(2)
    with col1:
        st.metric("Text Break-even Users", f"{int(text_break_even)}")
        st.metric("Text Margin per User", 
                 f"${text_contribution:.2f} ({text_contribution/monthly_subscription*100:.1f}%)")
        
    with col2:
        st.metric("Audio Break-even Users", f"{int(audio_break_even)}")
        st.metric("Audio Margin per User", 
                 f"${audio_contribution:.2f} ({audio_contribution/monthly_subscription*100:.1f}%)")
    
    # Create a combined visualization
    st.subheader("Profit Analysis")
    
    user_counts = list(range(0, 10001, 500))
    text_profits = [(monthly_subscription - text_cost_per_user) * users - fixed_costs for users in user_counts]
    audio_profits = [(monthly_subscription - audio_cost_per_user) * users - fixed_costs for users in user_counts]
    
    profit_data = pd.DataFrame({
        'Users': user_counts,
        'Text Profit': text_profits,
        'Audio Profit': audio_profits
    })
    
    fig = px.line(profit_data, x='Users', y=['Text Profit', 'Audio Profit'],
                 title="Profit by User Count",
                 labels={'value': 'Profit ($)', 'Users': 'Number of Users'},
                 color_discrete_sequence=["#3366CC", "#FF9900"])
    
    fig.add_hline(y=0, line_dash="dash", line_color="red")
    st.plotly_chart(fig, use_container_width=True)
    
    # Business model recommendations
    st.subheader("Business Model Recommendations")
    
    if audio_cost_per_user > monthly_subscription:
        st.warning(f"""
        ⚠️ Audio processing costs (${audio_cost_per_user:.2f}/user) exceed subscription price (${monthly_subscription:.2f}).
        Consider increasing subscription price or implementing usage limits for audio features.
        """)
        
    recommended_model = "Text-Only" if text_contribution > audio_contribution else "Hybrid"
    
    st.success(f"""
    ✅ Recommended Business Model: **{recommended_model}**
    
    Based on your inputs, a {'text-focused approach' if recommended_model == 'Text-Only' else 'hybrid approach with limited audio processing'} 
    would maximize profitability while maintaining competitive pricing.
    """)

# Cost Calculator
elif page == "Cost Calculator":
    st.header("Interactive Cost Calculator")
    
    # Choose model type
    model_type = st.selectbox("Select Model Type", ["Text", "Audio", "Hybrid"])
    
    if model_type == "Text":
        st.subheader("GPT-4o mini Text Model Calculator")
        
        # Input parameters
        col1, col2 = st.columns(2)
        with col1:
            total_users = st.number_input("Total Users", min_value=1, value=1000, step=100)
            msgs_per_user = st.number_input("Monthly Messages per User", min_value=1, value=300, step=10)
            input_tokens = st.number_input("Avg. Input Tokens per Message", min_value=1, value=15, step=1)
            output_tokens = st.number_input("Avg. Output Tokens per Message", min_value=1, value=20, step=1)
        
        with col2:
            subscription_price = st.number_input("Monthly Subscription Price ($)", 
                                              min_value=0.0, value=12.99, step=0.99)
            free_tier_ratio = st.slider("Free:Paid User Ratio", 
                                      min_value=0.0, max_value=20.0, value=9.0, step=0.1)
            cached_pct = st.slider("% Cached Input", 
                                 min_value=0, max_value=100, value=0, step=5)
        
        # Calculate values
        free_users = int(total_users * (free_tier_ratio / (free_tier_ratio + 1)))
        paid_users = total_users - free_users
        
        # Free tier calculations
        free_msgs_limit = 100  # Free tier message limit
        free_total_msgs = free_users * min(msgs_per_user, free_msgs_limit)
        
        # Token calculations
        free_costs = calculate_text_costs(free_users, min(msgs_per_user, free_msgs_limit), input_tokens, output_tokens, cached_pct)
        paid_costs = calculate_text_costs(paid_users, msgs_per_user, input_tokens, output_tokens, cached_pct)
        
        total_cost = free_costs['total_cost'] + paid_costs['total_cost']
        
        # Calculate revenue and profit
        revenue = paid_users * subscription_price
        profit = revenue - total_cost
        margin = (profit / revenue) * 100 if revenue > 0 else 0
        
        # Display results
        st.subheader("Results")
        
        col1, col2, col3, col4 = st.columns(4)
        with col1:
            st.metric("Total Cost", f"${total_cost:.2f}")
        with col2:
            st.metric("Revenue", f"${revenue:.2f}")
        with col3:
            st.metric("Monthly Profit", f"${profit:.2f}")
        with col4:
            st.metric("Profit Margin", f"{margin:.1f}%")
        
        # Detailed breakdown
        with st.expander("See Detailed Cost Breakdown"):
            st.markdown(f"""
            ### User Distribution
            - Total Users: {total_users:,}
            - Free Tier Users: {free_users:,} ({free_users/total_users*100:.1f}%)
            - Paid Tier Users: {paid_users:,} ({paid_users/total_users*100:.1f}%)
            
            ### Token Usage
            - Total Input Tokens: {free_costs['input_tokens'] + paid_costs['input_tokens']:,.0f}
            - Total Output Tokens: {free_costs['output_tokens'] + paid_costs['output_tokens']:,.0f}
            
            ### Token Cost Breakdown
            - Input Cost: ${free_costs['input_cost'] + paid_costs['input_cost']:.2f}
            - Output Cost: ${free_costs['output_cost'] + paid_costs['output_cost']:.2f}
            
            ### Per User Economics
            - Cost per Paid User: ${total_cost/paid_users:.4f} (if all costs allocated to paid users)
            - Revenue per Paid User: ${subscription_price:.2f}
            - Profit per Paid User: ${(revenue-total_cost)/paid_users:.2f}
            """)
        
        # Visualization
        st.subheader("Cost vs Revenue")
        
        fig = go.Figure()
        fig.add_trace(go.Bar(
            name='Free Tier Cost',
            x=['Cost'],
            y=[free_costs['total_cost']],
            marker_color='#FF9900'
        ))
        fig.add_trace(go.Bar(
            name='Paid Tier Cost',
            x=['Cost'],
            y=[paid_costs['total_cost']],
            marker_color='#FF5733'
        ))
        fig.add_trace(go.Bar(
            name='Revenue',
            x=['Revenue'],
            y=[revenue],
            marker_color='#3366CC'
        ))
        
        fig.update_layout(barmode='stack', title="Cost vs Revenue Breakdown")
        st.plotly_chart(fig, use_container_width=True)
    
    elif model_type == "Audio":
        st.subheader("GPT-4o mini Audio Model Calculator")
        
        # Input parameters
        col1, col2 = st.columns(2)
        with col1:
            users = st.number_input("Number of Users", min_value=1, value=100, step=10)
            audio_minutes = st.number_input("Minutes of Audio per User per Month", min_value=1, value=10, step=1)
            tokens_per_second = st.number_input("Audio Tokens per Second", min_value=100, value=600, step=10)
            cached_pct = st.slider("% Cached Input", min_value=0, max_value=100, value=20, step=5)
        
        with col2:
            output_ratio = st.slider("Output:Input Token Ratio", min_value=0.01, max_value=0.2, value=0.05, step=0.01)
            subscription = st.number_input("Monthly Subscription ($)", min_value=0.0, value=29.99, step=0.99)
            silence_reduction = st.slider("Silence Reduction %", min_value=0, max_value=50, value=20, step=5)
            
        # Apply silence reduction to effective minutes
        effective_minutes = audio_minutes * (1 - silence_reduction/100)
        
        # Calculate costs
        costs = calculate_audio_costs(users, effective_minutes, tokens_per_second, output_ratio, cached_pct)
        
        # Calculate revenue and profit
        revenue = users * subscription
        profit = revenue - costs['total_cost']
        margin = (profit / revenue) * 100 if revenue > 0 else 0
        
        # Display results
        st.subheader("Results")
        
        col1, col2 = st.columns(2)
        with col1:
            st.metric("Cost per Audio Minute", f"${costs['cost_per_minute']:.4f}")
            st.metric("Total Monthly Cost", f"${costs['total_cost']:.2f}")
            st.metric("Cost per User", f"${costs['total_cost']/users:.2f}")
        
        with col2:
            st.metric("Monthly Revenue", f"${revenue:.2f}")
            st.metric("Monthly Profit", f"${profit:.2f}")
            st.metric("Profit Margin", f"{margin:.1f}%")