app.py

"""
Strategic Sandbox v1.0
Interactive strategy simulation and evaluation tool
"""

import streamlit as st
import json
import os
from pathlib import Path
import pandas as pd
import plotly.graph_objects as go
import plotly.express as px
import networkx as nx
import matplotlib.pyplot as plt
from openai import OpenAI
from datetime import datetime

from strategy_core import (
    Strategy, Goal, Arena, Insight, Hypothesis, Move, Metric,
    SimulationEngine
)


# Page configuration
st.set_page_config(
    page_title="Strategic Sandbox",
    page_icon="🎯",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS for Heuristica aesthetic
st.markdown("""
<style>
    .main-header {
        font-size: 2.5rem;
        font-weight: 600;
        color: #1e90ff;
        margin-bottom: 0.5rem;
    }
    .sub-header {
        font-size: 1.2rem;
        color: #666;
        margin-bottom: 2rem;
    }
    .metric-card {
        background-color: #f0f8ff;
        padding: 1rem;
        border-radius: 8px;
        border-left: 4px solid #1e90ff;
    }
    .stButton>button {
        background-color: #1e90ff;
        color: white;
        border-radius: 6px;
        border: none;
        padding: 0.5rem 1.5rem;
        font-weight: 500;
    }
    .stButton>button:hover {
        background-color: #187bcd;
    }
</style>
""", unsafe_allow_html=True)


# Initialize session state
def init_session_state():
    """Initialize all session state variables"""
    if 'strategy' not in st.session_state:
        st.session_state.strategy = Strategy()
    if 'simulation_results' not in st.session_state:
        st.session_state.simulation_results = None
    if 'ai_feedback' not in st.session_state:
        st.session_state.ai_feedback = None
    if 'openai_api_key' not in st.session_state:
        st.session_state.openai_api_key = ""
    if 'current_page' not in st.session_state:
        st.session_state.current_page = "Dashboard"


def save_api_key():
    """Save API key to local file for persistence"""
    key_file = Path("data/.api_key")
    key_file.parent.mkdir(exist_ok=True)
    with open(key_file, 'w') as f:
        f.write(st.session_state.openai_api_key)


def load_api_key():
    """Load API key from local file"""
    key_file = Path("data/.api_key")
    if key_file.exists():
        with open(key_file, 'r') as f:
            return f.read().strip()
    return ""


def render_sidebar():
    """Render sidebar with navigation and API key input"""
    with st.sidebar:
        st.markdown('<div class="main-header">🎯 Strategic Sandbox</div>', unsafe_allow_html=True)
        st.markdown("**v1.0** - Strategy Simulation Tool")
        st.markdown("---")

        # API Key input
        st.subheader("OpenAI Configuration")

        # Load saved key if available
        if not st.session_state.openai_api_key:
            st.session_state.openai_api_key = load_api_key()

        api_key = st.text_input(
            "API Key",
            value=st.session_state.openai_api_key,
            type="password",
            help="Your OpenAI API key will be saved locally"
        )

        if api_key != st.session_state.openai_api_key:
            st.session_state.openai_api_key = api_key
            save_api_key()
            if api_key:
                st.success("API Key saved!")

        st.markdown("---")

        # Navigation
        st.subheader("Navigation")
        pages = ["Dashboard", "Strategy Builder", "Simulation", "AI Evaluator", "Report"]

        for page in pages:
            if st.button(page, key=f"nav_{page}", use_container_width=True):
                st.session_state.current_page = page
                st.rerun()

        st.markdown("---")

        # Quick actions
        st.subheader("Quick Actions")

        col1, col2 = st.columns(2)
        with col1:
            if st.button("📁 Load Example", use_container_width=True):
                load_example_strategy()
                st.success("Example loaded!")
                st.rerun()

        with col2:
            if st.button("🔄 Reset", use_container_width=True):
                st.session_state.strategy = Strategy()
                st.session_state.simulation_results = None
                st.session_state.ai_feedback = None
                st.success("Strategy reset!")
                st.rerun()


def load_example_strategy():
    """Load example strategy from JSON"""
    example_path = Path("data/example.json")
    if example_path.exists():
        st.session_state.strategy = Strategy.from_json(str(example_path))


def render_dashboard():
    """Render dashboard page"""
    st.markdown('<div class="main-header">Dashboard</div>', unsafe_allow_html=True)
    st.markdown('<div class="sub-header">Strategic overview and quick start</div>', unsafe_allow_html=True)

    # Quick stats
    col1, col2, col3, col4 = st.columns(4)

    strategy = st.session_state.strategy

    with col1:
        st.metric("Insights", len(strategy.insights))
    with col2:
        st.metric("Hypotheses", len(strategy.hypotheses))
    with col3:
        st.metric("Moves", len(strategy.moves))
    with col4:
        st.metric("Metrics", len(strategy.metrics))

    st.markdown("---")

    # Strategy overview
    if strategy.goal:
        st.subheader("Current Goal")
        st.info(f"**{strategy.goal.text}**\n\nTarget: {strategy.goal.target}{strategy.metrics[0].unit if strategy.metrics else ''} by {strategy.goal.horizon}")
    else:
        st.warning("No strategy defined yet. Go to **Strategy Builder** to start.")

    # Recent simulation results
    if st.session_state.simulation_results:
        st.subheader("Latest Simulation Results")
        results = st.session_state.simulation_results

        col1, col2 = st.columns(2)
        with col1:
            st.metric("Total Impact Score", f"{results['total_impact']:.4f}")
        with col2:
            if results['move_scores']:
                top_move = results['move_scores'][0]
                st.metric("Top Move", top_move['text'], f"Score: {top_move['score']:.4f}")

    # Quick start guide
    st.markdown("---")
    st.subheader("Quick Start Guide")

    st.markdown("""
    1. **Strategy Builder**: Define your goal, insights, hypotheses, and moves
    2. **Simulation**: Run scoring simulation to evaluate moves
    3. **AI Evaluator**: Get AI feedback on strategy coherence
    4. **Report**: Generate and export your strategy report
    """)


def render_strategy_builder():
    """Render strategy builder page with forms"""
    st.markdown('<div class="main-header">Strategy Builder</div>', unsafe_allow_html=True)
    st.markdown('<div class="sub-header">Define your strategy components</div>', unsafe_allow_html=True)

    strategy = st.session_state.strategy

    # Create tabs for different sections
    tab1, tab2, tab3, tab4, tab5 = st.tabs([
        "🎯 Goal & Arena",
        "💡 Insights",
        "🔬 Hypotheses",
        "🎬 Moves",
        "📊 Supporting Metrics"
    ])

    with tab1:
        render_goal_arena_form(strategy)

    with tab2:
        render_insights_form(strategy)

    with tab3:
        render_hypotheses_form(strategy)

    with tab4:
        render_moves_form(strategy)

    with tab5:
        render_metrics_form(strategy)

    # Save/Export buttons
    st.markdown("---")
    col1, col2, col3 = st.columns([1, 1, 2])

    with col1:
        if st.button("💾 Save Strategy", use_container_width=True):
            save_strategy()

    with col2:
        if st.button("📥 Export JSON", use_container_width=True):
            export_strategy_json()


def render_goal_arena_form(strategy):
    """Render goal and arena input form"""
    st.subheader("Goal Definition")

    col1, col2 = st.columns(2)

    with col1:
        goal_text = st.text_area(
            "Goal Statement",
            value=strategy.goal.text if strategy.goal else "",
            help="What do you want to achieve?"
        )

        metric_id = st.text_input(
            "Metric ID",
            value=strategy.goal.metric if strategy.goal else "",
            help="e.g., share_premium, CR_online"
        )

        horizon = st.text_input(
            "Time Horizon",
            value=strategy.goal.horizon if strategy.goal else "2026",
            help="When do you want to achieve this?"
        )

    with col2:
        baseline = st.number_input(
            "Baseline Value",
            value=float(strategy.goal.baseline) if strategy.goal else 0.0,
            help="Current value"
        )

        target = st.number_input(
            "Target Value",
            value=float(strategy.goal.target) if strategy.goal else 0.0,
            help="Desired value"
        )

        unit = st.text_input(
            "Unit",
            value=strategy.goal.unit if strategy.goal else "%",
            help="Unit of measurement (e.g., %, pts, PLN)"
        )

    if st.button("Save Goal"):
        strategy.goal = Goal(
            text=goal_text,
            metric=metric_id,
            baseline=baseline,
            target=target,
            horizon=horizon,
            unit=unit
        )
        st.success("Goal saved!")

    st.markdown("---")
    st.subheader("Arena Definition")

    col1, col2 = st.columns(2)

    with col1:
        market = st.text_input(
            "Market",
            value=strategy.arena.market if strategy.arena else "",
            help="e.g., PL, EU, US"
        )

        category = st.text_input(
            "Category",
            value=strategy.arena.category if strategy.arena else "",
            help="e.g., pasta_premium, skincare"
        )

        target_audience = st.text_area(
            "Target Audience",
            value=strategy.arena.target_audience if strategy.arena else "",
            help="Describe your target audience (demographics, psychographics, behaviors)"
        )

    with col2:
        competitors_text = st.text_area(
            "Competitors (one per line)",
            value="\n".join(strategy.arena.competitors) if strategy.arena else "",
            help="List your main competitors"
        )

    if st.button("Save Arena"):
        competitors = [c.strip() for c in competitors_text.split("\n") if c.strip()]
        strategy.arena = Arena(
            market=market,
            category=category,
            competitors=competitors,
            target_audience=target_audience
        )
        st.success("Arena saved!")


def render_insights_form(strategy):
    """Render insights input form"""
    st.subheader("Add Insight")

    col1, col2 = st.columns([2, 1])

    with col1:
        insight_id = st.text_input("Insight ID", help="e.g., i1, i2")
        insight_text = st.text_area("Insight Statement", help="What did you learn?")

    with col2:
        evidence_text = st.text_area("Evidence Sources (one per line)", help="e.g., FGI_2024, Survey_Q1")

    if st.button("Add Insight"):
        if insight_id and insight_text:
            evidence = [e.strip() for e in evidence_text.split("\n") if e.strip()]
            strategy.insights.append(Insight(
                id=insight_id,
                text=insight_text,
                evidence=evidence
            ))
            st.success(f"Insight {insight_id} added!")
            st.rerun()

    # Display existing insights
    if strategy.insights:
        st.markdown("---")
        st.subheader("Current Insights")
        for i, insight in enumerate(strategy.insights):
            with st.expander(f"{insight.id}: {insight.text[:50]}..."):
                st.write(f"**Full text:** {insight.text}")
                st.write(f"**Evidence:** {', '.join(insight.evidence)}")
                if st.button(f"Remove {insight.id}", key=f"remove_insight_{i}"):
                    strategy.insights.pop(i)
                    st.rerun()


def render_hypotheses_form(strategy):
    """Render hypotheses input form"""
    st.subheader("Add Hypothesis")

    col1, col2 = st.columns([2, 1])

    with col1:
        hyp_id = st.text_input("Hypothesis ID", help="e.g., h1, h2")
        hyp_text = st.text_area("Hypothesis Statement", help="What do you believe will happen?")

        # Insight selector
        insight_ids = [i.id for i in strategy.insights]
        based_on = st.multiselect("Based on Insights", insight_ids)

    with col2:
        metric_id = st.text_input("Target Metric ID", help="Which metric will this affect?")
        expected_change = st.number_input("Expected Change", value=0.0, step=0.01, help="Expected change (e.g., 0.2 for +20%)")

    if st.button("Add Hypothesis"):
        if hyp_id and hyp_text:
            strategy.hypotheses.append(Hypothesis(
                id=hyp_id,
                text=hyp_text,
                based_on=based_on,
                metric=metric_id,
                expected_change=expected_change
            ))
            st.success(f"Hypothesis {hyp_id} added!")
            st.rerun()

    # Display existing hypotheses
    if strategy.hypotheses:
        st.markdown("---")
        st.subheader("Current Hypotheses")
        for i, hyp in enumerate(strategy.hypotheses):
            with st.expander(f"{hyp.id}: {hyp.text[:50]}..."):
                st.write(f"**Full text:** {hyp.text}")
                st.write(f"**Based on:** {', '.join(hyp.based_on)}")
                st.write(f"**Metric:** {hyp.metric} | **Expected change:** {hyp.expected_change}")
                if st.button(f"Remove {hyp.id}", key=f"remove_hyp_{i}"):
                    strategy.hypotheses.pop(i)
                    st.rerun()


def render_moves_form(strategy):
    """Render moves input form"""
    st.subheader("Add Move")

    col1, col2 = st.columns([2, 1])

    with col1:
        move_id = st.text_input("Move ID", help="e.g., m1, m2")
        move_text = st.text_area("Move Description", help="What action will you take?")

        # Hypothesis selector
        hyp_ids = [h.id for h in strategy.hypotheses]
        linked_hyp = st.selectbox("Linked Hypothesis", [""] + hyp_ids)

    with col2:
        impact = st.slider("Impact", 0.0, 1.0, 0.5, 0.05, help="Expected impact (0-1)")
        fit = st.slider("Fit", 0.0, 1.0, 0.8, 0.05, help="Fit with strategy (0-1)")
        risk = st.slider("Risk", 0.0, 1.0, 0.3, 0.05, help="Risk level (0-1)")
        cost = st.number_input("Cost", value=100000.0, step=10000.0, help="Cost in currency")

    if st.button("Add Move"):
        if move_id and move_text and linked_hyp:
            strategy.moves.append(Move(
                id=move_id,
                text=move_text,
                linked_hypothesis=linked_hyp,
                impact=impact,
                fit=fit,
                risk=risk,
                cost=cost
            ))
            st.success(f"Move {move_id} added!")
            st.rerun()

    # Display existing moves
    if strategy.moves:
        st.markdown("---")
        st.subheader("Current Moves")
        for i, move in enumerate(strategy.moves):
            with st.expander(f"{move.id}: {move.text[:50]}..."):
                st.write(f"**Full text:** {move.text}")
                st.write(f"**Linked hypothesis:** {move.linked_hypothesis}")
                col1, col2, col3, col4 = st.columns(4)
                col1.metric("Impact", f"{move.impact:.2f}")
                col2.metric("Fit", f"{move.fit:.2f}")
                col3.metric("Risk", f"{move.risk:.2f}")
                col4.metric("Cost", f"{move.cost:,.0f}")
                if st.button(f"Remove {move.id}", key=f"remove_move_{i}"):
                    strategy.moves.pop(i)
                    st.rerun()


def render_metrics_form(strategy):
    """Render metrics input form"""
    st.subheader("Add Supporting Metric")
    st.info("💡 Main goal metric is defined in Goal & Arena tab. Here you add supporting/leading indicator metrics that help track progress.")

    col1, col2 = st.columns([2, 1])

    with col1:
        metric_id = st.text_input("Metric ID", help="e.g., CR_online, consideration")
        metric_text = st.text_input("Metric Name", help="Full name of the metric")

    with col2:
        baseline = st.number_input("Baseline", value=0.0, help="Current value")
        target = st.number_input("Target", value=0.0, help="Target value")
        unit = st.text_input("Unit", value="%", help="Unit of measurement")

    if st.button("Add Metric"):
        if metric_id and metric_text:
            strategy.metrics.append(Metric(
                id=metric_id,
                text=metric_text,
                baseline=baseline,
                target=target,
                unit=unit
            ))
            st.success(f"Metric {metric_id} added!")
            st.rerun()

    # Display existing metrics
    if strategy.metrics:
        st.markdown("---")
        st.subheader("Current Metrics")
        for i, metric in enumerate(strategy.metrics):
            with st.expander(f"{metric.id}: {metric.text}"):
                col1, col2, col3 = st.columns(3)
                col1.metric("Baseline", f"{metric.baseline}{metric.unit}")
                col2.metric("Target", f"{metric.target}{metric.unit}")
                col3.metric("Gap", f"{metric.target - metric.baseline}{metric.unit}")
                if st.button(f"Remove {metric.id}", key=f"remove_metric_{i}"):
                    strategy.metrics.pop(i)
                    st.rerun()


def render_simulation():
    """Render simulation page"""
    st.markdown('<div class="main-header">Simulation</div>', unsafe_allow_html=True)
    st.markdown('<div class="sub-header">Run strategy simulation and view results</div>', unsafe_allow_html=True)

    strategy = st.session_state.strategy

    # Check if strategy is ready
    if not strategy.moves:
        st.warning("No moves defined. Go to Strategy Builder to add moves.")
        return

    # Run simulation button
    if st.button("▶️ Run Simulation", use_container_width=True):
        with st.spinner("Running simulation..."):
            results = SimulationEngine.simulate_strategy(strategy)
            st.session_state.simulation_results = results
        st.success("Simulation complete!")

    # Display results
    if st.session_state.simulation_results:
        results = st.session_state.simulation_results

        # Overall metrics
        st.subheader("Overall Results")
        col1, col2, col3 = st.columns(3)

        with col1:
            st.metric("Total Impact Score", f"{results['total_impact']:.4f}")
        with col2:
            st.metric("Number of Moves", len(results['move_scores']))
        with col3:
            avg_risk = sum(m['risk'] for m in results['move_scores']) / len(results['move_scores'])
            st.metric("Average Risk", f"{avg_risk:.2f}")

        # Moves ranking
        st.markdown("---")
        st.subheader("Moves Ranking")

        df = SimulationEngine.create_results_dataframe(results)
        st.dataframe(df, use_container_width=True)

        # Visualizations
        col1, col2 = st.columns(2)

        with col1:
            # Bar chart - scores
            fig_scores = go.Figure()
            fig_scores.add_trace(go.Bar(
                x=[m['id'] for m in results['move_scores']],
                y=[m['score'] for m in results['move_scores']],
                marker_color='#1e90ff',
                text=[f"{m['score']:.4f}" for m in results['move_scores']],
                textposition='auto'
            ))
            fig_scores.update_layout(
                title="Move Scores Ranking",
                xaxis_title="Move ID",
                yaxis_title="Score",
                height=400
            )
            st.plotly_chart(fig_scores, use_container_width=True)

        with col2:
            # Scatter plot - risk vs impact
            fig_scatter = go.Figure()

            for move in results['move_scores']:
                fig_scatter.add_trace(go.Scatter(
                    x=[move['risk']],
                    y=[move['impact']],
                    mode='markers+text',
                    name=move['id'],
                    text=[move['id']],
                    textposition="top center",
                    marker=dict(
                        size=move['score'] * 100,
                        color=move['fit'],
                        colorscale='Blues',
                        showscale=True,
                        colorbar=dict(
                            title=dict(
                                text="Fit",
                                font=dict(size=14, color='white'),
                                side='right'
                            ),
                            showticklabels=False,
                            thickness=15,
                            len=0.7
                        )
                    )
                ))

            fig_scatter.update_layout(
                title={
                    'text': "Risk vs Impact Analysis<br><sub>Bubble size = Score | Color intensity = Fit</sub>",
                    'x': 0.5,
                    'xanchor': 'center'
                },
                xaxis_title="Risk →",
                yaxis_title="Impact →",
                height=400,
                showlegend=False
            )
            st.plotly_chart(fig_scatter, use_container_width=True)
            st.caption("💡 Larger bubbles = higher score | Darker blue = better fit with strategy")

        # Metric forecasts
        if results['metric_forecasts']:
            st.markdown("---")
            st.subheader("Metric Forecasts")

            for forecast in results['metric_forecasts']:
                # Highlight main goal metric
                icon = "🎯" if forecast.get('is_main') else "📊"
                title_prefix = "MAIN GOAL: " if forecast.get('is_main') else ""

                with st.expander(f"{icon} {title_prefix}{forecast['text']}", expanded=True):
                    # Metric summary in columns
                    col1, col2, col3 = st.columns(3)

                    with col1:
                        st.markdown(f"**Baseline:** {forecast['baseline']}{forecast['unit']}")
                    with col2:
                        st.markdown(f"**Forecast:** <span style='color: #1e90ff; font-weight: bold;'>{forecast['forecast']}{forecast['unit']}</span>", unsafe_allow_html=True)
                    with col3:
                        gap_color = 'red' if forecast['gap_to_target'] > 0 else 'green'
                        st.markdown(f"**Gap to Target:** <span style='color: {gap_color}; font-weight: bold;'>{forecast['gap_to_target']:+.2f}{forecast['unit']}</span>", unsafe_allow_html=True)

                    st.markdown("")  # spacing

                    # Show linked hypotheses
                    if forecast.get('linked_hypotheses'):
                        st.markdown(f"**Linked Hypotheses:** {', '.join(forecast['linked_hypotheses'])}")

                    # Show contributing moves breakdown
                    if forecast.get('linked_moves'):
                        st.markdown("**Contributing Moves:**")
                        if len(forecast['linked_moves']) == 0:
                            st.info("⚠️ No moves linked to this metric")
                        else:
                            for move in forecast['linked_moves']:
                                contribution = move['score'] * forecast['baseline']
                                st.markdown(f"- **{move['id']}**: {move['text'][:60]}... (score: {move['score']:.4f}, contribution: +{contribution:.2f}{forecast['unit']})")
                    else:
                        st.info("⚠️ No moves linked to this metric")

        # Recommendations
        if results['recommendations']:
            st.markdown("---")
            st.subheader("Recommendations")
            for rec in results['recommendations']:
                st.info(rec)

        # Strategy graph visualization
        st.markdown("---")
        st.subheader("Strategy Logic Flow")
        render_strategy_graph(strategy)


def render_strategy_graph(strategy):
    """Render NetworkX graph of strategy logic"""
    G = nx.DiGraph()

    # Add nodes
    for insight in strategy.insights:
        G.add_node(insight.id, type='insight', label=insight.text[:30])

    for hyp in strategy.hypotheses:
        G.add_node(hyp.id, type='hypothesis', label=hyp.text[:30])

    for move in strategy.moves:
        G.add_node(move.id, type='move', label=move.text[:30])

    for metric in strategy.metrics:
        G.add_node(metric.id, type='metric', label=metric.text[:30])

    # Add edges
    for hyp in strategy.hypotheses:
        for insight_id in hyp.based_on:
            if G.has_node(insight_id):
                G.add_edge(insight_id, hyp.id)
        if G.has_node(hyp.metric):
            G.add_edge(hyp.id, hyp.metric)

    for move in strategy.moves:
        if G.has_node(move.linked_hypothesis):
            G.add_edge(move.linked_hypothesis, move.id)

    # Draw graph
    fig, ax = plt.subplots(figsize=(12, 8))
    pos = nx.spring_layout(G, k=2, iterations=50, seed=42)

    # Color nodes by type
    node_colors = []
    for node in G.nodes():
        node_type = G.nodes[node].get('type', '')
        if node_type == 'insight':
            node_colors.append('#90EE90')
        elif node_type == 'hypothesis':
            node_colors.append('#FFD700')
        elif node_type == 'move':
            node_colors.append('#1e90ff')
        elif node_type == 'metric':
            node_colors.append('#FF6B6B')
        else:
            node_colors.append('#CCCCCC')

    nx.draw(G, pos, ax=ax, node_color=node_colors, node_size=2000,
            with_labels=True, font_size=8, font_weight='bold',
            arrows=True, arrowsize=20, edge_color='#999999', width=2)

    ax.set_title("Strategy Logic Flow\n(Green=Insight, Yellow=Hypothesis, Blue=Move, Red=Metric)",
                 fontsize=12, fontweight='bold')

    st.pyplot(fig, clear_figure=True)


def render_ai_evaluator():
    """Render AI evaluator page"""
    st.markdown('<div class="main-header">AI Evaluator</div>', unsafe_allow_html=True)
    st.markdown('<div class="sub-header">Get brutally honest AI audit of your strategy</div>', unsafe_allow_html=True)

    strategy = st.session_state.strategy

    # Check API key
    if not st.session_state.openai_api_key:
        st.warning("Please configure your OpenAI API key in the sidebar.")
        return

    # Check if strategy is ready
    if not strategy.goal or not strategy.moves:
        st.warning("Strategy is incomplete. Please define at least a goal and some moves.")
        return

    # Display current strategy summary
    st.subheader("Strategy Summary")
    st.write(f"**Goal:** {strategy.goal.text}")
    st.write(f"**Insights:** {len(strategy.insights)}")
    st.write(f"**Hypotheses:** {len(strategy.hypotheses)}")
    st.write(f"**Moves:** {len(strategy.moves)}")

    st.markdown("---")

    # Ask AI button
    st.info("⚠️ This AI audit will be brutally honest - expect specific criticism, red flags, and concrete fixes (not polite suggestions).")
    if st.button("🤖 Run Strategy Audit", use_container_width=True):
        with st.spinner("AI is auditing your strategy..."):
            feedback = get_ai_evaluation(strategy)
            st.session_state.ai_feedback = feedback
        st.rerun()

    # Display AI feedback
    if st.session_state.ai_feedback:
        st.markdown("---")
        st.subheader("🔍 Strategy Audit Report")
        st.markdown(st.session_state.ai_feedback)


def get_ai_evaluation(strategy: Strategy) -> str:
    """Call OpenAI API to evaluate strategy"""
    try:
        client = OpenAI(api_key=st.session_state.openai_api_key)

        # Prepare strategy data
        strategy_json = json.dumps(strategy.to_dict(), indent=2, ensure_ascii=False)

        # Create prompt
        prompt = f"""You are a ruthlessly analytical strategy evaluator. Your job is to find weaknesses, gaps, and risks - not to be polite.

IMPORTANT: Detect the language of the strategy below and respond in THE SAME LANGUAGE.
If the strategy is in Polish, respond in Polish. If in English, respond in English.

Analyze this strategy with BRUTAL honesty:

Strategy:
```json
{strategy_json}
```

Your evaluation MUST include:

## 1. LOGICAL FLOW AUDIT (Score: X/10)
- Map exact connections: Which insights feed which hypotheses? Which hypotheses feed which moves?
- RED FLAGS: List any broken links (e.g., "Move m3 links to h2, but h2 doesn't target the main goal metric")
- ORPHANS: Are there insights/hypotheses not connected to any moves? List them by ID.

## 2. HYPOTHESIS QUALITY CHECK
For EACH hypothesis (h1, h2, h3, h4...):
- Is expected_change realistic? (Compare to industry benchmarks if known)
- Is the metric actually measurable? How would you track it?
- RED FLAG if hypothesis is vague or unmeasurable

## 3. MOVE PORTFOLIO ANALYSIS
- Cost concentration: What % of budget goes to top move? (Flag if >40%)
- Risk profile: How many high-risk moves (risk >0.6)?
- MISSING MOVES: What obvious actions are NOT here? (e.g., "No paid search strategy despite digital focus")
- Prioritization: Using score formula, which moves should be CUT? Be specific with IDs.

## 4. GAP ANALYSIS - What's MISSING?
- Competitive response: How will competitors react? No moves addressing this?
- Measurement plan: How will you track these metrics in reality?
- Budget realism: Total cost vs. expected revenue/impact - does math work?
- Timeline: Are moves sequenced or all at once? Flag if unclear.

## 5. TOP 3 FATAL FLAWS
List the 3 biggest risks that could KILL this strategy. Be specific:
- "Move m6 costs 150k but has lowest score (X.XX) - CUT IT"
- "No B2B distribution strategy despite targeting gyms/studios"
- "Hypothesis h2 assumes 30% trial rate but category average is 8%"

## 6. ACTIONABLE FIXES (Prioritized)
🔴 CRITICAL (do NOW):
- Specific change with exact ID reference (e.g., "Change h3 expected_change from 0.45 to 0.25")

🟡 IMPORTANT (before launch):
- Concrete additions (e.g., "Add move m7: Partnership with Żabka for distribution")

🟢 NICE TO HAVE:
- Optimizations

NO GENERIC ADVICE like "consider research" or "might want to test". Give SPECIFIC actions with IDs, numbers, and rationale.

Remember: RESPOND IN THE SAME LANGUAGE AS THE STRATEGY. Be direct, numerical, and reference specific IDs.
"""

        # Call API
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[
                {"role": "system", "content": "You are a ruthlessly honest strategy auditor. Find flaws, gaps, and risks. Reference specific IDs and numbers. Always respond in the same language as the user's input."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.5,
            max_tokens=2500
        )

        return response.choices[0].message.content

    except Exception as e:
        return f"Error calling OpenAI API: {str(e)}\n\nPlease check your API key and try again."


def render_report():
    """Render report generation page"""
    st.markdown('<div class="main-header">Strategy Report</div>', unsafe_allow_html=True)
    st.markdown('<div class="sub-header">View and export your complete strategy</div>', unsafe_allow_html=True)

    strategy = st.session_state.strategy

    if not strategy.goal:
        st.warning("No strategy to report. Go to Strategy Builder first.")
        return

    # Generate report
    report = generate_report(strategy)

    # Display report
    st.markdown(report)

    # Export buttons
    st.markdown("---")
    col1, col2 = st.columns(2)

    with col1:
        st.download_button(
            label="📄 Download as Markdown",
            data=report,
            file_name=f"strategy_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md",
            mime="text/markdown",
            use_container_width=True
        )

    with col2:
        json_data = json.dumps(strategy.to_dict(), indent=2, ensure_ascii=False)
        st.download_button(
            label="📥 Download as JSON",
            data=json_data,
            file_name=f"strategy_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
            mime="application/json",
            use_container_width=True
        )


def generate_report(strategy: Strategy) -> str:
    """Generate markdown report from strategy"""
    report = f"""# Strategic Sandbox Report
*Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*

---

## 🎯 Goal

**{strategy.goal.text if strategy.goal else 'Not defined'}**

"""

    if strategy.goal:
        report += f"""
- **Metric:** {strategy.goal.metric}
- **Baseline:** {strategy.goal.baseline}{strategy.goal.unit}
- **Target:** {strategy.goal.target}{strategy.goal.unit}
- **Horizon:** {strategy.goal.horizon}
- **Unit:** {strategy.goal.unit}
"""

    if strategy.arena:
        report += f"""
---

## 🗺️ Arena

- **Market:** {strategy.arena.market}
- **Category:** {strategy.arena.category}
- **Target Audience:** {strategy.arena.target_audience}
- **Competitors:** {', '.join(strategy.arena.competitors)}
"""

    if strategy.insights:
        report += "\n---\n\n## 💡 Insights\n\n"
        for insight in strategy.insights:
            report += f"### {insight.id}\n{insight.text}\n\n*Evidence: {', '.join(insight.evidence)}*\n\n"

    if strategy.hypotheses:
        report += "---\n\n## 🔬 Hypotheses\n\n"
        for hyp in strategy.hypotheses:
            report += f"### {hyp.id}\n{hyp.text}\n\n"
            report += f"- Based on: {', '.join(hyp.based_on)}\n"
            report += f"- Metric: {hyp.metric}\n"
            report += f"- Expected change: {hyp.expected_change}\n\n"

    if strategy.moves:
        report += "---\n\n## 🎬 Moves\n\n"
        for move in strategy.moves:
            report += f"### {move.id}: {move.text}\n\n"
            report += f"- Linked hypothesis: {move.linked_hypothesis}\n"
            report += f"- Impact: {move.impact} | Fit: {move.fit} | Risk: {move.risk}\n"
            report += f"- Cost: {move.cost:,.0f}\n\n"

    if strategy.metrics:
        report += "---\n\n## 📊 Supporting Metrics\n\n"
        for metric in strategy.metrics:
            report += f"### {metric.id}: {metric.text}\n"
            report += f"- Baseline: {metric.baseline}{metric.unit}\n"
            report += f"- Target: {metric.target}{metric.unit}\n\n"

    # Add simulation results if available
    if st.session_state.simulation_results:
        results = st.session_state.simulation_results
        report += "---\n\n## 📈 Simulation Results\n\n"
        report += f"**Total Impact Score:** {results['total_impact']:.4f}\n\n"

        report += "### Move Rankings\n\n"
        for move in results['move_scores']:
            report += f"- **{move['id']}**: Score {move['score']:.4f} (Impact: {move['impact']}, Risk: {move['risk']}, Cost: {move['cost']:,.0f})\n"

    # Add AI feedback if available
    if st.session_state.ai_feedback:
        report += "\n---\n\n## 🤖 AI Evaluation\n\n"
        report += st.session_state.ai_feedback

    report += "\n\n---\n\n*Generated with Strategic Sandbox v1.0*\n"
    report += "*🤖 Generated with [Claude Code](https://claude.com/claude-code)*\n"

    return report


def save_strategy():
    """Save strategy to JSON file"""
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    filename = f"data/strategy_{timestamp}.json"
    st.session_state.strategy.to_json(filename)
    st.success(f"Strategy saved to {filename}")


def export_strategy_json():
    """Export strategy as downloadable JSON"""
    json_data = json.dumps(st.session_state.strategy.to_dict(), indent=2, ensure_ascii=False)
    st.download_button(
        label="Download JSON",
        data=json_data,
        file_name=f"strategy_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
        mime="application/json"
    )


# Main app
def main():
    init_session_state()
    render_sidebar()

    # Route to appropriate page
    page = st.session_state.current_page

    if page == "Dashboard":
        render_dashboard()
    elif page == "Strategy Builder":
        render_strategy_builder()
    elif page == "Simulation":
        render_simulation()
    elif page == "AI Evaluator":
        render_ai_evaluator()
    elif page == "Report":
        render_report()


if __name__ == "__main__":
    main()