gcc alsatoggle.c -o alsatoggle $(pkg-config --cflags --libs gtk+-3.0) -lasound

#include <gtk/gtk.h>
#include <alsa/asoundlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>

typedef struct {
    snd_mixer_elem_t *elem;
} ToggleChannel;

typedef struct {
    snd_mixer_t *mixer;
    ToggleChannel *channels;
    int num_channels;
    GtkListStore *store;
} ToggleData;

// Normalize name for matching (lowercase, spaces/dashes removed)
static void normalize_name(char *dest, const char *src, size_t dest_size) {
    size_t i = 0;
    while (*src && i < dest_size - 1) {
        char c = tolower(*src);
        if (c != ' ' && c != '-') {
            dest[i++] = c;
        }
        src++;
    }
    dest[i] = '\0';
}

// Get user-friendly description, this section will need fine-tuning and additions
static const char* get_description(const char *alsa_name) {
    char normalized[128];
    normalize_name(normalized, alsa_name, sizeof(normalized));

    if (strstr(normalized, "automute") ||
        strstr(normalized, "automutemode") ||
        strstr(normalized, "automode")) {
        return "Automatically mutes internal speakers when headphones are plugged in.";
    }
    else if (strstr(normalized, "loopback")) {
        return "Routes audio output back to input (for recording what you hear).";
    }
    else if (strstr(normalized, "independenthp") ||
             strstr(normalized, "independentheadphone")) {
        return "Allows independent audio streams for headphones and speakers (no auto-muting of speakers).";
    }
    else if (strstr(normalized, "beep")) {
        return "Controls the PC speaker beep tone (system alerts). Usually best left disabled to avoid noise.";
    }
    else if (strstr(normalized, "phantom") ||
             strstr(normalized, "48v")) {
        return "Provides 48V phantom power for condenser microphones.";
    }

    return "Toggles this audio control on or off.";
}

// Callback when a toggle is flipped
static void on_toggle_changed(GtkCellRendererToggle *renderer, gchar *path_str, ToggleData *data) {
    GtkTreeIter iter;
    if (!gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(data->store), &iter, path_str))
        return;

    gboolean active;
    gtk_tree_model_get(GTK_TREE_MODEL(data->store), &iter, 0, &active, -1);
    active = !active;  // Flip it

    int row = atoi(path_str);
    snd_mixer_elem_t *elem = data->channels[row].elem;

    // Apply to ALSA
    if (snd_mixer_selem_has_playback_switch(elem)) {
        snd_mixer_selem_set_playback_switch_all(elem, active);
    }
    if (snd_mixer_selem_has_capture_switch(elem)) {
        snd_mixer_selem_set_capture_switch_all(elem, active);
    }
    if (snd_mixer_selem_is_enumerated(elem)) {
        unsigned int item = active ? 1 : 0;  // Most are 0=Disabled, 1=Enabled
        snd_mixer_selem_set_enum_item(elem, 0, item);
    }

    // Update the store/UI
    gtk_list_store_set(data->store, &iter, 0, active, -1);
}

static gboolean on_row_click(GtkWidget *treeview, GdkEventButton *event, ToggleData *data) {
    if (event->button == 3) { // Right-click toggle
        GtkTreePath *path;
        if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), event->x, event->y, &path, NULL, NULL, NULL)) {
            GtkTreeIter iter;
            if (gtk_tree_model_get_iter(GTK_TREE_MODEL(data->store), &iter, path)) {
                gboolean active;
                gtk_tree_model_get(GTK_TREE_MODEL(data->store), &iter, 0, &active, -1);
                active = !active;
                gtk_list_store_set(data->store, &iter, 0, active, -1);

                int row = gtk_tree_path_get_indices(path)[0];
                snd_mixer_elem_t *elem = data->channels[row].elem;
                // Same apply code as on_toggle_changed
                if (snd_mixer_selem_has_playback_switch(elem)) {
                    snd_mixer_selem_set_playback_switch_all(elem, active);
                }
                if (snd_mixer_selem_has_capture_switch(elem)) {
                    snd_mixer_selem_set_capture_switch_all(elem, active);
                }
                if (snd_mixer_selem_is_enumerated(elem)) {
                    unsigned int item = active ? 1 : 0;
                    snd_mixer_selem_set_enum_item(elem, 0, item);
                }
            }
            gtk_tree_path_free(path);
            return TRUE; // Handled
        }
    }
    return FALSE; // Pass left-click through
}

// Initialize ALSA and find toggles
static void init_alsa_toggles(ToggleData *data) {
    data->mixer = NULL;
    data->channels = NULL;
    data->num_channels = 0;

    if (snd_mixer_open(&data->mixer, 0) < 0) return;

    if (snd_mixer_attach(data->mixer, "default") < 0 ||
        snd_mixer_selem_register(data->mixer, NULL, NULL) < 0 ||
        snd_mixer_load(data->mixer) < 0) {
        snd_mixer_close(data->mixer);
        return;
    }

    ToggleChannel temp[64];
    int count = 0;

    snd_mixer_elem_t *elem;
    for (elem = snd_mixer_first_elem(data->mixer); elem; elem = snd_mixer_elem_next(elem)) {
        if (!snd_mixer_selem_is_active(elem)) continue;

        gboolean has_volume = snd_mixer_selem_has_playback_volume(elem) ||
                              snd_mixer_selem_has_capture_volume(elem);
        gboolean has_switch = snd_mixer_selem_has_playback_switch(elem) ||
                              snd_mixer_selem_has_capture_switch(elem);
        gboolean is_enum = snd_mixer_selem_is_enumerated(elem);

        // Pure toggle: either a switch without volume, or an enumerated control
        if ((has_switch && !has_volume) || is_enum) {
            if (count >= 64) break;
            temp[count].elem = elem;
            count++;
        }
    }

    if (count > 0) {
        data->num_channels = count;
        data->channels = g_new(ToggleChannel, count);
        memcpy(data->channels, temp, count * sizeof(ToggleChannel));
    }
}

