Blame for app.py

"""
LiiS Circular Economy Simulator
Interactive dashboard with stakeholder-specific views.

Run with: streamlit run app.py
"""

import streamlit as st
import plotly.graph_objects as go
import pandas as pd
from pathlib import Path
import yaml
def sfmt(n, decimals=0):
    """Format number with space as thousands separator."""
    return f"{n:,.{decimals}f}".replace(",", " ")

# ── LiiS Brand Palette ──
COLORS = {
    "bg": "#f9fcf3",
    "surface": "#ffffff",
    "surface_alt": "#eef5e6",
    "primary": "#124b5f",
    "secondary": "#785964",
    "text": "#1a1a2e",
    "text_muted": "#4a5568",
    "text_subtle": "#718096",
    "border": "#d1ddc8",
    "positive": "#124b5f",
    "negative": "#a0444a",
    "warning": "#c87941",
    "info": "#4a7c9b",
}
CHART_COLORS = ["#124b5f", "#785964", "#2a7f62", "#c87941", "#4a7c9b", "#a0444a"]

# LiiS light Plotly theme
LIIS_LAYOUT = dict(
    paper_bgcolor=COLORS["bg"],
    plot_bgcolor=COLORS["surface"],
    font=dict(family="Futura, Century Gothic, Arial, sans-serif", color=COLORS["text"], size=14),
    xaxis=dict(gridcolor="#e2e8f0", zerolinecolor=COLORS["border"]),
    yaxis=dict(gridcolor="#e2e8f0", zerolinecolor=COLORS["border"]),
    colorway=CHART_COLORS,
    legend=dict(orientation="h", yanchor="bottom", y=1.02),
    hovermode="x unified",
)

import plotly.io as pio
liis_template = pio.templates["plotly"]
liis_template.layout.update(LIIS_LAYOUT)
liis_template.layout.separators = ", "  # decimal=comma-free, thousands=space
pio.templates["liis"] = liis_template
pio.templates.default = "liis"

# ── Helper Functions ──

def hero_card(label, value, unit="", subtitle=""):
    """Large centered hero metric card."""
    unit_html = f' <span style="font-size: 1.2rem; font-weight: 400; color: {COLORS["text_subtle"]};">{unit}</span>' if unit else ""
    subtitle_html = f'<p style="color: {COLORS["text_subtle"]}; margin: 0.5rem 0 0 0; font-size: 0.95rem;">{subtitle}</p>' if subtitle else ""
    return f"""
    <div style="text-align: center; padding: 2rem 1.5rem; background: {COLORS['surface']};
        border-radius: 10px; border: 1px solid {COLORS['border']};">
        <p style="color: {COLORS['text_muted']}; margin: 0 0 0.5rem 0;
           font-size: 1.3rem; font-weight: 700;">{label}</p>
        <p style="color: {COLORS['primary']}; margin: 0;
           font-size: 3rem; font-weight: 700;">{value}{unit_html}</p>
        {subtitle_html}
    </div>
    """

def metric_card(label, value, unit="", color=None):
    """Smaller supporting metric card."""
    c = color or COLORS["primary"]
    unit_html = f' <span style="font-size: 1.1rem; font-weight: 400; color: {COLORS["text_subtle"]};">{unit}</span>' if unit else ""
    return f"""
    <div style="text-align: center; padding: 1.5rem; background: {COLORS['surface']};
        border-radius: 10px; border: 1px solid {COLORS['border']};">
        <p style="color: {COLORS['text_muted']}; margin: 0 0 0.5rem 0;
           font-size: 1.2rem; font-weight: 700;">{label}</p>
        <p style="color: {c}; margin: 0;
           font-size: 2.4rem; font-weight: 600;">{value}{unit_html}</p>
    </div>
    """

def slider_with_input(label, min_value, max_value, key, step=1, format=None, help=None):
    """Sidebar slider paired with a number input, so exact values can be typed in."""
    num_key = f"_{key}_num"
    if key not in st.session_state:
        st.session_state[key] = min_value
    if num_key not in st.session_state:
        st.session_state[num_key] = st.session_state[key]

    def _from_slider():
        st.session_state[num_key] = st.session_state[key]

    def _from_number():
        v = min(max_value, max(min_value, st.session_state[num_key]))
        st.session_state[num_key] = v
        st.session_state[key] = v

    col_slider, col_input = st.sidebar.columns([2.3, 1])
    with col_slider:
        st.slider(label, min_value, max_value, step=step, format=format, key=key, help=help, on_change=_from_slider)
    with col_input:
        st.markdown("<div style='height: 1.6rem'></div>", unsafe_allow_html=True)
        st.number_input(
            label, min_value=min_value, max_value=max_value, step=step,
            key=num_key, on_change=_from_number, label_visibility="collapsed",
        )


def foundation_banner():
    """Read-only bar showing Strategy foundation values."""
    portfolio = st.session_state.strategy_portfolio
    lease = st.session_state.strategy_monthly_lease
    mfg = st.session_state.strategy_mfg_cost
    cycles = st.session_state.strategy_reuse_cycles
    st.markdown(f"""
    <div style="display: flex; justify-content: space-between; padding: 0.75rem 1.5rem;
        background: {COLORS['surface_alt']}; border-radius: 8px; border: 1px solid {COLORS['border']};
        margin-bottom: 1.5rem;">
        <span style="color: {COLORS['text_muted']}; font-size: 0.9rem;">
            <b>Strategy:</b> Portfolio {sfmt(portfolio)} units &nbsp;|&nbsp;
            Lease {sfmt(lease)} NOK/mo &nbsp;|&nbsp;
            Mfg cost {sfmt(mfg)} NOK &nbsp;|&nbsp;
            {cycles} reuse cycles
        </span>
    </div>
    """, unsafe_allow_html=True)


# Page config
st.set_page_config(
    page_title="LiiS Simulator",
    page_icon="♻️",
    layout="wide",
)

# Custom CSS — LiiS brand
st.markdown(f"""
<style>
    [data-testid="stMetricValue"] {{ font-size: 1.8rem; color: {COLORS['primary']}; }}
    .stMarkdown h2 {{ border-bottom: 2px solid {COLORS['primary']}; padding-bottom: 0.5rem; }}
    [data-testid="stImage"] {{ border-radius: 10px; }}
    .stSuccess, .stInfo {{ border-radius: 8px; }}
    .stDataFrame {{ border-radius: 8px; }}
    .streamlit-expanderHeader {{ border-radius: 8px; }}
    /* Sidebar: kill all top spacing */
    [data-testid="stSidebar"] > div {{ padding-top: 0 !important; margin-top: 0 !important; }}
    [data-testid="stSidebar"] [data-testid="stSidebarContent"] {{ padding-top: 0 !important; }}
    [data-testid="stSidebar"] [data-testid="stVerticalBlock"] {{ gap: 0.5rem; }}
    [data-testid="stSidebar"] .stElementContainer:first-child {{ margin-top: 0 !important; }}
    section[data-testid="stSidebar"] {{ padding-top: 0 !important; }}
    [data-testid="stSidebarCollapsedControl"] {{ top: 0.5rem; }}
    /* Dropdowns: non-editable */
    [data-testid="stSidebar"] [data-testid="stSelectbox"] input {{ pointer-events: none; caret-color: transparent; }}
</style>
""", unsafe_allow_html=True)

# Header
import base64
st.title("Circular Economy Transition")


# Load product configs
def load_products():
    products = {}
    products_dir = Path("products")
    for product_dir in products_dir.iterdir():
        if product_dir.is_dir():
            config_path = product_dir / "config.yaml"
            if config_path.exists():
                products[product_dir.name] = yaml.safe_load(config_path.read_text())
    return products


products = load_products()

# ============================================================
# SIDEBAR - Product Selection & View Selection
# ============================================================
with open("branding/image.png", "rb") as f:
    logo_b64 = base64.b64encode(f.read()).decode()
st.sidebar.markdown(f'<img src="data:image/png;base64,{logo_b64}" style="height: 44px; margin: -50px 0 1rem 0; padding: 0; display: block;">', unsafe_allow_html=True)
selected_view = st.sidebar.selectbox(
    "View",
    options=["Strategy", "Design", "Operations", "Logistics", "Sourcing", "Market", "Sustainability"],
    index=0,
)

_product_keys = list(products.keys())
_default_product_index = _product_keys.index("parkdress") if "parkdress" in _product_keys else 0
selected_product = st.sidebar.selectbox(
    "Product",
    options=_product_keys,
    format_func=lambda x: products[x]["product"]["name"],
    index=_default_product_index,
)
config = products[selected_product]

product_image_path = Path("products") / selected_product / "image.png"
if not product_image_path.exists():
    product_image_path = Path("products") / selected_product / "image.webp"
if product_image_path.exists():
    st.sidebar.image(str(product_image_path), use_container_width=True)


# ============================================================
# TAB-SPECIFIC SIDEBAR CONTROLS
# ============================================================

# Initialize all values with defaults from config
product_info = config["product"]
retail_price = product_info.get("retail_price", 0)
lease_term = config["pricing"]["lease_term_months"]
max_cycles = config["design"]["max_cycles"]

