oci-deal-accelerator/tools/oci_bizcase_gen.py

#!/usr/bin/env python3
"""
OCI Deal Accelerator — Business Case Deck Generator (.pptx)

Produces an 8-10 slide business case deck using the Oracle FY26 official
PowerPoint template layouts. Target audience: customer CxO / decision-makers.

Usage:
    python oci_bizcase_gen.py --spec business-case.yaml --output business-case.pptx

Or import and use programmatically:
    from oci_bizcase_gen import BusinessCaseDeckGenerator
    gen = BusinessCaseDeckGenerator.from_spec(spec)
    gen.save("business-case.pptx")
"""

import yaml
import argparse
import re
from datetime import datetime
from pathlib import Path
from typing import Optional, List, Dict

from pptx.util import Inches, Pt
from pptx.dml.color import RGBColor
from pptx.enum.text import PP_ALIGN
from pptx.enum.shapes import MSO_SHAPE

try:
    from oci_pptx_base import Colors, Layouts, OraclePresBase
except ModuleNotFoundError:
    from tools.oci_pptx_base import Colors, Layouts, OraclePresBase


# ============================================================
# Defensive input helpers
# ============================================================

def pick(mapping: dict, *keys, default=""):
    """Return the first non-empty value for any of the provided keys."""
    if not isinstance(mapping, dict):
        return default
    for key in keys:
        if key in mapping:
            value = mapping.get(key)
            if value is not None:
                return value
    return default


def pick_list(mapping: dict, *keys):
    """Return the first list-like field normalized to a list."""
    if not isinstance(mapping, dict):
        return []
    for key in keys:
        if key in mapping:
            value = mapping.get(key)
            if value is None:
                return []
            if isinstance(value, list):
                return value
            return [value]
    return []


def _timeline_to_weeks(text: str) -> int | None:
    """Parse a simple duration phrase like '12 weeks' or '6 months'."""
    if not text:
        return None
    value = str(text).lower()
    match = re.search(r"(\d+)\s*(week|weeks|month|months)", value)
    if not match:
        return None
    amount = int(match.group(1))
    unit = match.group(2)
    return amount * 4 if unit.startswith("month") else amount


def _extract_business_case_text(bc: dict) -> str:
    parts = [
        pick(bc, "executive_summary", "summary"),
        pick(bc, "primary_driver", "main_driver"),
    ]
    drivers = bc.get("drivers", {})
    if isinstance(drivers, dict):
        parts.extend([
            pick(drivers, "primary", "primary_driver", "main_driver"),
            pick(drivers, "urgency", "why_now"),
        ])
        coi = drivers.get("cost_of_inaction", {}) or {}
        if isinstance(coi, dict):
            parts.extend(coi.values())
    return " ".join(str(p) for p in parts if p)


def _infer_driver_headline(text: str) -> str:
    lowered = text.lower()
    if any(token in lowered for token in ("budget", "cost", "tco", "license", "refresh")):
        return "Reduce cost and avoid infrastructure refresh"
    if any(token in lowered for token in ("dr", "disaster recovery", "resilien", "rto", "rpo")):
        return "Improve resilience and business continuity"
    if any(token in lowered for token in ("pci", "regulator", "compliance", "data residency", "sovereignty")):
        return "Address compliance and sovereignty requirements"
    return "Modernize the platform on OCI"


def _infer_driver_objective(text: str) -> str:
    """Return a noun phrase suitable for recommendation prose."""
    lowered = text.lower()
    if any(token in lowered for token in ("budget", "cost", "tco", "license", "refresh")):
        return "the cost-reduction and refresh-avoidance case"
    if any(token in lowered for token in ("dr", "disaster recovery", "resilien", "rto", "rpo")):
        return "the resilience and business-continuity posture"
    if any(token in lowered for token in ("pci", "regulator", "compliance", "data residency", "sovereignty")):
        return "the compliance and sovereignty position"
    return "the OCI modernization approach"


def _infer_business_case_drivers(text: str) -> dict:
    headline = _infer_driver_headline(text)
    urgency = "Use the current planning window to validate scope, commercials, and delivery readiness."
    if _timeline_to_weeks(text):
        urgency = f"Align the case with the stated delivery window ({_timeline_to_weeks(text)} weeks)."
    return {
        "primary": headline,
        "urgency": urgency,
        "cost_of_inaction": {
            "financial": "Continuing with the current platform preserves avoidable run costs and refresh exposure.",
            "operational": "The delivery team keeps spending time on manual operations instead of modernization work.",
            "strategic": "Delaying the decision extends technical debt and slows business change.",
        },
    }


