main.py

import os
from datetime import timedelta

import yaml
import markdown
from jinja2 import Environment, FileSystemLoader
from bs4 import BeautifulSoup
from collections import defaultdict

# --- CSS STYLE ---
DEFAULT_STYLE = {
    "a": {"text-decoration": "none"},
    "p": {"text-align": "justify"}
}

SCHEDULE_FIELDS_TO_IMPORT = ["speaker", "description", "bio", "speaker_size", "slides", "video"]


def load_yaml(path: str):
    if not os.path.exists(path):
        raise FileNotFoundError(f"{path} not found")
    with open(path, encoding="utf-8", mode="r") as f:
        return yaml.safe_load(f) or []


def serialize_style(style: dict[str, str]) -> str:
    return "; ".join(f"{k}: {v}" for k, v in style.items())


def process_markdown(
        text: str,
        strip_top_level_p: bool = False,
        css_customizations: dict[str, dict[str, str]] = None
) -> str:
    if css_customizations is None:
        css_customizations = {}

    if not text:
        return ""

    soup = BeautifulSoup(markdown.markdown(text.strip()), features="html.parser")

    if strip_top_level_p:
        for p in soup.find_all("p", recursive=False):
            p.unwrap()

    if css_customizations:
        for tag, style in css_customizations.items():
            for element in soup.find_all(tag, recursive=True):
                element["style"] = "; ".join(
                    s for s in (element.get("style", "").rstrip(";"), serialize_style(style)) if s)

    return soup.decode_contents().strip()


def render_markdown(text: str) -> str:
    return process_markdown(text=text, css_customizations=DEFAULT_STYLE).strip()


def render_template(context: dict, template_name: str, output_path: str, template_dir: str = "templates"):
    env = Environment(loader=FileSystemLoader(template_dir), autoescape=True)
    rendered_html = env.get_template(template_name).render(**context)
    os.makedirs(os.path.dirname(output_path) or ".", exist_ok=True)
    with open(output_path, "w", encoding="utf-8") as f:
        f.write(rendered_html)
    print(f"Success! Generated {output_path}.")


def generate_data(
        name: str,
        input_path: str,
        output_name: str,
        template_name: str,
        assets_path: str,
        sorter=None,
        formatter=None,
        output_dir: str = "output",
        template_dir: str = "templates",
):
    data = load_yaml(input_path)
    assets = load_yaml(assets_path)

    if sorter:
        sorter(data)

    if formatter:
        formatter(data)

    context = {
        name: data,
        "github_icon": assets.get("github_icon_url", ""),
        "linkedin_icon": assets.get("linkedin_icon_url", ""),
    }

    render_template(context, template_name, os.path.join(output_dir, output_name), template_dir)


def sort_speakers_inplace(data):
    data.sort(
        key=lambda s: (
            s.get("last_name", "").strip().lower(),
            s.get("name", "").strip().lower(),
        )
    )


def format_speakers_inplace(data):
    for speaker in data:
        speaker["company_html"] = process_markdown(
            text=speaker.get("company", ""),
            strip_top_level_p=True,
            css_customizations=DEFAULT_STYLE
        )
        speaker["bio_html"] = process_markdown(
            text=speaker.get("bio", ""),
            css_customizations=DEFAULT_STYLE
        )
        for talk in speaker.get("talks", []):
            talk["description_html"] = process_markdown(
                text=talk.get("description", ""),
                css_customizations=DEFAULT_STYLE
            )


def format_workshops_inplace(data):
    for speaker in data:
        for workshop in speaker.get("workshops", []):
            workshop["title_html"] = process_markdown(
                text=workshop.get("title", ""),
                strip_top_level_p=True,
                css_customizations=DEFAULT_STYLE
            )
            workshop["description_html"] = process_markdown(
                text=workshop.get("description", ""),
                css_customizations=DEFAULT_STYLE
            )


def cross_reference_talks(talks_data_path: str):
    index = defaultdict(lambda: {"speakers": [], "biographies": [], "description": "", "slides": "", "video": ""})
    for speaker in load_yaml(talks_data_path):
        full_name = f"{speaker['name']} {speaker['last_name']}"
        biography = render_markdown(speaker["bio"])

        for talk in speaker.get("talks", []):
            title = talk["title"]
            entry = index[title]
            entry["speakers"].append(full_name)
            entry["biographies"].append(biography)
            if not entry["description"]:
                entry["description"] = render_markdown(talk["description"])
            if talk.get("slides"):
                entry["slides"] = talk["slides"]
            if talk.get("video"):
                entry["video"] = talk["video"]

    return {
        title: {
            "speaker": ", ".join(data["speakers"]),
            "speaker_size": len(data["speakers"]),
            "description": data["description"],
            "bio": "\n".join(data["biographies"]),
            "slides": data["slides"],
            "video": data["video"]
        }
        for title, data in index.items()
    }


