Switch

from starhtml import *

Div(
    SwitchWithLabel(label="Unchecked", signal="sw_st_off"),
    SwitchWithLabel(label="Checked", signal="sw_st_on", checked=True),
    SwitchWithLabel(label="Disabled off", signal="sw_st_dis_off", disabled=True),
    SwitchWithLabel(label="Disabled on", signal="sw_st_dis_on", disabled=True, checked=True),
    SwitchWithLabel(
        label="With error",
        signal="sw_st_err",
        error_text="Stream key is invalid",
    ),
    SwitchWithLabel(
        label="Required field",
        signal="sw_st_req",
        required=True,
        helper_text="Required before going live",
    ),
    SwitchWithLabel(
        label="Small size",
        signal="sw_st_sm",
        size="sm",
    ),
    SwitchWithLabel(
        label="Custom styling",
        signal="sw_st_custom",
        label_cls="text-green-700 dark:text-green-400",
        switch_cls="border-2 border-green-500",
        helper_text="Green tint on label and track border",
    ),
    cls="max-w-sm space-y-4",
)

from starhtml import *

live = Signal("sw_out_live", _ref_only=True)
transcode = Signal("sw_out_transcode", _ref_only=True)
overlay = Signal("sw_out_overlay", _ref_only=True)
lowlat = Signal("sw_out_lowlat", _ref_only=True)
layer_count = Signal("sw_out_count", transcode + overlay + lowlat)

Card(
    CardHeader(
        CardTitle("Stream Output"),
        CardDescription("Layers applied to the broadcast encoder"),
    ),
    CardContent(
        Div(
            layer_count,
            SwitchWithLabel(
                label="Stream live",
                helper_text="Push to ingest server",
                signal=live,
                checked=True,
            ),
            Div(
                SwitchWithLabel(label="Multi-quality transcode", signal=transcode),
                SwitchWithLabel(label="Chat overlay", signal=overlay),
                SwitchWithLabel(label="Low-latency mode", signal=lowlat, size="sm"),
                cls="space-y-3 border-l-2 border-muted pl-4",
                data_show=live,
                data_effect=[
                    (~live).then(transcode.set(False)),
                    (~live).then(overlay.set(False)),
                    (~live).then(lowlat.set(False)),
                ],
            ),
            P(
                data_text=live.if_(
                    layer_count.if_(layer_count + " layers active", "No layers enabled"),
                    "Stream offline",
                ),
                cls="mt-3 text-sm text-muted-foreground",
            ),
            cls="space-y-4",
        )
    ),
    cls="max-w-md",
)

from starhtml import *

low_latency = Signal("sw_go_lowlat", _ref_only=True)
vod = Signal("sw_go_vod", _ref_only=True)
dvr = Signal("sw_go_dvr", _ref_only=True)

Card(
    CardHeader(
        CardTitle("Broadcast Mode"),
        CardDescription("Required features before going live"),
    ),
    CardContent(
        Form(
            SwitchWithLabel(
                label="Low-latency ingest",
                helper_text="Sub-second glass-to-glass delay",
                signal=low_latency,
                required=True,
            ),
            SwitchWithLabel(
                label="VOD recording",
                signal=vod,
                required=True,
            ),
            SwitchWithLabel(
                label="DVR rewind",
                signal=dvr,
                required=True,
            ),
            SwitchWithLabel(
                label="Auto-clip highlights",
                signal="sw_go_clip",
            ),
            Button(
                "Go Live",
                type="submit",
                cls="mt-4 w-full",
                data_attr_disabled=~all_(low_latency, vod, dvr),
                data_on_click=evt.preventDefault(),
            ),
            cls="space-y-3",
        )
    ),
    cls="max-w-md",
)

from starhtml import *

hd = Signal("sw_enc_hd", _ref_only=True)
hw = Signal("sw_enc_hw", _ref_only=True)
bframes = Signal("sw_enc_bf", _ref_only=True)
twopass = Signal("sw_enc_2p", _ref_only=True)
# Weighted: 1080p costs 6000, hardware saves 2000, B-frames add 500, two-pass adds 1500
bitrate = Signal("sw_enc_kbps", hd * 6000 + hw * -2000 + bframes * 500 + twopass * 1500)
bitrate_pct = Signal("sw_enc_pct", bitrate / 8000 * 100)

def setting_switch(label, signal, helper_text=None, checked=False):
    return SwitchWithLabel(
        label=label,
        signal=signal,
        checked=checked,
        helper_text=helper_text,
        label_cls=signal.if_("text-green-700 dark:text-green-400"),
    )