def _infer_business_case_risks(text: str) -> dict:
    lowered = text.lower()
    migration = [
        {
            "risk": "Migration scope may be larger than the initial discovery captured.",
            "mitigation": "Baseline applications, data stores, and dependencies before locking the plan.",
        },
        {
            "risk": "Operating model changes may require team enablement before go-live.",
            "mitigation": "Define the target RACI and training plan during design.",
        },
    ]
    if any(token in lowered for token in ("dr", "disaster recovery", "rto", "rpo")):
        migration.append({
            "risk": "Resilience objectives may require rehearsal and explicit runbooks.",
            "mitigation": "Schedule failover validation before production cutover.",
        })
    do_nothing = [
        {
            "risk": "Technical debt and platform constraints continue to accumulate.",
            "impact": "Higher delivery risk and slower response to business demand.",
        },
        {
            "risk": "Commercial and capacity assumptions remain unvalidated.",
            "impact": "Procurement or renewal decisions may be made without a current baseline.",
        },
    ]
    return {
        "migration_risks": migration[:4],
        "do_nothing_risks": do_nothing[:4],
    }


def _infer_business_case_roadmap(text: str) -> dict:
    total_weeks = _timeline_to_weeks(text)
    if total_weeks and total_weeks >= 6:
        define = max(1, round(total_weeks * 0.25))
        design = max(1, round(total_weeks * 0.35))
        deliver = max(1, total_weeks - define - design)
        total_duration = f"{total_weeks} weeks"
    else:
        define, design, deliver = 2, 4, 6
        total_duration = "12 weeks (to validate)"
    return {
        "total_duration": total_duration,
        "phases": [
            {
                "name": "Define",
                "duration": f"{define} weeks",
                "deliverables": ["Scope baseline", "Business case validation"],
                "milestones": ["Stakeholder alignment"],
            },
            {
                "name": "Design",
                "duration": f"{design} weeks",
                "deliverables": ["Target architecture", "Security and operating model"],
                "milestones": ["Design sign-off"],
            },
            {
                "name": "Deliver",
                "duration": f"{deliver} weeks",
                "deliverables": ["Migration execution", "Cutover and stabilization"],
                "milestones": ["Go-live readiness"],
            },
        ],
    }


def _infer_business_case_recommendation(text: str) -> dict:
    objective = _infer_driver_objective(text)
    return {
        "summary": f"Proceed to detailed design on OCI to validate {objective} with customer-specific sizing and commercials.",
        "next_steps": [
            "Confirm scope, current-state baseline, and success criteria.",
            "Validate commercials, licensing assumptions, and target delivery model.",
            "Run a design workshop and prepare the first migration wave.",
        ],
    }


def _enrich_sparse_business_case(spec: dict) -> dict:
    """Fill safe narrative sections so sparse business cases still render professionally."""
    if not isinstance(spec, dict):
        return spec
    bc = spec.get("business_case", spec)
    if not isinstance(bc, dict):
        return spec

    text = _extract_business_case_text(bc)
    if not text.strip():
        return spec

    enriched_bc = dict(bc)
    if "drivers" not in enriched_bc:
        enriched_bc["drivers"] = _infer_business_case_drivers(text)
    if "risks" not in enriched_bc:
        enriched_bc["risks"] = _infer_business_case_risks(text)
    if "roadmap" not in enriched_bc:
        enriched_bc["roadmap"] = _infer_business_case_roadmap(text)
    if "recommendation" not in enriched_bc:
        enriched_bc["recommendation"] = _infer_business_case_recommendation(text)

    if "business_case" in spec:
        enriched = dict(spec)
        enriched["business_case"] = enriched_bc
        return enriched
    return enriched_bc


# ============================================================
# Business Case Deck Generator
# ============================================================