# Default values (all NOK)
default_lease_price = config["pricing"]["lease_monthly"]
default_return_rate = config["return_assumptions"]["return_rate"]
default_refurb_pct = config["return_assumptions"]["grade_distribution"]["b"] + config["return_assumptions"]["grade_distribution"].get("c", 0.05)
default_mfg_cost = config["costs"]["manufacturing_unit_cost"]
default_avg_refurb = (config["costs"]["refurbishment"]["grade_a"] * 0.7 + config["costs"]["refurbishment"]["grade_b"] * 0.3)
default_logistics = config["costs"]["logistics"]["delivery"] + config["costs"]["logistics"]["return"]

# Streamlit discards a widget's state on runs where it isn't drawn; re-assigning keeps
# slider values when switching between views.
for _key in list(st.session_state.keys()):
    if _key.startswith(("strategy_", "design_", "ops_", "sourcing_", "market_", "sust_")):
        st.session_state[_key] = st.session_state[_key]

# True only on the very first run of a session, before any defaults are set
_first_load = "strategy_portfolio" not in st.session_state

# Product-specific values reset to the selected product's defaults
if st.session_state.get("active_product") != selected_product:
    st.session_state.active_product = selected_product
    st.session_state.lease_price = default_lease_price
    st.session_state.mfg_cost = default_mfg_cost
    st.session_state.return_rate = default_return_rate
    st.session_state.refurb_needed_pct = default_refurb_pct
    st.session_state.avg_refurb_cost = int(default_avg_refurb)
    st.session_state.logistics = default_logistics
    st.session_state.max_cycles_override = max_cycles
    st.session_state.strategy_monthly_lease = default_lease_price
    st.session_state.strategy_mfg_cost = default_mfg_cost
    st.session_state.logistics_cost_per_cycle = max(100, min(1000, default_logistics))

# Strategy view session state
if "strategy_portfolio" not in st.session_state:
    st.session_state.strategy_portfolio = 7000
if "strategy_reuse_cycles" not in st.session_state:
    st.session_state.strategy_reuse_cycles = 4
if "strategy_cycle_length" not in st.session_state:
    st.session_state.strategy_cycle_length = 8
if "strategy_customer_base" not in st.session_state:
    st.session_state.strategy_customer_base = 1000

# App-wide starting point (overrides the selected product's config defaults once)
if _first_load:
    st.session_state.strategy_monthly_lease = 100
    st.session_state.strategy_mfg_cost = 750
    st.session_state.lease_price = 100
    st.session_state.mfg_cost = 750

# Render sidebar based on selected view
if selected_view == "Strategy":

    slider_with_input(
        "Product Portfolio", 100, 10000, step=50,
        key="strategy_portfolio", help="Number of units in your fleet"
    )
    slider_with_input(
        "Monthly Lease Price", 0, 1000, step=25,
        format="%d NOK", key="strategy_monthly_lease", help="What customers pay per month"
    )
    slider_with_input(
        "Manufacturing Cost", 0, 7500, step=250,
        format="%d NOK", key="strategy_mfg_cost", help="Cost to produce one unit"
    )
    slider_with_input(
        "Reuse Cycles", 1, 10,
        key="strategy_reuse_cycles", help="How many families use each product"
    )
    slider_with_input(
        "Cycle Length", 1, 36, step=1,
        format="%d mo", key="strategy_cycle_length",
        help="How many months each lease cycle lasts"
    )
    slider_with_input(
        "Cycle Cost", 100, 1000, step=25,
        format="%d NOK", key="logistics_cost_per_cycle",
        help="Total logistics cost per cycle (delivery + return + processing)"
    )

    # Keep shared state in sync (pure NOK now)
    st.session_state.lease_price = st.session_state.strategy_monthly_lease
    st.session_state.mfg_cost = st.session_state.strategy_mfg_cost

elif selected_view == "Design":
    if "design_damage_rate" not in st.session_state:
        st.session_state.design_damage_rate = 10
    if "design_repairability" not in st.session_state:
        st.session_state.design_repairability = 7
    if "design_spare_parts" not in st.session_state:
        st.session_state.design_spare_parts = 75

    slider_with_input(
        "Expected Damage Rate", 0, 50,
        key="design_damage_rate", format="%d%%",
        help="% of products needing repair per cycle"
    )
    slider_with_input(
        "Repairability Score", 0, 10,
        key="design_repairability",
        help="0 = everything scrapped, 10 = everything can be repaired"
    )
    slider_with_input(
        "Spare Parts Availability", 0, 100,
        key="design_spare_parts", format="%d%%",
        help="% of components available in supply chain"
    )

    # Sync back to shared state
    _damage = st.session_state.design_damage_rate / 100
    _repair_factor = st.session_state.design_repairability / 10
    _spare_factor = st.session_state.design_spare_parts / 100
    st.session_state.refurb_needed_pct = _damage * _repair_factor * _spare_factor + (_damage - _damage * _repair_factor * _spare_factor)

elif selected_view == "Operations":
    if "ops_batch_size" not in st.session_state:
        st.session_state.ops_batch_size = 500
    if "ops_qa_level" not in st.session_state:
        st.session_state.ops_qa_level = 3
    if "ops_repair_new_pct" not in st.session_state:
        st.session_state.ops_repair_new_pct = 50

    slider_with_input(
        "Batch Size", 100, 10000, step=100,
        key="ops_batch_size", help="Units processed per batch"
    )
    slider_with_input(
        "QA Inspection Level", 1, 6,
        key="ops_qa_level", help="1 = basic visual, 6 = full functional test"
    )
    slider_with_input(
        "Repair Components % New", 0, 100, step=5,
        key="ops_repair_new_pct", format="%d%%",
        help="% of replacement parts that are new (vs refurbished)"
    )

elif selected_view == "Logistics":
    if "logistics_collection_freq" not in st.session_state:
        st.session_state.logistics_collection_freq = "Bi-weekly"
    if "logistics_cost_per_cycle" not in st.session_state:
        st.session_state.logistics_cost_per_cycle = max(100, min(1000, default_logistics))

    st.session_state.logistics_collection_freq = st.sidebar.selectbox(
        "Collection Frequency",
        options=["Weekly", "Bi-weekly", "Monthly"],
        index=["Weekly", "Bi-weekly", "Monthly"].index(st.session_state.logistics_collection_freq),
        help="How often products are collected from customers"
    )
    slider_with_input(
        "Logistics Cost per Cycle", 100, 1000, step=25,
        format="%d NOK", key="logistics_cost_per_cycle",
        help="Total logistics cost (delivery + return + processing)"
    )

elif selected_view == "Sourcing":
    if "sourcing_recycled_target" not in st.session_state:
        st.session_state.sourcing_recycled_target = 20
    if "sourcing_closed_loop" not in st.session_state:
        st.session_state.sourcing_closed_loop = 10
    if "sourcing_production_eff" not in st.session_state:
        st.session_state.sourcing_production_eff = 85

    slider_with_input(
        "Recycled Content Target", 0, 100, step=5,
        key="sourcing_recycled_target", format="%d%%",
        help="Target % of recycled material in new products"
    )
    slider_with_input(
        "Closed-Loop Recovery", 0, 100, step=5,
        key="sourcing_closed_loop", format="%d%%",
        help="% of materials recovered from own product returns"
    )
    slider_with_input(
        "Production Efficiency", 0, 100, step=5,
        key="sourcing_production_eff", format="%d%%",
        help="% of raw material that ends up in finished product"
    )

elif selected_view == "Market":
    if "market_quality_level" not in st.session_state:
        st.session_state.market_quality_level = 4
    if "market_pricing_discount" not in st.session_state:
        st.session_state.market_pricing_discount = 0
    if "market_subscription_tier" not in st.session_state:
        st.session_state.market_subscription_tier = "Standard"

    slider_with_input(
        "Service Quality Level", 1, 6,
        key="market_quality_level",
        help="1 = basic, 6 = premium white-glove service"
    )
    slider_with_input(
        "Pricing Discount", 0, 100, step=5,
        key="market_pricing_discount", format="%d%%",
        help="Discount from standard lease price"
    )
    st.session_state.market_subscription_tier = st.sidebar.selectbox(
        "Subscription Tier",
        options=["Basic", "Standard", "Premium"],
        index=["Basic", "Standard", "Premium"].index(st.session_state.market_subscription_tier),
        help="Tier affects service level and pricing"
    )

elif selected_view == "Sustainability":
    if "sust_reuse_cycles" not in st.session_state:
        st.session_state.sust_reuse_cycles = 3
    if "sust_recycled_content" not in st.session_state:
        st.session_state.sust_recycled_content = 20
    if "sust_production_eff" not in st.session_state:
        st.session_state.sust_production_eff = 85

    slider_with_input(
        "Reuse Cycles (Slowing)", 1, 6,
        key="sust_reuse_cycles",
        help="Number of reuse cycles — slowing the loop"
    )
    slider_with_input(
        "Recycled Content (Closing)", 0, 100, step=5,
        key="sust_recycled_content", format="%d%%",
        help="% recycled material — closing the loop"
    )
    slider_with_input(
        "Production Efficiency (Narrowing)", 0, 100, step=5,
        key="sust_production_eff", format="%d%%",
        help="Material efficiency — narrowing the loop"
    )

