Day 84 – BI Career Development and Capstone

# %%
"""Day 84 – BI Career Development and Capstone classroom script."""

# %%
from __future__ import annotations

from textwrap import indent

from Day_84_BI_Career_Development_and_Capstone import (
    generate_checklists,
    serialize_checklists,
)

# %%
CAPSTONE_PHASES: list[tuple[str, str]] = [
    (
        "Phase 1 – Frame the business objective",
        (
            "Summarize the business question, BI success metrics, and stakeholders. "
            "Anchor your narrative in the developer-roadmap nodes you plan to demonstrate."
        ),
    ),
    (
        "Phase 2 – Design the solution storyline",
        (
            "Sketch a walkthrough that highlights your analytics workflow, decision checkpoints, "
            "and how you will showcase portfolio artifacts such as dashboards or notebooks."
        ),
    ),
    (
        "Phase 3 – Deliverables and rehearsal",
        (
            "Map roadmap titles to concrete deliverables, rehearse the presentation, and prepare "
            "supporting assets for interviews or stakeholder reviews."
        ),
    ),
]

# %%
CHECKLISTS = generate_checklists()


# %%
def outline_capstone(phases: list[tuple[str, str]] = CAPSTONE_PHASES) -> None:
    """Print the recommended capstone phases and guidance."""

    print("\nDay 84 capstone planning guide\n")
    for phase, description in phases:
        print(f"{phase}\n{indent(description, '  ')}\n")


# %%
def display_checklists(checklists=CHECKLISTS) -> None:
    """Print actionable checklists for learners."""

    print("Roadmap-aligned checklists\n")
    for group, items in checklists.items():
        print(f"## {group}")
        for item in items:
            print(f"- [ ] {item.title}")
        print()


# %%
def main() -> None:
    """Guide the learner through the Day 84 facilitation."""

    outline_capstone()
    display_checklists()
    print("Serialized checklist template (copy into your notes tool):\n")
    print(serialize_checklists(CHECKLISTS))


# %%
if __name__ == "__main__":
    main()

"""Utilities for Day 84 – BI Career Development and Capstone."""

from __future__ import annotations

import json
from dataclasses import dataclass
from pathlib import Path
from typing import Iterable, Mapping, MutableMapping

from mypackage.bi_curriculum import BiTopic, group_topics_by_titles

CAREER_ASSET_TITLES: list[str] = [
    "Building Your Portfolio",
    "Portfolio presentation",
    "Open-Source Projects",
    "BI Competitions",
    "BI Communities",
    "Conferences & Webinars",
    "Networking",
    "Professional Development",
    "Certifications",
]

JOB_READINESS_TITLES: list[str] = [
    "Resume optimization",
    "Interview preparation",
    "Salary negotiation strategies",
    "Job Preparation",
]

ROADMAP_GROUPS: Mapping[str, list[str]] = {
    "Career assets": CAREER_ASSET_TITLES,
    "Job readiness": JOB_READINESS_TITLES,
}


@dataclass(slots=True)
class ChecklistItem:
    """A simple representation of a learner checklist item."""

    title: str
    status: str = "Not started"
    notes: str = ""

    def to_dict(self) -> dict[str, str]:
        """Return a serializable representation of the checklist item."""

        return {"title": self.title, "status": self.status, "notes": self.notes}


def load_career_topics(
    *, groups: Mapping[str, Iterable[str]] = ROADMAP_GROUPS
) -> dict[str, list[BiTopic]]:
    """Return the roadmap topics grouped for the capstone."""

    return group_topics_by_titles(groups)


def _build_checklist(topics: Iterable[BiTopic]) -> list[ChecklistItem]:
    """Create checklist items from BI topics."""

    return [ChecklistItem(title=topic.title) for topic in topics]


def generate_checklists(
    *, groups: Mapping[str, Iterable[str]] = ROADMAP_GROUPS
) -> dict[str, list[ChecklistItem]]:
    """Return checklist templates for career assets and job readiness."""

    grouped_topics = load_career_topics(groups=groups)
    return {group: _build_checklist(topics) for group, topics in grouped_topics.items()}


def _checklists_to_serializable(
    checklists: Mapping[str, Iterable[ChecklistItem]],
) -> dict[str, list[dict[str, str]]]:
    """Convert checklist dataclasses into JSON serializable dictionaries."""

    payload: MutableMapping[str, list[dict[str, str]]] = {}
    for group, items in checklists.items():
        payload[group] = [item.to_dict() for item in items]
    return dict(payload)


def serialize_checklists(
    checklists: Mapping[str, Iterable[ChecklistItem]] | None = None,
    *,
    groups: Mapping[str, Iterable[str]] = ROADMAP_GROUPS,
    path: str | Path | None = None,
    indent: int = 2,
) -> str:
    """Return JSON for the grouped checklists and optionally persist it."""

    resolved = (
        checklists if checklists is not None else generate_checklists(groups=groups)
    )
    serializable = _checklists_to_serializable(resolved)
    json_text = json.dumps(serializable, indent=indent)
    if path is not None:
        destination = Path(path)
        destination.write_text(json_text, encoding="utf-8")
    return json_text


__all__ = [
    "CAREER_ASSET_TITLES",
    "JOB_READINESS_TITLES",
    "ChecklistItem",
    "generate_checklists",
    "load_career_topics",
    "serialize_checklists",
]