class BusinessCaseDeckGenerator(OraclePresBase):
    """Generate business case decks using Oracle FY26 template layouts."""

    # Use Teal accent for business case slides (finance / CxO audience)
    TITLE_ACCENT_COLOR = Colors.TEAL

    # ================================================================
    # Slide Methods
    # ================================================================

    def add_cover_slide(self, customer: str, subtitle: str = "",
                        prepared_by: str = "", date: str = ""):
        """Slide 1: Cover using Dark Title_Pillar layout."""
        slide = self._add_layout_slide(Layouts.COVER_DARK)
        self._set_placeholder(slide, 0, customer)  # Title
        self._set_placeholder(slide, 33, subtitle or "Business Case for Oracle Cloud Infrastructure")
        date_str = date or datetime.now().strftime("%B %Y")
        self._set_placeholder(slide, 35, date_str)
        if prepared_by:
            self._set_placeholder(slide, 34, f"Prepared by: {prepared_by}")

    def add_executive_summary_slide(self, statement: str):
        """Slide 2: Executive Summary — controlled typography on blank slide."""
        slide = self._add_blank_slide()

        self._add_title_bar(slide, "Executive Summary")

        # Body — large enough to read, small enough to fit the paragraph
        body_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.3), Inches(11.7), Inches(4.5))
        tf = body_box.text_frame
        tf.word_wrap = True
        p = tf.paragraphs[0]
        p.text = statement
        p.font.size = Pt(18)
        p.font.name = self.FONT
        p.font.color.rgb = Colors.PRIMARY_TEXT
        p.space_after = Pt(6)

    def add_business_drivers_slide(self, drivers: list):
        """Slide 3: Business Drivers — numbered cards on blank slide.

        drivers: list of up to 3 strings, each a driver statement (may include newline
        separating a bold headline from detail text).
        """
        slide = self._add_blank_slide()

        self._add_title_bar(slide, "Business Drivers")

        card_colors = [Colors.TEAL, Colors.BURNT_ORANGE, Colors.FOREST]
        card_y_start = Inches(1.3)
        available_h = Inches(5.8)
        n = min(len(drivers), 3)
        card_h = available_h / n if n else available_h
        card_h = min(card_h, Inches(2.1))

        for i, driver in enumerate(drivers[:3]):
            color = card_colors[i % len(card_colors)]
            y = card_y_start + i * card_h

            # Left accent bar
            accent = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), y + Inches(0.1), Inches(0.08), card_h - Inches(0.2))
            accent.fill.solid()
            accent.fill.fore_color.rgb = color
            accent.line.fill.background()

            # Number badge
            self._add_textbox(
                slide, Inches(1.05), y + Inches(0.12), Inches(0.5), Inches(0.45),
                text=f"0{i+1}", font_size=18, bold=True, color=color,
            )

            # Split driver into headline + detail (split on \n if present)
            parts = driver.split("\n", 1)
            headline = parts[0].strip()
            detail = parts[1].strip() if len(parts) > 1 else ""

            # Headline
            self._add_textbox(
                slide, Inches(1.6), y + Inches(0.1), Inches(11.0), Inches(0.5),
                text=headline, font_size=15, bold=True, color=Colors.PRIMARY_TEXT,
            )
            # Detail
            if detail:
                self._add_textbox(
                    slide, Inches(1.6), y + Inches(0.6), Inches(11.0), card_h - Inches(0.75),
                    text=detail, font_size=13, color=Colors.SECONDARY_TEXT,
                )

    def add_tco_slide(self, tco: dict):
        """Slide 4: TCO Comparison — table on blank slide.

        tco: dict from business-case.yaml with current_state and proposed_oci.
        """
        slide = self._add_blank_slide()

        self._add_title_bar(slide, "Total Cost of Ownership")

        # Subtitle
        horizon = tco.get("horizon_years", 3)
        self._add_textbox(
            slide, Inches(0.8), Inches(1.1), Inches(11), Inches(0.4),
            text=f"{horizon}-Year Comparison  |  Current State vs Oracle Cloud Infrastructure",
            font_size=13, color=Colors.TEAL, bold=True,
        )

        current = tco.get("current_state", {})
        proposed = tco.get("proposed_oci", {})
        savings = tco.get("savings", {})

        rows_data = [
            ("Infrastructure", current.get("annual_infrastructure", 0), proposed.get("annual_cloud_consumption", 0)),
            ("Licensing / Support", current.get("annual_licensing", 0), proposed.get("annual_licensing", 0)),
            ("Operations (People)", current.get("annual_operations", 0), proposed.get("annual_operations", 0)),
            ("Downtime Cost", current.get("annual_downtime_cost", 0), proposed.get("annual_downtime_cost", 0)),
            ("Compliance", current.get("annual_compliance_cost", 0), proposed.get("annual_compliance_cost", 0)),
        ]
        # Filter out zero rows
        rows_data = [(n, c, o) for n, c, o in rows_data if c or o]

        # Add migration one-time
        migration = proposed.get("migration_one_time", 0)

        num_rows = len(rows_data) + 3  # header + rows + annual total + horizon total
        table = self._add_table(
            slide, num_rows, 4,
            Inches(0.8), Inches(1.6),
            Inches(11.7), Inches(0.42 * num_rows),
        )
        table.columns[0].width = Inches(3.5)
        table.columns[1].width = Inches(2.7)
        table.columns[2].width = Inches(2.7)
        table.columns[3].width = Inches(2.8)

        # Header
        for j, h in enumerate(["Cost Category", "Current (Annual)", "OCI (Annual)", "Savings"]):
            self._style_table_cell(
                table.cell(0, j), h, font_size=11, bold=True,
                color=Colors.WHITE, bg_color=Colors.TEAL,
                alignment=PP_ALIGN.CENTER if j > 0 else PP_ALIGN.LEFT,
            )

        # Data rows
        for i, (name, curr, oci) in enumerate(rows_data):
            row = i + 1
            bg = Colors.TABLE_ALT_ROW if row % 2 == 0 else None
            curr_val = curr if isinstance(curr, (int, float)) else 0
            oci_val = oci if isinstance(oci, (int, float)) else 0
            save_val = curr_val - oci_val
            self._style_table_cell(table.cell(row, 0), name, font_size=10, bg_color=bg)
            self._style_table_cell(table.cell(row, 1), f"${curr_val:,.0f}", font_size=10, bg_color=bg, alignment=PP_ALIGN.RIGHT)
            self._style_table_cell(table.cell(row, 2), f"${oci_val:,.0f}", font_size=10, bg_color=bg, alignment=PP_ALIGN.RIGHT)
            save_color = Colors.SUCCESS if save_val > 0 else Colors.ERROR
            self._style_table_cell(table.cell(row, 3), f"${save_val:,.0f}", font_size=10, bold=True, color=save_color, bg_color=bg, alignment=PP_ALIGN.RIGHT)

        # Annual total row
        total_row = len(rows_data) + 1
        ann_current = current.get("total_annual", 0) or sum(r[1] for r in rows_data if isinstance(r[1], (int, float)))
        ann_oci = proposed.get("total_annual", 0) or sum(r[2] for r in rows_data if isinstance(r[2], (int, float)))
        ann_savings = savings.get("annual", 0) or (ann_current - ann_oci)
        self._style_table_cell(table.cell(total_row, 0), "TOTAL ANNUAL", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL)
        self._style_table_cell(table.cell(total_row, 1), f"${ann_current:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.RIGHT)
        self._style_table_cell(table.cell(total_row, 2), f"${ann_oci:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.RIGHT)
        self._style_table_cell(table.cell(total_row, 3), f"${ann_savings:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.TEAL, alignment=PP_ALIGN.RIGHT)

        # Horizon total row
        h_row = total_row + 1
        h_current = current.get("total_over_horizon", 0) or (ann_current * horizon)
        h_oci = proposed.get("total_over_horizon", 0) or (ann_oci * horizon + migration)
        h_savings = savings.get("over_horizon", 0) or (h_current - h_oci)
        pct = savings.get("percentage", 0) or (h_savings / h_current * 100 if h_current else 0)
        self._style_table_cell(table.cell(h_row, 0), f"TOTAL {horizon}-YEAR", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG)
        self._style_table_cell(table.cell(h_row, 1), f"${h_current:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT)
        self._style_table_cell(table.cell(h_row, 2), f"${h_oci:,.0f}", font_size=11, bold=True, color=Colors.WHITE, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT)
        self._style_table_cell(table.cell(h_row, 3), f"${h_savings:,.0f} ({pct:.0f}%)", font_size=11, bold=True, color=Colors.GOLD, bg_color=Colors.DARK_BG, alignment=PP_ALIGN.RIGHT)

        # Migration note
        if migration:
            note_y = Inches(1.6) + Inches(0.42 * num_rows) + Inches(0.15)
            self._add_textbox(
                slide, Inches(0.8), note_y, Inches(11), Inches(0.3),
                text=f"* Includes one-time migration investment of ${migration:,.0f} in Year 1",
                font_size=9, italic=True, color=Colors.SECONDARY_TEXT,
            )

        # Assumptions
        assumptions = tco.get("assumptions", [])
        if assumptions:
            a_y = Inches(1.6) + Inches(0.42 * num_rows) + Inches(0.45)
            self._add_textbox(
                slide, Inches(0.8), a_y, Inches(11), Inches(0.25),
                text="Assumptions:", font_size=9, bold=True, color=Colors.SECONDARY_TEXT,
            )
            for idx, a in enumerate(assumptions[:4]):
                self._add_textbox(
                    slide, Inches(1.0), a_y + Inches(0.25 + idx * 0.22),
                    Inches(11), Inches(0.22),
                    text=f"• {a}", font_size=8, italic=True, color=Colors.SECONDARY_TEXT,
                )

    def add_roi_slide(self, roi: dict, headline: str = ""):
        """Slide 5: ROI — centered big number + 3 supporting metrics."""
        slide = self._add_blank_slide()

        self._add_title_bar(slide, "Return on Investment")

        # Big centered ROI number
        pct = roi.get("three_year_roi_pct", 0)
        metric_text = headline or (f"{pct:.0f}%" if pct else "—")
        big_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.4), Inches(11.7), Inches(2.4))
        big_box.text_frame.word_wrap = False
        p = big_box.text_frame.paragraphs[0]
        p.text = metric_text
        p.font.size = Pt(96)
        p.font.bold = True
        p.font.name = self.FONT_HEADING
        p.font.color.rgb = Colors.TEAL
        p.alignment = PP_ALIGN.CENTER

        # Label under big number
        self._add_textbox(
            slide, Inches(0.8), Inches(3.75), Inches(11.7), Inches(0.4),
            text="3-Year Return on Investment", font_size=16,
            color=Colors.SECONDARY_TEXT, alignment=PP_ALIGN.CENTER,
        )

        # 3 supporting metric boxes
        payback = roi.get("payback_months", 0)
        investment = roi.get("total_investment", 0)
        benefit = roi.get("annual_net_benefit", 0)
        metrics = []
        if payback:
            metrics.append((f"{payback} months", "Payback Period"))
        if investment:
            metrics.append((f"${investment:,.0f}", "Total Investment"))
        if benefit:
            metrics.append((f"${benefit:,.0f}/yr", "Annual Net Benefit"))

        box_w = Inches(3.5)
        gap = Inches(0.45)
        total_w = box_w * len(metrics) + gap * (len(metrics) - 1)
        x_start = (Inches(13.33) - total_w) / 2
        y_box = Inches(4.4)

        for j, (value, label) in enumerate(metrics):
            x = x_start + j * (box_w + gap)
            # Background
            bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, y_box, box_w, Inches(1.4))
            bg.fill.solid()
            bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW
            bg.line.color.rgb = Colors.MUTED_TEAL

            # Value
            self._add_textbox(
                slide, x, y_box + Inches(0.15), box_w, Inches(0.7),
                text=value, font_size=26, bold=True, color=Colors.TEAL,
                alignment=PP_ALIGN.CENTER,
            )
            # Label
            self._add_textbox(
                slide, x, y_box + Inches(0.85), box_w, Inches(0.45),
                text=label, font_size=11, color=Colors.SECONDARY_TEXT,
                alignment=PP_ALIGN.CENTER,
            )

    def add_value_drivers_slide(self, drivers: list):
        """Slide 6: Value Drivers — 4 categories on blank slide.

        drivers: list of {"category": str, "title": str, "description": str, "quantified": str}
        """
        slide = self._add_blank_slide()

        self._add_title_bar(slide, "Value Drivers")

        # 4 value cards in a 2x2 grid
        card_colors = [Colors.TEAL, Colors.FOREST, Colors.BURNT_ORANGE, Colors.ORACLE_RED]
        positions = [
            (Inches(0.8), Inches(1.5)),   # top-left
            (Inches(6.8), Inches(1.5)),   # top-right
            (Inches(0.8), Inches(4.3)),   # bottom-left
            (Inches(6.8), Inches(4.3)),   # bottom-right
        ]
        card_w, card_h = Inches(5.5), Inches(2.5)

        for i, driver in enumerate(drivers[:4]):
            x, y = positions[i]
            color = card_colors[i % len(card_colors)]

            # Color accent bar
            bar = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, y, Inches(0.08), card_h)
            bar.fill.solid()
            bar.fill.fore_color.rgb = color
            bar.line.fill.background()

            # Title
            title = driver.get("title", driver.get("category", "").replace("_", " ").title())
            self._add_textbox(
                slide, x + Inches(0.25), y + Inches(0.1),
                card_w - Inches(0.3), Inches(0.4),
                text=title, font_size=16, bold=True, color=color,
            )

            # Quantified value (big)
            quantified = driver.get("quantified", "")
            if quantified:
                self._add_textbox(
                    slide, x + Inches(0.25), y + Inches(0.55),
                    card_w - Inches(0.3), Inches(0.5),
                    text=quantified, font_size=22, bold=True, color=Colors.PRIMARY_TEXT,
                )

            # Description
            desc = driver.get("description", "")
            if desc:
                self._add_textbox(
                    slide, x + Inches(0.25), y + Inches(1.2),
                    card_w - Inches(0.3), Inches(1.0),
                    text=desc, font_size=11, color=Colors.SECONDARY_TEXT,
                )

    def add_risk_slide(self, migration_risks: list, do_nothing_risks: list):
        """Slide 7: Risk Assessment — two-column table layout."""
        slide = self._add_blank_slide()

        self._add_title_bar(slide, "Risk Assessment")

        col_w = Inches(5.6)
        col_gap = Inches(0.5)
        left_x = Inches(0.8)
        right_x = left_x + col_w + col_gap
        header_y = Inches(1.2)
        content_start_y = Inches(1.75)
        row_h = Inches(0.8)          # height per risk block (title + detail)
        slide_h = Inches(7.1)

        # Stretch rows to fill available slide height
        n_rows = max(len(migration_risks[:5]), len(do_nothing_risks[:5]))
        if n_rows > 0:
            available = slide_h - content_start_y
            row_h = min(Inches(1.8), available / n_rows)

        # Column header backgrounds
        for x, color, label in [
            (left_x,  Colors.TEAL,  "✓  Migration Risks (Mitigated)"),
            (right_x, Colors.ERROR, "⚠  Risks of Inaction"),
        ]:
            bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, x, header_y, col_w, Inches(0.45))
            bg.fill.solid()
            bg.fill.fore_color.rgb = color
            bg.line.fill.background()
            self._add_textbox(
                slide, x + Inches(0.15), header_y + Inches(0.05), col_w - Inches(0.2), Inches(0.38),
                text=label, font_size=13, bold=True, color=Colors.WHITE,
            )

        # Left column: migration risks
        for i, risk in enumerate(migration_risks[:5]):
            r_text = risk.get("risk", str(risk)) if isinstance(risk, dict) else str(risk)
            mitigation = risk.get("mitigation", "") if isinstance(risk, dict) else ""
            y = content_start_y + i * row_h

            # Alternating row background
            if i % 2 == 0:
                row_bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, left_x, y, col_w, row_h)
                row_bg.fill.solid()
                row_bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW
                row_bg.line.fill.background()

            self._add_textbox(
                slide, left_x + Inches(0.15), y + Inches(0.07), col_w - Inches(0.25), Inches(0.4),
                text=f"• {r_text}", font_size=12, bold=True, color=Colors.PRIMARY_TEXT,
            )
            if mitigation:
                self._add_textbox(
                    slide, left_x + Inches(0.25), y + Inches(0.45), col_w - Inches(0.35), row_h - Inches(0.48),
                    text=f"Mitigation: {mitigation}", font_size=11,
                    italic=True, color=Colors.SECONDARY_TEXT,
                )

        # Right column: do-nothing risks
        for i, risk in enumerate(do_nothing_risks[:5]):
            r_text = risk.get("risk", str(risk)) if isinstance(risk, dict) else str(risk)
            impact = risk.get("impact", "") if isinstance(risk, dict) else ""
            timeline = risk.get("timeline", "") if isinstance(risk, dict) else ""
            y = content_start_y + i * row_h

            if i % 2 == 0:
                row_bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, right_x, y, col_w, row_h)
                row_bg.fill.solid()
                row_bg.fill.fore_color.rgb = RGBColor(0xFF, 0xF3, 0xF3)
                row_bg.line.fill.background()

            self._add_textbox(
                slide, right_x + Inches(0.15), y + Inches(0.07), col_w - Inches(0.25), Inches(0.4),
                text=f"• {r_text}", font_size=12, bold=True, color=Colors.ERROR,
            )
            detail_parts = []
            if impact:
                detail_parts.append(f"Impact: {impact}")
            if timeline:
                detail_parts.append(f"By: {timeline}")
            if detail_parts:
                self._add_textbox(
                    slide, right_x + Inches(0.25), y + Inches(0.45), col_w - Inches(0.35), row_h - Inches(0.48),
                    text="  |  ".join(detail_parts), font_size=10,
                    italic=True, color=Colors.SECONDARY_TEXT,
                )

    def add_roadmap_slide(self, phases: list, total_duration: str = ""):
        """Slide 8: Implementation Roadmap — timeline bars filling the slide."""
        slide = self._add_blank_slide()

        title = "Implementation Roadmap"
        if total_duration:
            title += f"  —  {total_duration}"
        self._add_title_bar(slide, title)

        phase_colors = [Colors.TEAL, Colors.BURNT_ORANGE, Colors.FOREST, Colors.ORACLE_RED]
        content_start = Inches(1.25)
        available_h = Inches(5.9)
        n = min(len(phases), 4)
        row_h = available_h / n if n else available_h

        bar_left = Inches(3.6)
        bar_w = Inches(9.1)
        label_w = Inches(2.6)

        for i, phase in enumerate(phases[:4]):
            color = phase_colors[i % len(phase_colors)]
            y = content_start + i * row_h
            name = pick(phase, "name", "title", default=f"Phase {i+1}")
            duration = pick(phase, "duration", "weeks")
            deliverables = pick_list(phase, "deliverables", "outputs")
            quick_wins = pick_list(phase, "quick_wins", "milestones")

            # Alternating row background
            if i % 2 == 0:
                bg = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), y, Inches(12.0), row_h - Inches(0.08))
                bg.fill.solid()
                bg.fill.fore_color.rgb = Colors.TABLE_ALT_ROW
                bg.line.fill.background()

            # Phase number circle accent
            dot = slide.shapes.add_shape(MSO_SHAPE.OVAL, Inches(0.82), y + (row_h - Inches(0.38)) / 2, Inches(0.38), Inches(0.38))
            dot.fill.solid()
            dot.fill.fore_color.rgb = color
            dot.line.fill.background()
            dot.text_frame.paragraphs[0].text = str(i + 1)
            dot.text_frame.paragraphs[0].font.size = Pt(11)
            dot.text_frame.paragraphs[0].font.bold = True
            dot.text_frame.paragraphs[0].font.color.rgb = Colors.WHITE
            dot.text_frame.paragraphs[0].font.name = self.FONT
            dot.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER

            # Phase name
            self._add_textbox(
                slide, Inches(1.35), y + Inches(0.08), label_w, Inches(0.45),
                text=name, font_size=14, bold=True, color=color,
            )

            # Duration bar
            bar_h = Inches(0.42)
            bar_y = y + (row_h - bar_h) / 2
            bar = slide.shapes.add_shape(MSO_SHAPE.ROUNDED_RECTANGLE, bar_left, bar_y, bar_w * 0.55, bar_h)
            bar.fill.solid()
            bar.fill.fore_color.rgb = color
            bar.line.fill.background()
            bar.text_frame.paragraphs[0].text = duration
            bar.text_frame.paragraphs[0].font.size = Pt(12)
            bar.text_frame.paragraphs[0].font.bold = True
            bar.text_frame.paragraphs[0].font.color.rgb = Colors.WHITE
            bar.text_frame.paragraphs[0].font.name = self.FONT
            bar.text_frame.paragraphs[0].alignment = PP_ALIGN.CENTER

            # Deliverables — listed to the right of the bar
            items = quick_wins + deliverables
            if items:
                items_text = "  •  ".join(items[:3])
                self._add_textbox(
                    slide, bar_left + bar_w * 0.57, bar_y - Inches(0.02),
                    bar_w * 0.43, bar_h + Inches(0.05),
                    text=items_text, font_size=11, color=Colors.SECONDARY_TEXT,
                )

    def add_recommendation_slide(self, summary: str, next_steps: list = None):
        """Slide 9: Recommendation — dark blank slide with controlled fonts."""
        slide = self._add_blank_slide(dark=True)

        # "Recommendation" label in gold
        self._add_textbox(
            slide, Inches(0.8), Inches(0.45), Inches(11.7), Inches(0.5),
            text="Our Recommendation", font_size=13, bold=True,
            color=Colors.GOLD, font_name=self.FONT,
        )

        # Gold accent bar
        acc = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), Inches(1.0), Inches(11.7), Inches(0.05))
        acc.fill.solid()
        acc.fill.fore_color.rgb = Colors.GOLD
        acc.line.fill.background()

        # Main recommendation statement — 20pt, white, readable
        rec_box = slide.shapes.add_textbox(Inches(0.8), Inches(1.2), Inches(11.7), Inches(2.2))
        tf = rec_box.text_frame
        tf.word_wrap = True
        p = tf.paragraphs[0]
        p.text = summary
        p.font.size = Pt(20)
        p.font.bold = True
        p.font.name = self.FONT_HEADING
        p.font.color.rgb = Colors.WHITE

        # Next steps section
        if next_steps:
            self._add_textbox(
                slide, Inches(0.8), Inches(3.6), Inches(4.0), Inches(0.4),
                text="NEXT STEPS", font_size=11, bold=True,
                color=Colors.GOLD,
            )
            # Divider
            div = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, Inches(0.8), Inches(4.05), Inches(11.7), Inches(0.03))
            div.fill.solid()
            div.fill.fore_color.rgb = RGBColor(0x55, 0x50, 0x4C)
            div.line.fill.background()

            y = Inches(4.15)
            for i, step in enumerate(next_steps[:4]):
                action = step.get("action", str(step)) if isinstance(step, dict) else str(step)
                owner = step.get("owner", "") if isinstance(step, dict) else ""
                deadline = step.get("deadline", "") if isinstance(step, dict) else ""

                # Number
                self._add_textbox(
                    slide, Inches(0.8), y, Inches(0.4), Inches(0.5),
                    text=str(i + 1), font_size=13, bold=True, color=Colors.GOLD,
                )
                # Action text
                action_text = action
                meta_parts = []
                if owner:
                    meta_parts.append(owner)
                if deadline:
                    meta_parts.append(deadline)
                meta = f"  [{' · '.join(meta_parts)}]" if meta_parts else ""
                self._add_textbox(
                    slide, Inches(1.25), y, Inches(11.2), Inches(0.5),
                    text=action_text + meta, font_size=13, color=Colors.WHITE,
                )
                y += Inches(0.6)

    # ================================================================
    # Build from YAML spec
    # ================================================================

    @classmethod
    def from_spec(cls, spec: dict, template: Optional[str] = None) -> "BusinessCaseDeckGenerator":
        """Build a complete business case deck from a YAML specification."""
        spec = _enrich_sparse_business_case(spec)
        bc = spec.get("business_case", spec)  # Support both wrapped and unwrapped
        gen = cls(template=template)

        # Slide 1: Cover
        gen.add_cover_slide(
            customer=pick(bc, "customer_name", "customer"),
            subtitle="Business Case for Oracle Cloud Infrastructure",
            prepared_by=pick(bc, "prepared_by", "author"),
            date=pick(bc, "date", "generated_on"),
        )

        # Slide 2: Executive Summary
        exec_summary = bc.get("executive_summary", "")
        if exec_summary:
            gen.add_executive_summary_slide(exec_summary)

        # Slide 3: Business Drivers
        drivers_data = bc.get("drivers", {})
        # Accept primary_driver at the top level as well (common user shape)
        top_primary = pick(bc, "primary_driver", "main_driver")
        # Accept a plain string or list for drivers
        if isinstance(drivers_data, str):
            drivers_data = {"primary": drivers_data}
        elif isinstance(drivers_data, list):
            drivers_data = {"items": drivers_data}
        elif not isinstance(drivers_data, dict):
            drivers_data = {}

        if drivers_data or top_primary:
            driver_statements = []
            primary = pick(drivers_data, "primary", "primary_driver", "main_driver") or top_primary
            urgency = pick(drivers_data, "urgency", "why_now")
            coi = drivers_data.get("cost_of_inaction", {}) or {}

            if primary:
                primary_text = primary if isinstance(primary, str) else str(primary)
                # Only rewrite snake_case enum tokens ("compliance_driven"); leave natural
                # language intact so values like "Soberanía de datos + compliance regulatorio"
                # render verbatim.
                if "_" in primary_text and " " not in primary_text and len(primary_text) <= 40:
                    headline = f"Primary Driver: {primary_text.replace('_', ' ').title()}"
                else:
                    headline = primary_text
                driver_statements.append(f"{headline}\n{urgency}" if urgency else headline)

            # Spec-provided additional cards take precedence over the inaction fallback
            extra_items = pick_list(drivers_data, "items", "additional", "secondary", "cards")
            for item in extra_items:
                if isinstance(item, str) and item.strip():
                    driver_statements.append(item.strip())
                elif isinstance(item, dict):
                    label = pick(item, "label", "headline", "title", "name")
                    desc = pick(item, "detail", "description", "text", "body")
                    if label and desc:
                        driver_statements.append(f"{label}\n{desc}")
                    elif label or desc:
                        driver_statements.append(label or desc)

            if not extra_items:
                financial = pick(coi, "financial")
                operational = pick(coi, "operational")
                strategic = pick(coi, "strategic")
                if financial:
                    driver_statements.append(f"Financial Impact of Inaction\n{financial}")
                if operational:
                    driver_statements.append(f"Operational Impact\n{operational}")
                elif strategic:
                    driver_statements.append(f"Strategic Risk\n{strategic}")

            if driver_statements:
                gen.add_business_drivers_slide(driver_statements)

        # Slide 4: TCO Comparison
        tco = bc.get("tco", {})
        if tco and (tco.get("current_state") or tco.get("proposed_oci")):
            gen.add_tco_slide(tco)

        # Slide 5: ROI
        roi = bc.get("roi", {})
        if roi and any(roi.get(k) for k in ["three_year_roi_pct", "payback_months", "total_investment"]):
            gen.add_roi_slide(roi)

        # Slide 6: Value Drivers
        value_drivers = bc.get("value_drivers", [])
        if value_drivers:
            gen.add_value_drivers_slide(value_drivers)

        # Slide 7: Risk Assessment
        risks = bc.get("risks", {})
        migration_risks = pick_list(risks, "migration_risks")
        do_nothing_risks = pick_list(risks, "do_nothing_risks")
        if migration_risks or do_nothing_risks:
            gen.add_risk_slide(migration_risks, do_nothing_risks)

        # Slide 8: Roadmap
        roadmap = bc.get("roadmap", {})
        if roadmap.get("phases"):
            gen.add_roadmap_slide(
                phases=pick_list(roadmap, "phases"),
                total_duration=pick(roadmap, "total_duration"),
            )

        # Slide 9: Recommendation
        rec = bc.get("recommendation", {})
        if rec:
            summary = pick(rec, "summary")
            if not summary and rec.get("commitment_amount"):
                summary = f"Recommended: {rec['commitment_amount']} {rec.get('commitment_type', 'UCM')} commitment"
            if summary:
                gen.add_recommendation_slide(
                    summary=summary,
                    next_steps=pick_list(rec, "next_steps"),
                )

        return gen


# ============================================================
# CLI
# ============================================================

def main():
    parser = argparse.ArgumentParser(
        description="Generate OCI business case slide deck (.pptx)"
    )
    parser.add_argument(
        "--spec", required=True,
        help="Path to YAML business case spec file",
    )
    parser.add_argument(
        "--output", default="business-case.pptx",
        help="Output .pptx file path",
    )
    parser.add_argument(
        "--template",
        help="Path to Oracle FY26 .pptx template (default: templates/Oracle_PPT-template_FY26.pptx)",
    )
    args = parser.parse_args()

    with open(args.spec, 'r') as f:
        spec = yaml.safe_load(f)

    gen = BusinessCaseDeckGenerator.from_spec(spec, template=args.template)
    gen.save(args.output)

    print(f"Generated: {args.output}")
    print(f"  Slides: {gen.slide_count}")
    print(f"  Template: Oracle FY26")
    customer = spec.get("business_case", spec).get("customer_name", "")
    if customer:
        print(f"  Customer: {customer}")


if __name__ == "__main__":
    main()