# ============================================================
# DERIVED VALUES (used across all views)
# ============================================================
lease_price = st.session_state.lease_price
mfg_cost = st.session_state.mfg_cost
return_rate = st.session_state.return_rate
refurb_needed_pct = st.session_state.refurb_needed_pct
avg_refurb_cost = st.session_state.avg_refurb_cost
logistics = st.session_state.logistics
max_cycles = st.session_state.max_cycles_override

grade_a_pct = 1.0 - refurb_needed_pct - 0.05
grade_b_pct = refurb_needed_pct
grade_c_pct = 0.05

eolrr = return_rate * (grade_a_pct + grade_b_pct)
new_unit_cost = mfg_cost + logistics
refurb_unit_cost = avg_refurb_cost + logistics
revenue_per_customer = lease_price * lease_term
total_lease_cost = lease_price * lease_term

refurb_a = int(avg_refurb_cost * 0.4)
refurb_b = int(avg_refurb_cost * 1.8)

# Executive Summary calculations
lifecycle_revenue = max_cycles * revenue_per_customer
lifecycle_cost = new_unit_cost + (max_cycles - 1) * refurb_unit_cost
lifecycle_profit = lifecycle_revenue - lifecycle_cost
operating_margin = (lifecycle_profit / lifecycle_revenue) * 100 if lifecycle_revenue > 0 else 0

# Model status thresholds
if operating_margin >= 30:
    model_status, status_color = "Profitable", COLORS["positive"]
elif operating_margin >= 15:
    model_status, status_color = "Healthy", COLORS["warning"]
elif operating_margin >= 0:
    model_status, status_color = "Break-even", COLORS["secondary"]
else:
    model_status, status_color = "Loss", COLORS["negative"]



# ============================================================
# HELPER: Break-even calculation
# ============================================================
def calculate_breakeven_months(portfolio, monthly_lease, mfg_cost_nok, lease_term_mo=12, logistics_nok=150, repair_nok=200, max_months=120):
    """Return (breakeven_month, cumulative_list) for given parameters.

    A lease cycle shorter than 12 months (e.g. a seasonal product) is assumed to
    sit idle — no revenue — for the rest of the calendar year before the next
    cycle begins. Transport + maintenance cost is paid as a lump sum at the end
    of each active period, when the product is collected back and refurbished.
    """
    real_cycle_mo = max(lease_term_mo, 12)
    monthly_revenue = portfolio * monthly_lease
    cycle_cost = portfolio * (logistics_nok + repair_nok)
    initial = -portfolio * mfg_cost_nok
    cumulative = initial
    cumulative_list = [cumulative]
    breakeven = None
    for month in range(1, max_months + 1):
        position_in_cycle = (month - 1) % real_cycle_mo
        active = position_in_cycle < lease_term_mo
        if position_in_cycle == lease_term_mo - 1:
            cumulative -= cycle_cost
        if active:
            cumulative += monthly_revenue
        cumulative_list.append(cumulative)
        if cumulative >= 0 and breakeven is None:
            breakeven = month
    return breakeven, cumulative_list