Card(
    CardHeader(
        CardTitle("Encoder Settings"),
        CardDescription("Estimated bitrate from active options"),
    ),
    CardContent(
        Div(
            bitrate,
            bitrate_pct,
            setting_switch("1080p60 output", hd, helper_text="+6000 kbps", checked=True),
            setting_switch("Hardware encoding", hw, helper_text="-2000 kbps overhead"),
            setting_switch("B-frames", bframes, helper_text="+500 kbps"),
            setting_switch("Two-pass encoding", twopass, helper_text="+1500 kbps"),
            Div(
                P(
                    "Bitrate: ",
                    Span(data_text=bitrate, cls="font-bold"),
                    " kbps",
                    cls="text-sm text-muted-foreground",
                ),
                Progress(signal=bitrate_pct, cls="mt-2 h-2 w-full", aria_label="Estimated bitrate"),
                cls="mt-4",
            ),
            cls="space-y-3",
        )
    ),
    cls="max-w-md",
)

from starhtml import *

platforms = [
    ("sw_dst_twitch", "Twitch", "Twitch"),
    ("sw_dst_yt", "YouTube", "YT"),
    ("sw_dst_fb", "Facebook Live", "FB"),
    ("sw_dst_x", "X (Twitter)", "X"),
    ("sw_dst_kick", "Kick", "Kick"),
    ("sw_dst_rumble", "Rumble", "Rumble"),
]

platform_signals = {name: Signal(name, _ref_only=True) for name, _, _ in platforms}

active_summary = collect(
    [(platform_signals[name], short) for name, _, short in platforms],
    join_with=", ",
)

reset_actions = [platform_signals[name].set(False) for name, _, _ in platforms]

Card(
    CardHeader(
        CardTitle("Stream Destinations"),
        CardDescription("Multistream to selected platforms"),
    ),
    CardContent(
        Form(
            Div(
                *[
                    SwitchWithLabel(label=label, signal=platform_signals[name])
                    for name, label, _ in platforms
                ],
                cls="space-y-3",
            ),
            Div(
                Button("Go Multistream", type="submit", cls="w-full", data_on_click=evt.preventDefault()),
                Button("Reset All", variant="outline", cls="mt-2 w-full", data_on_click=(reset_actions, dict(prevent=True))),
                cls="mt-6",
            ),
            Div(
                P(
                    "Active: ",
                    Span(data_text=active_summary.if_(active_summary, "None"), cls="font-medium"),
                    cls="text-sm text-muted-foreground",
                ),
                cls="mt-4 border-t pt-4",
            ),
        )
    ),
    cls="max-w-sm",
)

from starhtml import *

renderer = Signal("sw_scene_render", _ref_only=True)

layers = [
    ("sw_scene_cam", "Webcam", "sw_scene_cam_p"),
    ("sw_scene_screen", "Screen capture", "sw_scene_screen_p"),
    ("sw_scene_lower", "Lower thirds", "sw_scene_lower_p"),
]

layer_signals = {name: Signal(name, _ref_only=True) for name, _, _ in layers}
preview_signals = {prev: Signal(prev, _ref_only=True) for _, _, prev in layers}
active_count = Signal(
    "sw_scene_count",
    sum(layer_signals[name] for name, _, _ in layers),
)

Card(
    CardHeader(
        CardTitle("Scene Layers"),
        CardDescription("Sources composited into the broadcast"),
    ),
    CardContent(
        Div(
            active_count,
            SwitchWithLabel(
                label="Studio mode",
                helper_text="Preview scene before pushing live",
                signal=renderer,
                checked=True,
            ),
            Div(
                *[
                    Div(
                        SwitchWithLabel(label=label, signal=layer_signals[name]),
                        Div(
                            Span("Preview", cls="text-xs text-muted-foreground"),
                            Switch(
                                signal=preview_signals[prev],
                                size="sm",
                                cls="border-2 border-amber-500",
                                data_attr_disabled=~layer_signals[name],
                                aria_label=f"Preview {label}",
                            ),
                            cls="flex items-center gap-2",
                        ),
                        cls="flex items-center justify-between",
                    )
                    for name, label, prev in layers
                ],
                cls="space-y-3 border-l-2 border-muted pl-4",
                data_show=renderer,
                data_effect=[
                    (~renderer).then(layer_signals[name].set(False))
                    for name, _, _ in layers
                ] + [
                    (~renderer).then(preview_signals[prev].set(False))
                    for _, _, prev in layers
                ],
            ),
            Div(
                Badge(
                    data_text=renderer.if_(active_count + " active", "Studio off"),
                    variant="secondary",
                ),
                cls="mt-4 flex justify-center",
            ),
            cls="space-y-4",
        )
    ),
    cls="max-w-md",
)