def cross_reference_workshops(workshops_data_path: str):
    raw_index = defaultdict(lambda: {"names": [], "description": ""})
    for speaker in load_yaml(workshops_data_path):
        for workshop in speaker.get("workshops", []):
            title = workshop["title"]
            entry = raw_index[title]
            entry["names"].append(speaker["name"])
            if not entry["description"]:
                entry["description"] = render_markdown(workshop["description"])

    return {
        title: {
            "speaker": ", ".join(data["names"]),
            "speaker_size": len(data["names"]),
            "description": data["description"],
        }
        for title, data in raw_index.items()
    }


def human_duration(minutes: int) -> str:
    minutes = int(minutes)
    hours, mins = divmod(minutes, 60)
    if hours == 0:
        return f"{mins} min"
    if mins == 0:
        return f"{hours} hour"
    return f"{hours} hr, {mins} min"


def process_timestamps_inplace(schedule_data):
    for talk in schedule_data:
        talk['day_sort_key'] = talk['start'].strftime('%Y-%m-%d')  # Jinja Sorting Key
        talk['day_label'] = talk['start'].strftime('%A, %B %d')  # e.g. Monday, January 01
        talk['end'] = talk['start'] + timedelta(minutes=talk['duration'])
        talk['duration'] = human_duration(talk['duration'])

    schedule_data.sort(key=lambda x: x['start'])

    for current, next_entry in zip(schedule_data, schedule_data[1:]):
        if next_entry['start'] < current['end']:
            print(
                "Warning: overlapping talks:",
                f"'{current['title']}' "
                f"({current['start']} – {current['end']}) overlaps with "
                f"'{next_entry['title']}' "
                f"({next_entry['start']} – {next_entry['end']})"
            )


def generate_schedule(
        name: str,
        input_path: str,
        cross_reference_map: dict,
        output_name: str,
        template_name: str,
        output_dir: str = "output",
        template_dir: str = "templates",
):
    schedule_data = load_yaml(input_path)

    index = cross_reference_talks(cross_reference_map['speakers']) | cross_reference_workshops(cross_reference_map['workshops'])

    process_timestamps_inplace(schedule_data)

    for entry in schedule_data:
        title = entry["title"]

        if entry.get("description"):
            entry["description"] = render_markdown(entry["description"])

        extra_data = index.get(title)
        if not extra_data:
            if entry["type"] in ["talk", "workshop"]:
                print(f"Warning: Could not cross-reference {entry['type']} title: {title}")
            continue

        for field in SCHEDULE_FIELDS_TO_IMPORT:
            index_value = extra_data.get(field)
            if index_value:
                if entry.get(field):
                    print(f"Warning: Schedule for '{title}' already has a {field}. Ignoring index value.")
                else:
                    entry[field] = index_value

    render_template({name: schedule_data}, template_name, os.path.join(output_dir, output_name), template_dir)


if __name__ == "__main__":
    data_assets_path = "data/assets.yaml"
    schedule_path = "data/2026/schedule.yaml"
    speakers_path = "data/2026/speakers.yaml"
    workshops_path = "data/2026/workshops.yaml"

    # Speakers
    generate_data(
        name="speakers",
        input_path=speakers_path,
        output_name="speakers.html",
        template_name="speakers.html.j2",
        assets_path=data_assets_path,
        sorter=sort_speakers_inplace,
        formatter=format_speakers_inplace,
    )
    # Workshops
    generate_data(
        name="speakers",
        input_path=workshops_path,
        output_name="workshops.html",
        template_name="workshops.html.j2",
        assets_path=data_assets_path,
        formatter=format_workshops_inplace
    )
    # Schedule
    generate_schedule(
        name="talks",
        input_path=schedule_path,
        cross_reference_map={'speakers': speakers_path, 'workshops': workshops_path},
        output_name="schedule.html",
        template_name="schedule.html.j2"
    )