# ============================================================
# VIEW: STRATEGY (C-Level)
# ============================================================
if selected_view == "Strategy":
    st.header("Strategy")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For C-level executives and business owners</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">Portfolio economics, break-even timeline, and operating margin</p>', unsafe_allow_html=True)

    st.subheader("Portfolio Economics")

    # Get Strategy slider values
    portfolio_size = st.session_state.strategy_portfolio
    monthly_lease = st.session_state.strategy_monthly_lease
    s_mfg_cost = st.session_state.strategy_mfg_cost
    reuse_cycles = st.session_state.strategy_reuse_cycles

    # ============================================================
    # CALCULATIONS
    # ============================================================
    lease_term_months = st.session_state.strategy_cycle_length
    logistics_per_cycle = st.session_state.logistics_cost_per_cycle  # NOK - pickup + delivery per cycle
    repair_per_cycle = 200  # NOK - average repair/refurb per cycle

    # A cycle shorter than a year (e.g. a seasonal product) sits idle — no
    # revenue, no wear — for the rest of the calendar year before the next
    # cycle's logistics cost is paid and it goes back into active service.
    idle_months = max(0, 12 - lease_term_months)
    real_cycle_months = lease_term_months + idle_months

    # Per-product economics
    revenue_per_product = monthly_lease * lease_term_months * reuse_cycles
    total_cost_per_product = s_mfg_cost + (logistics_per_cycle + repair_per_cycle) * reuse_cycles
    blended_cost_per_product = total_cost_per_product / reuse_cycles if reuse_cycles > 0 else total_cost_per_product
    profit_per_product = revenue_per_product - total_cost_per_product
    operating_margin_strat = (profit_per_product / revenue_per_product) * 100 if revenue_per_product > 0 else 0

    # Portfolio level
    revenue_portfolio = portfolio_size * revenue_per_product
    profit_portfolio = portfolio_size * profit_per_product

    # Break-even using helper
    breakeven_month, breakeven_cumulative = calculate_breakeven_months(
        portfolio_size, monthly_lease, s_mfg_cost,
        lease_term_months, logistics_per_cycle, repair_per_cycle,
    )

    # ============================================================
    # TIER 1: Break Even + Operating Margin
    # ============================================================
    be_display = f"{breakeven_month}" if breakeven_month else "> 120"

    t1_left, t1_right = st.columns(2)
    with t1_left:
        st.markdown(hero_card("Break Even Period", be_display, "months"), unsafe_allow_html=True)
    with t1_right:
        st.markdown(hero_card("Operating Margin", f"{operating_margin_strat:.0f}%"), unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

    # ============================================================
    # TIER 2: Revenue + Blended Cost (per product & portfolio)
    # ============================================================
    st.subheader("Operating Efficiency")
    blended_cost_portfolio = portfolio_size * blended_cost_per_product

    # Row: Revenue
    r1_left, r1_right = st.columns(2)
    with r1_left:
        st.markdown(metric_card("Revenue / Product", sfmt(revenue_per_product), "NOK"), unsafe_allow_html=True)
    with r1_right:
        st.markdown(metric_card("Portfolio Revenue", sfmt(revenue_portfolio), "NOK"), unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 0.75rem;"></div>', unsafe_allow_html=True)

    # Row: Blended Cost
    r2_left, r2_right = st.columns(2)
    with r2_left:
        st.markdown(metric_card("Blended Cost / Product", sfmt(blended_cost_per_product), "NOK", COLORS["secondary"]), unsafe_allow_html=True)
    with r2_right:
        st.markdown(metric_card("Portfolio Blended Cost", sfmt(blended_cost_portfolio), "NOK", COLORS["secondary"]), unsafe_allow_html=True)

    cycle_length_note = f"Assuming {lease_term_months}-month cycle length."
    if idle_months > 0:
        cycle_length_note = f"Assuming {lease_term_months} active months + {idle_months} idle (off-season) months per {real_cycle_months}-month cycle."
    st.markdown(f'<p style="text-align: center; color: {COLORS["text_muted"]}; font-size: 0.95rem; margin-top: 1rem;">{cycle_length_note}</p>', unsafe_allow_html=True)

    st.markdown("---")

    # ============================================================
    # CHART 1: Break Even Timeline
    # ============================================================
    st.subheader("Break Even Timeline")

    if monthly_lease == 0:
        st.warning("Set a lease price above 0 NOK to see the break-even timeline.")
    else:
        # Scale chart length with reuse cycles (each real cycle = active + idle months)
        chart_months = min(reuse_cycles * real_cycle_months, len(breakeven_cumulative) - 1)
        be_months = list(range(chart_months + 1))

        # Revenue builds steadily during each cycle's active months, then flatlines
        # for its idle months (e.g. a seasonal product with no one renting it).
        # Cost starts at the upfront manufacturing spend and is otherwise flat —
        # it only steps up as a lump sum at the end of each active period, when
        # the product is collected back for transport and maintenance.
        monthly_revenue_val = portfolio_size * monthly_lease
        initial_investment = portfolio_size * s_mfg_cost
        cycle_cost_val = portfolio_size * (logistics_per_cycle + repair_per_cycle)

        def _active_months_through(m):
            full_cycles, remainder = divmod(m, real_cycle_months)
            return full_cycles * lease_term_months + min(remainder, lease_term_months)

        def _cycle_events_through(m):
            full_cycles, remainder = divmod(m, real_cycle_months)
            return full_cycles + (1 if remainder >= lease_term_months else 0)

        revenue_cum = [monthly_revenue_val * _active_months_through(m) for m in be_months]
        cost_cum = [
            initial_investment + cycle_cost_val * _cycle_events_through(m)
            for m in be_months
        ]

        be_lead = f'Cost starts at <b>{sfmt(initial_investment)} NOK</b> — the upfront manufacturing spend — then steps up by <b>{sfmt(cycle_cost_val)} NOK</b> each time the portfolio is collected back for transport and maintenance. Revenue builds during each cycle\'s active months'
        be_lead += f' and flatlines for its {idle_months} idle months.' if idle_months > 0 else '.'
        if breakeven_month and breakeven_month <= chart_months:
            lead_gap = revenue_cum[-1] - cost_cum[-1]
            be_lead += f' Revenue overtakes cost in <b>month {breakeven_month}</b>, and the portfolio is <b>{sfmt(lead_gap)} NOK</b> ahead by month {chart_months}.'
        else:
            be_lead += f' Cost still leads revenue after {chart_months} months at these settings.'
        st.markdown(f'<p style="color: {COLORS["text_muted"]}; font-size: 0.95rem; margin: 0 0 1rem 0;">{be_lead}</p>', unsafe_allow_html=True)

        # Pre-formatted hover text (matches the rest of the app's number style,
        # instead of Plotly's default SI-suffix auto-formatting)
        rev_hover = [f"+{sfmt(v)} NOK" for v in revenue_cum]
        cost_hover = [f"-{sfmt(v)} NOK" for v in cost_cum]

        fig_be = go.Figure()

        # Shaded gap between the lines — red while cost leads, teal once revenue overtakes it.
        # hoverinfo is skipped so these don't clutter the tooltip.
        crossing = breakeven_month if (breakeven_month and breakeven_month <= chart_months) else chart_months
        if crossing > 0:
            fig_be.add_trace(go.Scatter(
                x=be_months[:crossing + 1] + be_months[:crossing + 1][::-1],
                y=cost_cum[:crossing + 1] + revenue_cum[:crossing + 1][::-1],
                mode="none", fill="toself", fillcolor="rgba(160, 68, 74, 0.16)",
                hoverinfo="skip", showlegend=False,
            ))
        if crossing < chart_months:
            fig_be.add_trace(go.Scatter(
                x=be_months[crossing:] + be_months[crossing:][::-1],
                y=revenue_cum[crossing:] + cost_cum[crossing:][::-1],
                mode="none", fill="toself", fillcolor="rgba(18, 75, 95, 0.12)",
                hoverinfo="skip", showlegend=False,
            ))

        fig_be.add_trace(go.Scatter(
            x=be_months, y=revenue_cum, mode="lines", name="Cumulative revenue",
            line=dict(color=COLORS["primary"], width=3),
            customdata=rev_hover,
            hovertemplate="Month %{x}<br>Revenue: <b>%{customdata}</b><extra></extra>",
        ))
        fig_be.add_trace(go.Scatter(
            x=be_months, y=cost_cum, mode="lines", name="Cumulative cost",
            line=dict(color=COLORS["negative"], width=3),
            customdata=cost_hover,
            hovertemplate="Month %{x}<br>Cost: <b>%{customdata}</b><extra></extra>",
        ))

        if breakeven_month and breakeven_month <= chart_months:
            cross_y = revenue_cum[breakeven_month]
            fig_be.add_trace(go.Scatter(
                x=[breakeven_month], y=[cross_y], mode="markers",
                marker=dict(size=14, color=COLORS["warning"], symbol="diamond",
                            line=dict(color="white", width=1.5)),
                hoverinfo="skip", showlegend=False,
            ))
            fig_be.add_annotation(
                x=breakeven_month, y=cross_y,
                text=f"<b>Break-even — month {breakeven_month}</b>",
                showarrow=True, arrowhead=2, arrowcolor=COLORS["warning"], ax=0, ay=-45,
                bgcolor="white", bordercolor=COLORS["warning"], borderwidth=1, borderpad=4,
                font=dict(size=12, color=COLORS["text"]),
            )

        fig_be.update_layout(
            xaxis_title="Months", yaxis_title="Cumulative NOK",
            showlegend=True, yaxis=dict(separatethousands=True),
            margin=dict(t=30),
        )
        st.plotly_chart(fig_be, use_container_width=True)
        caption = f"Cost steps up once per {lease_term_months}-month active period — transport + maintenance paid when the product is collected back; revenue accrues from the lease price during those same active months"
        caption += f" and pauses for the {idle_months} idle months." if idle_months > 0 else "."
        st.caption(caption)

    st.markdown("---")

    # ============================================================
    # CHART 2: Revenue & Cost Distribution
    # ============================================================
    st.subheader("Revenue & Cost Distribution")

    rev_per = monthly_lease * lease_term_months  # per cycle
    cost_per = blended_cost_per_product  # already blended across cycles
    margin_pct = operating_margin_strat

    profit_gap = rev_per - cost_per

    fig_rc = go.Figure()
    fig_rc.add_trace(go.Bar(
        x=["Revenue / Product / Cycle", "Blended Cost / Product / Cycle"],
        y=[rev_per, cost_per],
        marker_color=[COLORS["positive"], COLORS["negative"]],
        text=[sfmt(rev_per), sfmt(cost_per)],
        textposition="outside",
    ))

    # Profit gap annotation
    gap_mid = (rev_per + cost_per) / 2
    gap_color = COLORS["positive"] if profit_gap >= 0 else COLORS["negative"]
    gap_label = f"+{sfmt(profit_gap)} NOK" if profit_gap >= 0 else f"{sfmt(profit_gap)} NOK"

    fig_rc.add_shape(
        type="line", x0=0, x1=1, y0=rev_per, y1=rev_per,
        line=dict(color=gap_color, width=1, dash="dot"),
    )
    fig_rc.add_shape(
        type="line", x0=1, x1=1, y0=rev_per, y1=cost_per,
        line=dict(color=gap_color, width=2),
    )
    fig_rc.add_annotation(
        x=1, y=gap_mid,
        text=f"  <b>{gap_label}</b><br>  <span style='font-size:11px'>profit gap</span>",
        showarrow=False, xanchor="left",
        font=dict(size=14, color=gap_color),
    )
    fig_rc.add_annotation(
        x=0.5, y=max(rev_per, cost_per) * 1.18, xref="paper",
        text=f"Margin: {margin_pct:.0f}%", showarrow=False,
        font=dict(size=18, color=COLORS["primary"]),
    )
    fig_rc.update_layout(
        yaxis_title="NOK", showlegend=False,
        yaxis=dict(separatethousands=True),
    )
    st.plotly_chart(fig_rc, use_container_width=True)

    mfg_share = s_mfg_cost / reuse_cycles if reuse_cycles > 0 else s_mfg_cost
    st.caption(f"Blended cost breakdown: Mfg share {sfmt(mfg_share)} + logistics {sfmt(logistics_per_cycle)} + repair {sfmt(repair_per_cycle)} = **{sfmt(blended_cost_per_product)} NOK** per product per cycle")


# ============================================================
# VIEW: DESIGN
# ============================================================
elif selected_view == "Design":
    st.header("Design")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For product designers and sustainability officers</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">Recovery rate, repairability impact, and component failure analysis</p>', unsafe_allow_html=True)

    # ── Design-specific calculations from 3 sliders ──
    d_damage_rate = st.session_state.design_damage_rate / 100
    d_repairability_factor = st.session_state.design_repairability / 10
    d_spare_parts_factor = st.session_state.design_spare_parts / 100

    d_grade_a_pct = 1 - d_damage_rate
    d_grade_b_pct = d_damage_rate * d_repairability_factor * d_spare_parts_factor
    d_grade_c_pct = d_damage_rate - d_grade_b_pct
    d_recovery_rate = return_rate * (d_grade_a_pct + d_grade_b_pct)

    # Repair cost affected by repairability (easier repair = cheaper)
    base_repair = config["costs"]["refurbishment"]["grade_b"]
    d_repair_cost = base_repair * (1.4 - d_repairability_factor * 0.8)

    # Strategy foundation values
    s_cycles = st.session_state.strategy_reuse_cycles

    # ── Hero metric: Reuse Rate ──
    st.markdown(hero_card("Reuse Rate", f"{d_recovery_rate:.1%}", subtitle="% of returned products that can be reused"), unsafe_allow_html=True)

    st.markdown(f'<p style="text-align: center; color: {COLORS["text_subtle"]}; font-size: 0.85rem; margin-top: 0.5rem;">'
                f'Affected by: Expected Damage Rate, Repairability Score, Spare Parts Availability</p>',
                unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

    # ── Supporting metrics (row) ──
    sup_left, sup_right = st.columns(2)

    with sup_left:
        st.markdown(metric_card("Grade A Rate", f"{d_grade_a_pct:.1%}", color=COLORS["positive"]), unsafe_allow_html=True)

    with sup_right:
        st.markdown(metric_card("Repair Cost per Unit", f"{sfmt(int(d_repair_cost))}", "NOK", COLORS["secondary"]), unsafe_allow_html=True)

    st.markdown("---")

    # ── Chart 1: Design Choices -> Return Grades ──
    st.subheader("Design Choices → Return Grades")
    st.markdown("Better design for durability and repairability reduces the damage rate and increases Grade A returns.")

    grade_labels = ["C (Scrap)", "B (Repair needed)", "A (Clean only)"]
    grade_values = [d_grade_c_pct * 100, d_grade_b_pct * 100, d_grade_a_pct * 100]
    grade_colors = [COLORS["negative"], COLORS["warning"], COLORS["positive"]]

    fig_grades = go.Figure()
    fig_grades.add_trace(go.Bar(
        y=grade_labels,
        x=grade_values,
        orientation="h",
        marker_color=grade_colors,
        text=[f"{v:.1f}%" for v in grade_values],
        textposition="outside",
    ))
    fig_grades.update_layout(
        title="Return Grade Distribution", showlegend=False,
        xaxis=dict(range=[0, 105], title="% of Returns"),
        yaxis=dict(type="category"),
        height=350, hovermode="closest",
    )
    st.plotly_chart(fig_grades, use_container_width=True, config={"displayModeBar": False})

    st.info(f"**Design insight:** At {st.session_state.design_damage_rate}% damage rate with repairability score "
            f"{st.session_state.design_repairability}/10, "
            f"**{d_grade_b_pct:.1%}** of products can be repaired while **{d_grade_c_pct:.1%}** are scrapped.")

    st.markdown("---")

    # ── Chart 2: Part Failure Distribution ──
    st.subheader("Part Failure Distribution")
    st.markdown("Which components fail most frequently, driving repair costs.")

    has_bom = "materials" in config and "bom" in config.get("materials", {})
    if has_bom:
        bom_keys = list(config["materials"]["bom"].keys())
        bom_names = [config["materials"]["bom"][k].get("name", k) for k in bom_keys]
        failure_map = {
            "wheels": 40, "tire": 40, "wheel": 40,
            "fabric": 20, "canopy": 20, "cover": 20, "mesh": 20,
            "hinge": 20, "joint": 20, "hitch": 15, "steel": 10,
            "fastener": 10, "hardware": 10,
            "foam": 8, "padding": 8,
            "frame": 5, "aluminum": 5, "shell": 10, "plastic": 10,
            "harness": 15,
        }
        raw_failures = []
        for k in bom_keys:
            name_lower = k.lower()
            rate = 5
            for keyword, r in failure_map.items():
                if keyword in name_lower:
                    rate = r
                    break
            raw_failures.append(rate)
        total_raw = sum(raw_failures)
        failure_pcts = [r / total_raw * 100 for r in raw_failures]
        failure_df = pd.DataFrame({"Component": bom_names, "Failure %": failure_pcts})
    else:
        failure_df = pd.DataFrame({
            "Component": ["Wheels", "Fabric/Cover", "Joints/Hinges", "Fasteners", "Frame", "Other"],
            "Failure %": [40, 20, 20, 10, 5, 5],
        })

    failure_df = failure_df.sort_values("Failure %", ascending=True)

    fig_failure = go.Figure(go.Bar(
        x=failure_df["Failure %"],
        y=failure_df["Component"],
        orientation="h",
        marker_color=COLORS["primary"],
        text=[f"{v:.0f}%" for v in failure_df["Failure %"]],
        textposition="outside",
    ))
    fig_failure.update_layout(
        xaxis_title="% of Total Failures",
        yaxis_title="",
        showlegend=False,
    )
    st.plotly_chart(fig_failure, use_container_width=True)

    st.caption("Prioritize design improvements on high-failure components to reduce damage rate and repair costs.")

    st.markdown("---")

    # ── Chart 3: Product Condition Degradation ──
    st.subheader("Product Condition Degradation")
    st.markdown("Estimated functional condition after each reuse cycle.")

    gauge_cols = st.columns(s_cycles)
    for i, col in enumerate(gauge_cols):
        cycle_num = i + 1
        functional_pct = (1 - d_damage_rate) ** cycle_num * 100
        if functional_pct >= 80:
            gauge_color = COLORS["positive"]
        elif functional_pct >= 60:
            gauge_color = COLORS["warning"]
        else:
            gauge_color = COLORS["negative"]

        fig_gauge = go.Figure(go.Indicator(
            mode="gauge+number",
            value=functional_pct,
            number={"suffix": "%", "font": {"size": 22}, "valueformat": ".0f"},
            title={"text": f"Cycle {cycle_num}", "font": {"size": 14}},
            domain={"x": [0, 1], "y": [0, 1]},
            gauge={
                "axis": {"range": [0, 100], "tickwidth": 1},
                "bar": {"color": gauge_color},
                "bgcolor": COLORS["surface"],
                "borderwidth": 1,
                "bordercolor": COLORS["border"],
                "steps": [
                    {"range": [0, 60], "color": "rgba(160, 68, 74, 0.1)"},
                    {"range": [60, 80], "color": "rgba(200, 121, 65, 0.1)"},
                    {"range": [80, 100], "color": "rgba(18, 75, 95, 0.1)"},
                ],
            },
        ))
        fig_gauge.update_layout(
            height=220,
            margin=dict(t=50, b=0, l=20, r=20),
        )
        with col:
            st.plotly_chart(fig_gauge, use_container_width=True)

    st.caption(f"Acceptable for recovery rate of {d_recovery_rate:.0%}")


# ============================================================
# VIEW: OPERATIONS (NEW)
# ============================================================
elif selected_view == "Operations":
    st.header("Operations")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For operations managers and warehouse teams</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">Turnaround time, throughput capacity, and material waste analysis</p>', unsafe_allow_html=True)

    foundation_banner()

    # ── Operations calculations ──
    batch_size = st.session_state.ops_batch_size
    qa_level = st.session_state.ops_qa_level
    repair_new_pct = st.session_state.ops_repair_new_pct / 100

    queue_days = max(1, batch_size / 50)
    qa_days = 0.5 + (qa_level - 1) * 0.5
    repair_days = 2.0 * (1 + (1 - repair_new_pct) * 0.5)
    turnaround_days = queue_days + qa_days + repair_days

    # Repair cost scales with new parts %
    base_repair_cost = config["costs"]["refurbishment"]["grade_b"]
    ops_repair_cost = base_repair_cost * (0.6 + repair_new_pct * 0.8)

    # Portfolio values from strategy
    portfolio_size = st.session_state.strategy_portfolio
    reuse_cycles = st.session_state.strategy_reuse_cycles

    # Throughput
    working_days_per_month = 22
    throughput_per_month = int(working_days_per_month / turnaround_days * batch_size) if turnaround_days > 0 else 0
    fleet_coverage = min(100, throughput_per_month / max(1, portfolio_size) * 100)

    # ── Hero: Turnaround Time ──
    st.markdown(hero_card(
        "Turnaround Time",
        f"{turnaround_days:.1f}",
        "days",
        f"Queue ({queue_days:.1f}d) + QA ({qa_days:.1f}d) + Repair ({repair_days:.1f}d)"
    ), unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

    # ── Supporting metrics ──
    s1, s2, s3, s4 = st.columns(4)
    with s1:
        st.markdown(metric_card("New Components", f"{repair_new_pct:.0%}"), unsafe_allow_html=True)
    with s2:
        st.markdown(metric_card("Avg Repair Cost", sfmt(int(ops_repair_cost)), "NOK", COLORS["secondary"]), unsafe_allow_html=True)
    with s3:
        st.markdown(metric_card("Queue + QA Time", f"{queue_days + qa_days:.1f}", "days", COLORS["info"]), unsafe_allow_html=True)
    with s4:
        st.markdown(metric_card("Repair Time", f"{repair_days:.1f}", "days", COLORS["warning"]), unsafe_allow_html=True)

    st.markdown("---")

    # ── Unit / Portfolio Economics ──
    st.subheader("Throughput Capacity")
    tp1, tp2 = st.columns(2)
    with tp1:
        st.markdown(metric_card("Throughput / Month", sfmt(throughput_per_month), "units"), unsafe_allow_html=True)
    with tp2:
        st.markdown(metric_card("Fleet Coverage", f"{fleet_coverage:.0f}%", color=COLORS["positive"] if fleet_coverage >= 80 else COLORS["warning"]), unsafe_allow_html=True)

    st.markdown("---")

    # ── Chart 1: Turnaround Timeline Breakdown ──
    st.subheader("Turnaround Timeline Breakdown")

    fig_timeline = go.Figure()
    phases = ["Queue", "QA Inspection", "Repair"]
    durations = [queue_days, qa_days, repair_days]
    phase_colors = [COLORS["info"], COLORS["primary"], COLORS["warning"]]

    for i, (phase, dur, color) in enumerate(zip(phases, durations, phase_colors)):
        fig_timeline.add_trace(go.Bar(
            y=["Turnaround"],
            x=[dur],
            name=phase,
            orientation="h",
            marker_color=color,
            text=[f"{phase}: {dur:.1f}d"],
            textposition="inside",
            insidetextanchor="middle",
        ))

    fig_timeline.update_layout(
        barmode="stack",
        xaxis_title="Days",
        showlegend=True,
        height=200,
        yaxis=dict(showticklabels=False),
    )
    st.plotly_chart(fig_timeline, use_container_width=True)

    st.markdown("---")

    # ── Chart 2: Material Waste Composition ──
    st.subheader("Material Waste Composition")
    st.markdown("Estimated waste by material type from BOM (% of total product weight).")

    has_bom = "materials" in config and "bom" in config.get("materials", {})
    if has_bom:
        bom = config["materials"]["bom"]
        waste_data = []
        waste_map = {
            "foam": 15, "padding": 15,
            "fabric": 12, "canopy": 12, "cover": 12,
            "plastic": 8, "shell": 8,
            "rubber": 10, "tire": 10, "wheel": 10,
            "steel": 3, "aluminum": 2, "frame": 2,
            "harness": 7, "hardware": 5, "fastener": 5,
        }
        for k, comp in bom.items():
            name = comp.get("name", k)
            weight = comp.get("weight_kg", 0)
            recyclable = comp.get("recyclable", False)
            waste_pct = 2 if recyclable else 10
            for keyword, wp in waste_map.items():
                if keyword in k.lower():
                    waste_pct = wp
                    break
            waste_data.append({"Material": name, "Waste %": waste_pct, "Weight": weight})

        waste_df = pd.DataFrame(waste_data).sort_values("Waste %", ascending=True)

        fig_waste = go.Figure(go.Bar(
            x=waste_df["Waste %"],
            y=waste_df["Material"],
            orientation="h",
            marker_color=[COLORS["negative"] if w > 10 else COLORS["warning"] if w > 5 else COLORS["positive"] for w in waste_df["Waste %"]],
            text=[f"{v}%" for v in waste_df["Waste %"]],
            textposition="outside",
        ))
        fig_waste.update_layout(
            xaxis_title="Waste Rate (%)",
            showlegend=False,
        )
        st.plotly_chart(fig_waste, use_container_width=True)
    else:
        st.info("Add BOM data to product config for detailed waste analysis.")

    st.caption("Waste rates are simulated estimates based on material type and recyclability.")


# ============================================================
# VIEW: LOGISTICS (REDESIGN)
# ============================================================
elif selected_view == "Logistics":
    st.header("Logistics")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For logistics managers and warehouse operations</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">Collection timing, exchange efficiency, and logistics cost breakdown</p>', unsafe_allow_html=True)

    foundation_banner()

    # ── Logistics calculations ──
    collection_freq = st.session_state.logistics_collection_freq
    logistics_cost = st.session_state.logistics_cost_per_cycle

    collection_time_map = {"Weekly": 3, "Bi-weekly": 7, "Monthly": 14}
    collection_days = collection_time_map[collection_freq]

    # Exchange time improves with frequency
    avg_exchange_days = collection_days * 0.7 + 1.5
    products_per_route = max(5, 30 - collection_days)
    cost_per_product = logistics_cost / max(1, products_per_route) * 3
    on_time_rate = max(70, 98 - collection_days * 1.5)

    portfolio_size = st.session_state.strategy_portfolio
    reuse_cycles = st.session_state.strategy_reuse_cycles
    delivery_cost = config["costs"]["logistics"]["delivery"]
    return_cost = config["costs"]["logistics"]["return"]

    # ── Hero: Collection Time ──
    st.markdown(hero_card(
        "Collection Time",
        f"{collection_days}",
        "days",
        f"{collection_freq} collection schedule"
    ), unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

    # ── Supporting metrics ──
    s1, s2, s3, s4 = st.columns(4)
    with s1:
        st.markdown(metric_card("Avg Exchange Time", f"{avg_exchange_days:.1f}", "days"), unsafe_allow_html=True)
    with s2:
        st.markdown(metric_card("Products / Route", f"{products_per_route}"), unsafe_allow_html=True)
    with s3:
        st.markdown(metric_card("Collection Cost", f"{sfmt(int(cost_per_product))}", "NOK", COLORS["secondary"]), unsafe_allow_html=True)
    with s4:
        st.markdown(metric_card("On-time Rate", f"{on_time_rate:.0f}%", color=COLORS["positive"] if on_time_rate >= 90 else COLORS["warning"]), unsafe_allow_html=True)

    st.markdown("---")

    # ── Chart 1: Exchange Time Over Cycles ──
    st.subheader("Exchange Time Over Cycles")
    st.markdown("How exchange time evolves across reuse cycles as processes improve.")

    cycles_range = list(range(1, reuse_cycles + 1))
    exchange_times = [avg_exchange_days * (1.1 - 0.05 * i) for i in range(reuse_cycles)]

    fig_exchange = go.Figure()
    fig_exchange.add_trace(go.Scatter(
        x=cycles_range, y=exchange_times,
        mode="lines+markers",
        line=dict(color=COLORS["primary"], width=3),
        marker=dict(size=10),
        name="Exchange Time",
        text=[f"{t:.1f} days" for t in exchange_times],
        textposition="top center",
    ))
    fig_exchange.update_layout(
        xaxis_title="Reuse Cycle",
        yaxis_title="Exchange Time (days)",
        showlegend=False,
        xaxis=dict(dtick=1),
    )
    st.plotly_chart(fig_exchange, use_container_width=True)

    st.markdown("---")

    # ── Chart 2: Logistics Cost Breakdown per Cycle ──
    st.subheader("Logistics Cost Breakdown per Cycle")

    processing_cost = logistics_cost - delivery_cost - return_cost
    processing_cost = max(0, processing_cost)

    cycle_data = []
    for cycle in range(1, reuse_cycles + 1):
        cycle_data.append({
            "Cycle": f"Cycle {cycle}",
            "Delivery": delivery_cost,
            "Return": return_cost,
            "Processing": processing_cost if cycle > 1 else 0,
        })

    df_logistics = pd.DataFrame(cycle_data)

    fig_logistics = go.Figure()
    fig_logistics.add_trace(go.Bar(
        name="Delivery", x=df_logistics["Cycle"], y=df_logistics["Delivery"],
        marker_color=COLORS["primary"],
        text=[f"{sfmt(v)} NOK" for v in df_logistics["Delivery"]], textposition="inside",
    ))
    fig_logistics.add_trace(go.Bar(
        name="Return", x=df_logistics["Cycle"], y=df_logistics["Return"],
        marker_color=COLORS["secondary"],
        text=[f"{sfmt(v)} NOK" for v in df_logistics["Return"]], textposition="inside",
    ))
    fig_logistics.add_trace(go.Bar(
        name="Processing", x=df_logistics["Cycle"], y=df_logistics["Processing"],
        marker_color=COLORS["info"],
        text=[f"{sfmt(v)} NOK" if v > 0 else "" for v in df_logistics["Processing"]], textposition="inside",
    ))
    fig_logistics.update_layout(
        barmode="stack",
        yaxis_title="Cost (NOK)",
        yaxis=dict(separatethousands=True),
    )
    st.plotly_chart(fig_logistics, use_container_width=True)

    total_logistics_lifecycle = sum(df_logistics["Delivery"]) + sum(df_logistics["Return"]) + sum(df_logistics["Processing"])
    st.caption(f"Total logistics cost over {reuse_cycles} cycles: **{sfmt(int(total_logistics_lifecycle))} NOK** per product")


# ============================================================
# VIEW: SOURCING (REDESIGN)
# ============================================================
elif selected_view == "Sourcing":
    st.header("Sourcing")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For procurement, supply chain, and finance</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">Material cost optimization, recycled content impact, and waste reduction</p>', unsafe_allow_html=True)

    foundation_banner()

    # ── Sourcing calculations ──
    recycled_target = st.session_state.sourcing_recycled_target / 100
    closed_loop = st.session_state.sourcing_closed_loop / 100
    production_eff = st.session_state.sourcing_production_eff / 100

    has_bom = "materials" in config and "bom" in config.get("materials", {})

    if has_bom:
        bom = config["materials"]["bom"]

        # Calculate material costs with recycled target applied
        material_data = []
        total_cost_current = 0
        total_cost_virgin = 0
        total_weight = 0
        total_recycled_weight = 0

        for comp_key, comp in bom.items():
            weight = comp.get("weight_kg", 0)
            total_weight += weight

            if "virgin_cost_per_kg" in comp:
                virgin_cpk = comp["virgin_cost_per_kg"]
                recycled_cpk = comp.get("recycled_cost_per_kg", virgin_cpk)
                # Apply the slider target to recyclable materials
                effective_recycled = recycled_target if comp.get("recyclable", False) else comp.get("recycled_content_pct", 0)
                blended_cpk = virgin_cpk * (1 - effective_recycled) + recycled_cpk * effective_recycled
                cost = weight * blended_cpk
                cost_virgin = weight * virgin_cpk
                total_recycled_weight += weight * effective_recycled
            else:
                cpk = comp.get("cost_per_kg", 0)
                cost = weight * cpk
                cost_virgin = cost
                blended_cpk = cpk
                effective_recycled = 0

            total_cost_current += cost
            total_cost_virgin += cost_virgin

            material_data.append({
                "Component": comp.get("name", comp_key),
                "Weight (kg)": weight,
                "Cost/kg (NOK)": blended_cpk,
                "Total (NOK)": cost,
                "Recycled %": effective_recycled * 100,
                "Recyclable": comp.get("recyclable", False),
            })

        combined_recycled_pct = (total_recycled_weight / total_weight * 100) if total_weight > 0 else 0
        waste_rate = (1 - production_eff) * 100
        cost_per_kg = total_cost_current / total_weight if total_weight > 0 else 0

        # ── Hero: Material Cost per Unit ──
        st.markdown(hero_card(
            "Material Cost per Unit",
            sfmt(int(total_cost_current)),
            "NOK",
            f"Based on {combined_recycled_pct:.0f}% recycled content target"
        ), unsafe_allow_html=True)

        st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

        # ── Supporting metrics ──
        s1, s2, s3, s4 = st.columns(4)
        with s1:
            st.markdown(metric_card("Combined Recycled", f"{combined_recycled_pct:.0f}%", color=COLORS["positive"]), unsafe_allow_html=True)
        with s2:
            st.markdown(metric_card("Virgin Material Cost", sfmt(int(total_cost_virgin)), "NOK", COLORS["negative"]), unsafe_allow_html=True)
        with s3:
            st.markdown(metric_card("Waste Rate", f"{waste_rate:.0f}%", color=COLORS["warning"]), unsafe_allow_html=True)
        with s4:
            st.markdown(metric_card("Cost / kg", f"{sfmt(cost_per_kg, 1)}", "NOK"), unsafe_allow_html=True)

        savings = total_cost_virgin - total_cost_current
        if savings > 0:
            st.success(f"Using {combined_recycled_pct:.0f}% recycled content saves **{sfmt(int(savings))} NOK** per unit vs 100% virgin materials ({savings/total_cost_virgin*100:.1f}% reduction)")

        st.markdown("---")

        # ── Chart 1: Recycled vs Virgin Cost ──
        st.subheader("Recycled vs Virgin Cost Comparison")

        fig_compare = go.Figure()
        fig_compare.add_trace(go.Bar(
            x=["100% Virgin", "Current Mix"],
            y=[total_cost_virgin, total_cost_current],
            marker_color=[COLORS["negative"], COLORS["positive"]],
            text=[f"{sfmt(int(total_cost_virgin))} NOK", f"{sfmt(int(total_cost_current))} NOK"],
            textposition="outside",
        ))
        if savings > 0:
            fig_compare.add_annotation(
                x=1, y=total_cost_current + (total_cost_virgin - total_cost_current) / 2,
                text=f"Saves {sfmt(int(savings))} NOK",
                showarrow=True, arrowhead=2,
                font=dict(size=14, color=COLORS["positive"]),
            )
        fig_compare.update_layout(
            yaxis_title="Material Cost (NOK)",
            showlegend=False,
            yaxis=dict(separatethousands=True),
        )
        st.plotly_chart(fig_compare, use_container_width=True)

        st.markdown("---")

        # ── Chart 2: Recycled Content Impact by Material ──
        st.subheader("Recycled Content by Material Type")

        mat_df = pd.DataFrame(material_data)
        recyclable_df = mat_df[mat_df["Recyclable"]].sort_values("Weight (kg)", ascending=True)

        if not recyclable_df.empty:
            fig_materials = go.Figure()
            fig_materials.add_trace(go.Bar(
                y=recyclable_df["Component"],
                x=recyclable_df["Recycled %"],
                orientation="h",
                marker_color=COLORS["primary"],
                text=[f"{v:.0f}%" for v in recyclable_df["Recycled %"]],
                textposition="outside",
                name="Recycled Content",
            ))
            fig_materials.update_layout(
                xaxis=dict(range=[0, 110], title="Recycled Content (%)"),
                showlegend=False,
            )
            st.plotly_chart(fig_materials, use_container_width=True)

        # BOM table
        with st.expander("Full Bill of Materials"):
            display_df = mat_df.copy()
            display_df["Recyclable"] = display_df["Recyclable"].map({True: "Yes", False: "No"})
            st.dataframe(display_df.style.format({
                "Weight (kg)": "{:.1f}",
                "Cost/kg (NOK)": "{:.1f}",
                "Total (NOK)": "{:.0f}",
                "Recycled %": "{:.0f}%",
            }), hide_index=True)

    else:
        st.info("Add BOM data to product config for detailed sourcing analysis.")


# ============================================================
# VIEW: MARKET (REDESIGN)
# ============================================================
elif selected_view == "Market":
    st.header("Market")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For marketing, sales, and business development</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">Customer retention, satisfaction, and subscription tier analysis</p>', unsafe_allow_html=True)

    foundation_banner()

    # ── Market calculations ──
    quality_level = st.session_state.market_quality_level
    pricing_discount = st.session_state.market_pricing_discount / 100
    subscription_tier = st.session_state.market_subscription_tier

    # Customer retention = 50% + (quality - 1) * 9%
    retention_rate = min(100, 50 + (quality_level - 1) * 9)
    satisfaction = min(10, 3 + quality_level * 1.1)

    # Tier multipliers
    tier_config = {
        "Basic": {"price_mult": 0.75, "service_mult": 0.7, "share": 40},
        "Standard": {"price_mult": 1.0, "service_mult": 1.0, "share": 45},
        "Premium": {"price_mult": 1.35, "service_mult": 1.3, "share": 15},
    }
    tier = tier_config[subscription_tier]

    effective_price = lease_price * tier["price_mult"] * (1 - pricing_discount)
    revenue_per_customer_yr = effective_price * 12
    market_penetration = min(25, 5 + quality_level * 2 + pricing_discount * 10)
    exchange_rate = retention_rate * 0.85  # % who actually return product

    # ── Hero: Customer Retention Rate ──
    st.markdown(hero_card(
        "Customer Retention Rate",
        f"{retention_rate:.0f}%",
        subtitle=f"Based on service quality level {quality_level}/6"
    ), unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

    # ── Supporting metrics ──
    s1, s2, s3, s4 = st.columns(4)
    with s1:
        st.markdown(metric_card("Satisfaction", f"{satisfaction:.1f}", "/10"), unsafe_allow_html=True)
    with s2:
        st.markdown(metric_card("Revenue / Customer", sfmt(int(revenue_per_customer_yr)), "NOK/yr", COLORS["positive"]), unsafe_allow_html=True)
    with s3:
        st.markdown(metric_card("Market Penetration", f"{market_penetration:.0f}%", color=COLORS["info"]), unsafe_allow_html=True)
    with s4:
        st.markdown(metric_card("Exchange Rate", f"{exchange_rate:.0f}%", color=COLORS["secondary"]), unsafe_allow_html=True)

    st.markdown("---")

    # ── Chart 1: Quality Impact on Retention ──
    st.subheader("Quality Impact on Retention")

    quality_levels = list(range(1, 7))
    retention_rates = [min(100, 50 + (q - 1) * 9) for q in quality_levels]

    fig_retention = go.Figure()
    fig_retention.add_trace(go.Scatter(
        x=quality_levels, y=retention_rates,
        mode="lines+markers",
        line=dict(color=COLORS["primary"], width=3),
        marker=dict(size=10),
        name="Retention Rate",
    ))
    # Highlight current level
    fig_retention.add_trace(go.Scatter(
        x=[quality_level], y=[retention_rate],
        mode="markers+text",
        marker=dict(size=16, color=COLORS["warning"], symbol="star"),
        text=[f"{retention_rate:.0f}%"],
        textposition="top center",
        name="Current",
    ))
    fig_retention.update_layout(
        xaxis_title="Service Quality Level",
        yaxis_title="Customer Retention (%)",
        xaxis=dict(dtick=1),
        yaxis=dict(range=[40, 105]),
        showlegend=False,
    )
    st.plotly_chart(fig_retention, use_container_width=True)

    st.markdown("---")

    # ── Chart 2: Subscription Tier Distribution ──
    st.subheader("Subscription Tier Distribution")

    tier_names = ["Basic", "Standard", "Premium"]
    tier_shares = [tier_config[t]["share"] for t in tier_names]
    tier_prices = [lease_price * tier_config[t]["price_mult"] for t in tier_names]
    tier_colors = [COLORS["info"], COLORS["primary"], COLORS["warning"]]

    fig_tiers = go.Figure()
    fig_tiers.add_trace(go.Bar(
        x=tier_names,
        y=tier_shares,
        marker_color=tier_colors,
        text=[f"{s}%<br>{sfmt(int(p))} NOK/mo" for s, p in zip(tier_shares, tier_prices)],
        textposition="outside",
    ))
    # Highlight selected tier
    selected_idx = tier_names.index(subscription_tier)
    fig_tiers.add_trace(go.Scatter(
        x=[subscription_tier], y=[tier_shares[selected_idx]],
        mode="markers",
        marker=dict(size=14, color=COLORS["warning"], symbol="diamond"),
        name="Selected",
        showlegend=False,
    ))
    fig_tiers.update_layout(
        yaxis_title="Market Share (%)",
        showlegend=False,
        yaxis=dict(range=[0, 65]),
    )
    st.plotly_chart(fig_tiers, use_container_width=True)

    # Customer value comparison
    st.markdown("---")
    st.subheader("Customer Value Proposition")

    effective_annual = effective_price * 12
    retail = config["product"].get("retail_price", 0)
    use_years = config["design"].get("use_cycle_years", 3)
    annual_ownership = retail / use_years if use_years > 0 else 0

    v1, v2, v3 = st.columns(3)
    with v1:
        st.markdown(metric_card("Retail Price", sfmt(retail), "NOK", COLORS["negative"]), unsafe_allow_html=True)
    with v2:
        st.markdown(metric_card("LiiS Annual Cost", sfmt(int(effective_annual)), "NOK", COLORS["positive"]), unsafe_allow_html=True)
    with v3:
        saving = annual_ownership - effective_annual
        if saving > 0:
            st.markdown(metric_card("Annual Saving", sfmt(int(saving)), "NOK", COLORS["positive"]), unsafe_allow_html=True)
        else:
            st.markdown(metric_card("Premium", sfmt(int(-saving)), "NOK", COLORS["warning"]), unsafe_allow_html=True)


# ============================================================
# VIEW: SUSTAINABILITY (NEW)
# ============================================================
elif selected_view == "Sustainability":
    st.header("Sustainability")
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0; font-size: 1.15rem;">For sustainability officers, ESG reporting, and regulatory compliance</p>', unsafe_allow_html=True)
    st.markdown(f'<p style="color: {COLORS["text_muted"]}; margin: 0 0 1.5rem 0; font-size: 1.15rem;">CO2 savings, circular loop strategies, and regulatory mapping</p>', unsafe_allow_html=True)

    foundation_banner()

    # ── Sustainability calculations ──
    sust_cycles = st.session_state.sust_reuse_cycles
    sust_recycled = st.session_state.sust_recycled_content / 100
    sust_efficiency = st.session_state.sust_production_eff / 100

    portfolio_size = st.session_state.strategy_portfolio

    # CO2 data from config
    co2_mfg = config["environmental"]["co2_manufacturing_kg"]
    co2_refurb = config["environmental"]["co2_refurbishment_kg"]
    co2_logistics = config["environmental"]["co2_logistics_kg"]

    # Linear model: N products, each manufactured new
    linear_co2_total = portfolio_size * sust_cycles * co2_mfg
    linear_cost_total = portfolio_size * sust_cycles * mfg_cost

    # Circular model: 1st life = 100%, reuse = 20%, remanufacture = 40%, recycle = 70%
    # Simplified: first cycle full mfg CO2, subsequent cycles much lower
    circular_co2_per_product = co2_mfg  # first life
    for cycle in range(2, sust_cycles + 1):
        circular_co2_per_product += co2_refurb + co2_logistics  # reuse cycles

    circular_co2_total = portfolio_size * circular_co2_per_product
    circular_cost_total = portfolio_size * (mfg_cost + (sust_cycles - 1) * (avg_refurb_cost + logistics))

    co2_savings_pct = ((linear_co2_total - circular_co2_total) / linear_co2_total * 100) if linear_co2_total > 0 else 0
    cost_savings_pct = ((linear_cost_total - circular_cost_total) / linear_cost_total * 100) if linear_cost_total > 0 else 0
    products_avoided = portfolio_size * (sust_cycles - 1)
    material_recovery = return_rate * (grade_a_pct + grade_b_pct) * 100
    co2_per_product = circular_co2_per_product

    # Loop strategy breakdown
    slowing_savings = co2_mfg * (sust_cycles - 1) * 0.80  # reuse avoids most mfg CO2
    closing_savings = co2_mfg * sust_recycled * 0.30  # recycled content reduces virgin extraction
    narrowing_savings = co2_mfg * sust_efficiency * 0.10  # efficiency reduces waste in production

    # ── Hero: CO2 Savings vs Linear ──
    st.markdown(hero_card(
        "CO2 Savings vs Linear",
        f"{co2_savings_pct:.0f}%",
        subtitle=f"Circular model saves {sfmt(int(linear_co2_total - circular_co2_total))} kg CO2 across portfolio"
    ), unsafe_allow_html=True)

    st.markdown('<div style="margin-top: 1.5rem;"></div>', unsafe_allow_html=True)

    # ── Supporting metrics ──
    s1, s2, s3, s4 = st.columns(4)
    with s1:
        st.markdown(metric_card("Cost Savings vs Linear", f"{cost_savings_pct:.0f}%", color=COLORS["positive"]), unsafe_allow_html=True)
    with s2:
        st.markdown(metric_card("Products Avoided", sfmt(products_avoided), "units", COLORS["positive"]), unsafe_allow_html=True)
    with s3:
        st.markdown(metric_card("Material Recovery", f"{material_recovery:.0f}%", color=COLORS["info"]), unsafe_allow_html=True)
    with s4:
        st.markdown(metric_card("CO2 / Product", f"{co2_per_product:.1f}", "kg", COLORS["secondary"]), unsafe_allow_html=True)

    st.markdown("---")

    # ── Chart 1: Linear vs Circular ──
    st.subheader("Linear vs Circular Model Comparison")

    fig_compare = go.Figure()
    categories = ["CO2 Emissions (kg)", "Total Cost (NOK)"]

    fig_compare.add_trace(go.Bar(
        x=categories,
        y=[linear_co2_total, linear_cost_total],
        name="Linear (buy new each time)",
        marker_color=COLORS["negative"],
        text=[sfmt(int(linear_co2_total)), sfmt(int(linear_cost_total))],
        textposition="outside",
    ))
    fig_compare.add_trace(go.Bar(
        x=categories,
        y=[circular_co2_total, circular_cost_total],
        name="Circular (reuse model)",
        marker_color=COLORS["positive"],
        text=[sfmt(int(circular_co2_total)), sfmt(int(circular_cost_total))],
        textposition="outside",
    ))
    fig_compare.update_layout(
        barmode="group",
        yaxis_title="Value",
        yaxis=dict(separatethousands=True),
    )
    st.plotly_chart(fig_compare, use_container_width=True)

    st.markdown("---")

    # ── Chart 2: CO2 Savings by Loop Strategy (Waterfall) ──
    st.subheader("CO2 Savings by Loop Strategy")
    st.markdown("The three circular strategies: **Slowing** (reuse), **Closing** (recycled content), **Narrowing** (efficiency).")

    fig_waterfall = go.Figure(go.Waterfall(
        orientation="v",
        measure=["absolute", "relative", "relative", "relative", "total"],
        x=["Linear Baseline", "Slowing (Reuse)", "Closing (Recycling)", "Narrowing (Efficiency)", "Circular Total"],
        y=[co2_mfg * sust_cycles, -slowing_savings, -closing_savings, -narrowing_savings, 0],
        text=[f"{co2_mfg * sust_cycles:.1f}", f"-{slowing_savings:.1f}", f"-{closing_savings:.1f}", f"-{narrowing_savings:.1f}",
              f"{co2_mfg * sust_cycles - slowing_savings - closing_savings - narrowing_savings:.1f}"],
        textposition="outside",
        connector={"line": {"color": COLORS["border"]}},
        decreasing={"marker": {"color": COLORS["positive"]}},
        increasing={"marker": {"color": COLORS["negative"]}},
        totals={"marker": {"color": COLORS["info"]}},
    ))
    fig_waterfall.update_layout(
        yaxis_title="CO2 per Product (kg)",
        showlegend=False,
    )
    st.plotly_chart(fig_waterfall, use_container_width=True)

    st.caption(f"Per-product CO2: Linear = {co2_mfg * sust_cycles:.1f} kg, Circular = {co2_per_product:.1f} kg")

    st.markdown("---")

    # ── ESPR / EPR Regulatory Mapping ──
    st.subheader("ESPR / EPR Regulatory Mapping")
    st.markdown("How LiiS circular model maps to upcoming EU regulations.")

    st.markdown(f"""
    | Regulation | Requirement | LiiS Circular Model |
    |------------|-------------|---------------------|
    | **ESPR** (Ecodesign) | Product durability & repairability | {sust_cycles} reuse cycles, modular design |
    | **ESPR** (Digital Product Passport) | Material traceability | BOM tracking, {sust_recycled*100:.0f}% recycled content |
    | **EPR** (Extended Producer Responsibility) | End-of-life collection | {return_rate*100:.0f}% return rate, grade-based processing |
    | **EU Taxonomy** | Circular economy contribution | {co2_savings_pct:.0f}% CO2 reduction vs linear |
    | **CSRD** (Sustainability Reporting) | Environmental impact disclosure | Full lifecycle tracking per product |
    """)

    # Assumptions log
    with st.expander("Simulation Assumptions"):
        st.markdown(f"""
        **CO2 Model:**
        - Manufacturing: {co2_mfg} kg CO2 per new product
        - Refurbishment: {co2_refurb} kg CO2 per cycle
        - Logistics: {co2_logistics} kg CO2 per cycle
        - Reuse cycles avoid ~80% of manufacturing CO2
        - Recycled content reduces virgin extraction CO2 by ~30%
        - Production efficiency reduces waste CO2 by ~10%

        **Cost Model:**
        - Linear: {sust_cycles} x manufacturing cost ({sfmt(mfg_cost)} NOK)
        - Circular: 1x manufacturing + {sust_cycles - 1}x refurbishment ({sfmt(avg_refurb_cost)} NOK) + logistics ({sfmt(logistics)} NOK)

        *These are simulated estimates for decision support, not audited figures.*
        """)