static void cleanup_alsa(ToggleData *data) {
    if (data->mixer) snd_mixer_close(data->mixer);
    g_free(data->channels);
}

int main(int argc, char *argv[]) {
    gtk_init(&argc, &argv);

    gtk_window_set_default_icon_name("audio-speakers");

    ToggleData data = {0};
    init_alsa_toggles(&data);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(window), "AlsaTune - Toggle Functions");
    gtk_window_set_default_size(GTK_WINDOW(window), 660, 400);
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);

    // Some styling to match main app
    GtkCssProvider *css = gtk_css_provider_new();
    gtk_css_provider_load_from_data(css,
        "box { border: 2px solid #333333; border-radius: 4px; }"
        "button { border: 1px solid #333333; border-radius: 4px; }",
        -1, NULL);
    gtk_style_context_add_provider_for_screen(gdk_screen_get_default(),
                                              GTK_STYLE_PROVIDER(css),
                                              GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);

    GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
    gtk_container_set_border_width(GTK_CONTAINER(vbox), 5);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
    gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);

    if (data.num_channels == 0) {
        GtkWidget *label = gtk_label_new("No toggle controls detected on this system.");
        gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
        gtk_widget_set_margin_top(label, 40);
        gtk_container_add(GTK_CONTAINER(scrolled), label);
    } else {
        GtkWidget *treeview = gtk_tree_view_new();
        GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
        gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
        gtk_container_add(GTK_CONTAINER(scrolled), treeview);
        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);

        // Column 1: Toggle switch
        GtkCellRenderer *rend_toggle = gtk_cell_renderer_toggle_new();
        GtkTreeViewColumn *col_toggle = gtk_tree_view_column_new_with_attributes("", rend_toggle, "active", 0, NULL);
        gtk_tree_view_column_set_fixed_width(col_toggle, 80);
        gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), col_toggle);

        // Column 2: Name
        GtkCellRenderer *rend_name = gtk_cell_renderer_text_new();
        g_object_set(rend_name, "weight", PANGO_WEIGHT_BOLD, "xpad", 10, NULL);
        GtkTreeViewColumn *col_name = gtk_tree_view_column_new_with_attributes("Control", rend_name, "text", 1, NULL);
        gtk_tree_view_column_set_min_width(col_name, 200);
        gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), col_name);

        // Column 3: Description (wraps and expands)
        GtkCellRenderer *rend_desc = gtk_cell_renderer_text_new();
        g_object_set(rend_desc, "wrap-mode", PANGO_WRAP_WORD, "wrap-width", 330, NULL);
        GtkTreeViewColumn *col_desc = gtk_tree_view_column_new_with_attributes("Description", rend_desc, "text", 2, NULL);
        gtk_tree_view_column_set_expand(col_desc, TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), col_desc);

        // ListStore: active (bool), name (string), description (string)
        data.store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING);
        gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(data.store));

        for (int i = 0; i < data.num_channels; i++) {
            snd_mixer_elem_t *elem = data.channels[i].elem;
            const char *name = snd_mixer_selem_get_name(elem);
            const char *desc = get_description(name);

            // Determine current state
            gboolean active = FALSE;
            if (snd_mixer_selem_has_playback_switch(elem)) {
                int val;
                snd_mixer_selem_get_playback_switch(elem, SND_MIXER_SCHN_FRONT_LEFT, &val);
                active = val;
            } else if (snd_mixer_selem_is_enumerated(elem)) {
                unsigned int item;
                snd_mixer_selem_get_enum_item(elem, 0, &item);
                active = (item == 1);  // Adjust if any are reversed
            }

            GtkTreeIter iter;
            gtk_list_store_append(data.store, &iter);
            gtk_list_store_set(data.store, &iter,
                               0, active,
                               1, name,
                               2, desc,
                               -1);
        }

        g_signal_connect(rend_toggle, "toggled", G_CALLBACK(on_toggle_changed), &data);
        g_signal_connect(treeview, "button-press-event", G_CALLBACK(on_row_click), &data);
    }

    // Big goofy close button at bottom
    GtkWidget *close_btn = gtk_button_new_with_label("To enable a function, check the box beside it or hover over its row and right-click."
    "\nUncheck or click again to disable.  Left-click here to exit this window when done.");
    gtk_widget_set_tooltip_text(close_btn, 
    "Click this button (or the window's X) to close when you're done. "
    "All changes are applied instantly and saved on the backend, no further action needed.");
    gtk_widget_set_halign(close_btn, GTK_ALIGN_CENTER);
    gtk_widget_set_margin_top(close_btn, 10);
    gtk_widget_set_margin_bottom(close_btn, 10);
    g_signal_connect_swapped(close_btn, "clicked", G_CALLBACK(gtk_widget_destroy), window);
    gtk_box_pack_start(GTK_BOX(vbox), close_btn, FALSE, FALSE, 0);

    gtk_widget_show_all(window);
    gtk_main();

    cleanup_alsa(&data);
    return 0;
}