/*
 * DWN - Desktop Window Manager
 * retoor <retoor@molodetz.nl>
 * System tray widgets implementation with UTF-8 support
 */

#include "systray.h"
#include "panel.h"
#include "config.h"
#include "util.h"
#include "notifications.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <dirent.h>
#include <pthread.h>

#define ICON_WIFI_FULL      "\xE2\x96\x82\xE2\x96\x84\xE2\x96\x86\xE2\x96\x88"
#define ICON_WIFI_OFF       "\xE2\x9C\x97"
#define ICON_VOLUME_HIGH    "\xF0\x9F\x94\x8A"
#define ICON_VOLUME_MED     "\xF0\x9F\x94\x89"
#define ICON_VOLUME_LOW     "\xF0\x9F\x94\x88"
#define ICON_VOLUME_MUTE    "\xF0\x9F\x94\x87"
#define ICON_BATTERY_FULL   "\xF0\x9F\x94\x8B"
#define ICON_BATTERY_CHARGE "\xE2\x9A\xA1"

#define ASCII_WIFI_ON       "W"
#define ASCII_WIFI_OFF      "-"
#define ASCII_VOL_HIGH      "V"
#define ASCII_VOL_MUTE      "M"
#define ASCII_BATTERY       "B"
#define ASCII_CHARGING      "+"

#define SYSTRAY_SPACING 12
#define DROPDOWN_ITEM_HEIGHT 28
#define DROPDOWN_WIDTH 400
#define DROPDOWN_PADDING 8
#define SLIDER_WIDTH 30
#define SLIDER_HEIGHT 120
#define SLIDER_PADDING 8
#define SLIDER_KNOB_HEIGHT 8

#define WIFI_SCAN_INTERVAL 10000

WifiState wifi_state = {0};
AudioState audio_state = {0};
BatteryState battery_state = {0};
DropdownMenu *wifi_menu = NULL;
VolumeSlider *volume_slider = NULL;

static pthread_t update_thread;
static pthread_mutex_t state_mutex = PTHREAD_MUTEX_INITIALIZER;
static volatile int thread_running = 0;

static int systray_x = 0;
static int systray_width = 0;
static int wifi_icon_x = 0;
static int audio_icon_x = 0;

static void wifi_update_state_internal(void);
static void audio_update_state_internal(void);


static void draw_utf8_text(Drawable d, int x, int y, const char *text, unsigned long color)
{
    if (dwn == NULL || dwn->display == NULL || text == NULL) {
        return;
    }

    if (dwn->xft_font != NULL) {
        XftDraw *xft_draw = XftDrawCreate(dwn->display, d,
                                          DefaultVisual(dwn->display, dwn->screen),
                                          dwn->colormap);
        if (xft_draw != NULL) {
            XftColor xft_color;
            XRenderColor render_color;

            render_color.red = ((color >> 16) & 0xFF) * 257;
            render_color.green = ((color >> 8) & 0xFF) * 257;
            render_color.blue = (color & 0xFF) * 257;
            render_color.alpha = 0xFFFF;

            XftColorAllocValue(dwn->display,
                               DefaultVisual(dwn->display, dwn->screen),
                               dwn->colormap, &render_color, &xft_color);

            XftDrawStringUtf8(xft_draw, &xft_color, dwn->xft_font,
                              x, y, (const FcChar8 *)text, strlen(text));

            XftColorFree(dwn->display,
                         DefaultVisual(dwn->display, dwn->screen),
                         dwn->colormap, &xft_color);
            XftDrawDestroy(xft_draw);
            return;
        }
    }

    XSetForeground(dwn->display, dwn->gc, color);
    XDrawString(dwn->display, d, dwn->gc, x, y, text, strlen(text));
}

static int get_text_width(const char *text)
{
    if (dwn == NULL || text == NULL) {
        return 0;
    }

    if (dwn->xft_font != NULL) {
        XGlyphInfo extents;
        XftTextExtentsUtf8(dwn->display, dwn->xft_font,
                           (const FcChar8 *)text, strlen(text), &extents);
        return extents.xOff;
    }

    if (dwn->font != NULL) {
        return XTextWidth(dwn->font, text, strlen(text));
    }

    return strlen(text) * 8;
}


static void *systray_update_thread(void *arg)
{
    (void)arg;

    while (thread_running) {
        wifi_update_state_internal();

        audio_update_state_internal();

        pthread_mutex_lock(&state_mutex);
        battery_update_state();
        pthread_mutex_unlock(&state_mutex);

        for (int i = 0; i < 20 && thread_running; i++) {
            usleep(100000);
        }
    }

    return NULL;
}

void systray_init(void)
{
    memset(&wifi_state, 0, sizeof(wifi_state));
    memset(&audio_state, 0, sizeof(audio_state));
    memset(&battery_state, 0, sizeof(battery_state));

    audio_state.volume = 50;
    wifi_state.enabled = true;

    thread_running = 1;
    if (pthread_create(&update_thread, NULL, systray_update_thread, NULL) != 0) {
        LOG_WARN("Failed to create systray update thread");
        thread_running = 0;
    }

    LOG_INFO("System tray initialized");
}

void systray_cleanup(void)
{
    if (thread_running) {
        thread_running = 0;
        pthread_join(update_thread, NULL);
    }

    if (wifi_menu != NULL) {
        dropdown_destroy(wifi_menu);
        wifi_menu = NULL;
    }
    if (volume_slider != NULL) {
        volume_slider_destroy(volume_slider);
        volume_slider = NULL;
    }
}


void battery_update_state(void)
{
    DIR *dir;
    struct dirent *entry;
    char path[512];
    char value[64];
    FILE *fp;

    battery_state.present = false;
    battery_state.charging = false;
    battery_state.percentage = 0;

    dir = opendir("/sys/class/power_supply");
    if (dir == NULL) {
        return;
    }

    while ((entry = readdir(dir)) != NULL) {
        if (entry->d_name[0] == '.') {
            continue;
        }

        snprintf(path, sizeof(path), "/sys/class/power_supply/%s/type", entry->d_name);
        fp = fopen(path, "r");
        if (fp != NULL) {
            if (fgets(value, sizeof(value), fp) != NULL) {
                value[strcspn(value, "\n")] = '\0';
                if (strcmp(value, "Battery") == 0) {
                    battery_state.present = true;

                    snprintf(path, sizeof(path), "/sys/class/power_supply/%s/capacity", entry->d_name);
                    FILE *cap_fp = fopen(path, "r");
                    if (cap_fp != NULL) {
                        if (fgets(value, sizeof(value), cap_fp) != NULL) {
                            battery_state.percentage = atoi(value);
                        }
                        fclose(cap_fp);
                    }

                    snprintf(path, sizeof(path), "/sys/class/power_supply/%s/status", entry->d_name);
                    FILE *status_fp = fopen(path, "r");
                    if (status_fp != NULL) {
                        if (fgets(value, sizeof(value), status_fp) != NULL) {
                            value[strcspn(value, "\n")] = '\0';
                            battery_state.charging = (strcmp(value, "Charging") == 0 ||
                                                      strcmp(value, "Full") == 0);
                        }
                        fclose(status_fp);
                    }

                    fclose(fp);
                    break;
                }
            }
            fclose(fp);
        }
    }
    closedir(dir);
}

const char *battery_get_icon(void)
{
    if (!battery_state.present) {
        return "";
    }

    if (battery_state.charging) {
        return ASCII_CHARGING;
    }

    return ASCII_BATTERY;
}


static void wifi_update_state_internal(void)
{
    FILE *fp;
    char line[256];
    WifiState temp_state = {0};

    fp = popen("nmcli -t -f GENERAL.STATE,GENERAL.CONNECTION dev show 2>/dev/null | head -2", "r");
    if (fp != NULL) {
        while (fgets(line, sizeof(line), fp) != NULL) {
            line[strcspn(line, "\n")] = '\0';

            if (strstr(line, "GENERAL.STATE:") != NULL) {
                if (strstr(line, "100 (connected)") != NULL) {
                    temp_state.connected = true;
                    temp_state.enabled = true;
                }
            }
            if (strstr(line, "GENERAL.CONNECTION:") != NULL) {
                char *ssid = strchr(line, ':');
                if (ssid != NULL && strlen(ssid) > 1) {
                    ssid++;
                    strncpy(temp_state.current_ssid, ssid, sizeof(temp_state.current_ssid) - 1);
                }
            }
        }
        pclose(fp);
    }

    if (temp_state.connected) {
        fp = popen("nmcli -t -f IN-USE,SIGNAL dev wifi list 2>/dev/null | grep '^\\*' | cut -d: -f2", "r");
        if (fp != NULL) {
            if (fgets(line, sizeof(line), fp) != NULL) {
                temp_state.signal_strength = atoi(line);
            }
            pclose(fp);
        }
    }

    pthread_mutex_lock(&state_mutex);
    wifi_state.connected = temp_state.connected;
    wifi_state.enabled = temp_state.enabled;
    wifi_state.signal_strength = temp_state.signal_strength;
    memcpy(wifi_state.current_ssid, temp_state.current_ssid, sizeof(wifi_state.current_ssid));
    pthread_mutex_unlock(&state_mutex);
}

void wifi_update_state(void)
{
}

void wifi_scan_networks(void)
{
    FILE *fp;
    char line[512];

    WifiNetwork temp_networks[MAX_WIFI_NETWORKS];
    int temp_count = 0;
    long scan_time = get_time_ms();

    fp = popen("nmcli -t -f SSID,SIGNAL,SECURITY,IN-USE dev wifi list 2>/dev/null", "r");
    if (fp == NULL) {
        LOG_WARN("Failed to scan WiFi networks");
        return;
    }

    while (fgets(line, sizeof(line), fp) != NULL && temp_count < MAX_WIFI_NETWORKS) {
        line[strcspn(line, "\n")] = '\0';

        char *ssid = strtok(line, ":");
        char *signal = strtok(NULL, ":");
        char *security = strtok(NULL, ":");
        char *in_use = strtok(NULL, ":");

        if (ssid != NULL && strlen(ssid) > 0) {
            WifiNetwork *net = &temp_networks[temp_count];
            strncpy(net->ssid, ssid, sizeof(net->ssid) - 1);
            net->ssid[sizeof(net->ssid) - 1] = '\0';
            net->signal = signal ? atoi(signal) : 0;
            strncpy(net->security, security ? security : "", sizeof(net->security) - 1);
            net->security[sizeof(net->security) - 1] = '\0';
            net->connected = (in_use != NULL && in_use[0] == '*');
            temp_count++;
        }
    }
    pclose(fp);

    pthread_mutex_lock(&state_mutex);
    memcpy(wifi_state.networks, temp_networks, sizeof(temp_networks));
    wifi_state.network_count = temp_count;
    wifi_state.last_scan = scan_time;
    pthread_mutex_unlock(&state_mutex);

    LOG_DEBUG("Scanned %d WiFi networks", temp_count);
}

void wifi_connect(const char *ssid)
{
    if (ssid == NULL || strlen(ssid) == 0) {
        return;
    }

    char cmd[256];
    snprintf(cmd, sizeof(cmd), "nmcli dev wifi connect \"%s\" &", ssid);

    char msg[128];
    snprintf(msg, sizeof(msg), "Connecting to %s...", ssid);
    notification_show("WiFi", "Connecting", msg, NULL, 3000);

    spawn_async(cmd);

    pthread_mutex_lock(&state_mutex);
    wifi_state.connected = false;
    pthread_mutex_unlock(&state_mutex);
}

void wifi_disconnect(void)
{
    spawn_async("nmcli dev disconnect wlan0 &");

    pthread_mutex_lock(&state_mutex);
    wifi_state.connected = false;
    pthread_mutex_unlock(&state_mutex);

    notification_show("WiFi", "Disconnected", "WiFi connection closed", NULL, 2000);
}

const char *wifi_get_icon(void)
{
    if (!wifi_state.enabled || !wifi_state.connected) {
        return ASCII_WIFI_OFF;
    }
    return ASCII_WIFI_ON;
}


static void audio_update_state_internal(void)
{
    FILE *fp;
    char line[256];
    int volume = 50;
    bool muted = false;

    fp = popen("amixer get Master 2>/dev/null | grep -o '[0-9]*%\\|\\[on\\]\\|\\[off\\]' | head -2", "r");
    if (fp != NULL) {
        while (fgets(line, sizeof(line), fp) != NULL) {
            line[strcspn(line, "\n")] = '\0';

            if (strchr(line, '%') != NULL) {
                volume = atoi(line);
            } else if (strcmp(line, "[off]") == 0) {
                muted = true;
            } else if (strcmp(line, "[on]") == 0) {
                muted = false;
            }
        }
        pclose(fp);
    }

    pthread_mutex_lock(&state_mutex);
    audio_state.volume = volume;
    audio_state.muted = muted;
    pthread_mutex_unlock(&state_mutex);
}

void audio_update_state(void)
{
}

void audio_set_volume(int volume)
{
    if (volume < 0) volume = 0;
    if (volume > 100) volume = 100;

    char cmd[64];
    snprintf(cmd, sizeof(cmd), "amixer set Master %d%% >/dev/null 2>&1 &", volume);
    spawn_async(cmd);

    pthread_mutex_lock(&state_mutex);
    audio_state.volume = volume;
    audio_state.muted = false;
    pthread_mutex_unlock(&state_mutex);
}

void audio_toggle_mute(void)
{
    spawn_async("amixer set Master toggle >/dev/null 2>&1 &");

    pthread_mutex_lock(&state_mutex);
    audio_state.muted = !audio_state.muted;
    pthread_mutex_unlock(&state_mutex);
}

const char *audio_get_icon(void)
{
    if (audio_state.muted || audio_state.volume == 0) {
        return ASCII_VOL_MUTE;
    }
    return ASCII_VOL_HIGH;
}


VolumeSlider *volume_slider_create(int x, int y)
{
    if (dwn == NULL || dwn->display == NULL) {
        return NULL;
    }

    VolumeSlider *slider = dwn_calloc(1, sizeof(VolumeSlider));
    slider->x = x;
    slider->y = y;
    slider->width = SLIDER_WIDTH;
    slider->height = SLIDER_HEIGHT;
    slider->visible = false;
    slider->dragging = false;

    return slider;
}

void volume_slider_destroy(VolumeSlider *slider)
{
    if (slider == NULL) {
        return;
    }

    if (slider->window != None && dwn != NULL && dwn->display != NULL) {
        XDestroyWindow(dwn->display, slider->window);
    }

    dwn_free(slider);
}

void volume_slider_show(VolumeSlider *slider)
{
    if (slider == NULL || dwn == NULL || dwn->display == NULL) {
        return;
    }

    if (slider->window == None) {
        XSetWindowAttributes swa;
        swa.override_redirect = True;
        swa.background_pixel = dwn->config->colors.panel_bg;
        swa.border_pixel = dwn->config->colors.border_focused;
        swa.event_mask = ExposureMask | ButtonPressMask | ButtonReleaseMask |
                         PointerMotionMask | LeaveWindowMask;

        slider->window = XCreateWindow(dwn->display, dwn->root,
                                        slider->x, slider->y,
                                        slider->width, slider->height,
                                        1,
                                        CopyFromParent, InputOutput, CopyFromParent,
                                        CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWEventMask,
                                        &swa);
    }

    slider->visible = true;
    XMapRaised(dwn->display, slider->window);
    volume_slider_render(slider);
}

void volume_slider_hide(VolumeSlider *slider)
{
    if (slider == NULL || slider->window == None) {
        return;
    }

    slider->visible = false;
    slider->dragging = false;
    XUnmapWindow(dwn->display, slider->window);
}

void volume_slider_render(VolumeSlider *slider)
{
    if (slider == NULL || slider->window == None || !slider->visible) {
        return;
    }

    Display *dpy = dwn->display;
    const ColorScheme *colors = config_get_colors();

    XSetForeground(dpy, dwn->gc, colors->panel_bg);
    XFillRectangle(dpy, slider->window, dwn->gc, 0, 0, slider->width, slider->height);

    int track_x = slider->width / 2 - 2;
    int track_y = SLIDER_PADDING;
    int track_height = slider->height - 2 * SLIDER_PADDING;

    XSetForeground(dpy, dwn->gc, colors->workspace_inactive);
    XFillRectangle(dpy, slider->window, dwn->gc, track_x, track_y, 4, track_height);

    int fill_height = (audio_state.volume * track_height) / 100;
    int fill_y = track_y + track_height - fill_height;

    XSetForeground(dpy, dwn->gc, colors->workspace_active);
    XFillRectangle(dpy, slider->window, dwn->gc, track_x, fill_y, 4, fill_height);

    int knob_y = fill_y - SLIDER_KNOB_HEIGHT / 2;
    if (knob_y < track_y) knob_y = track_y;
    if (knob_y > track_y + track_height - SLIDER_KNOB_HEIGHT) {
        knob_y = track_y + track_height - SLIDER_KNOB_HEIGHT;
    }

    XSetForeground(dpy, dwn->gc, colors->panel_fg);
    XFillRectangle(dpy, slider->window, dwn->gc,
                   track_x - 4, knob_y, 12, SLIDER_KNOB_HEIGHT);

    char vol_text[8];
    snprintf(vol_text, sizeof(vol_text), "%d%%", audio_state.volume);
    int text_width = get_text_width(vol_text);
    int text_x = (slider->width - text_width) / 2;

    draw_utf8_text(slider->window, text_x, slider->height - 4, vol_text, colors->panel_fg);

    XFlush(dpy);
}

void volume_slider_handle_click(VolumeSlider *slider, int x, int y)
{
    (void)x;

    if (slider == NULL || !slider->visible) {
        return;
    }

    slider->dragging = true;

    int track_y = SLIDER_PADDING;
    int track_height = slider->height - 2 * SLIDER_PADDING;

    int relative_y = y - track_y;
    if (relative_y < 0) relative_y = 0;
    if (relative_y > track_height) relative_y = track_height;

    int new_volume = 100 - (relative_y * 100 / track_height);
    audio_set_volume(new_volume);
    volume_slider_render(slider);
    panel_render_all();
}

void volume_slider_handle_motion(VolumeSlider *slider, int x, int y)
{
    if (slider == NULL || !slider->visible || !slider->dragging) {
        return;
    }

    volume_slider_handle_click(slider, x, y);
}

void volume_slider_handle_release(VolumeSlider *slider)
{
    if (slider == NULL) {
        return;
    }
    slider->dragging = false;
}


DropdownMenu *dropdown_create(int x, int y, int width)
{
    if (dwn == NULL || dwn->display == NULL) {
        return NULL;
    }

    DropdownMenu *menu = dwn_calloc(1, sizeof(DropdownMenu));
    menu->x = x;
    menu->y = y;
    menu->width = width;
    menu->height = 0;
    menu->item_count = 0;
    menu->hovered_item = -1;
    menu->visible = false;
    menu->on_select = NULL;

    return menu;
}

void dropdown_destroy(DropdownMenu *menu)
{
    if (menu == NULL) {
        return;
    }

    if (menu->window != None && dwn != NULL && dwn->display != NULL) {
        XDestroyWindow(dwn->display, menu->window);
    }

    dwn_free(menu);
}

void dropdown_show(DropdownMenu *menu)
{
    if (menu == NULL || dwn == NULL || dwn->display == NULL) {
        return;
    }

    wifi_scan_networks();

    menu->item_count = wifi_state.network_count;
    menu->height = menu->item_count * DROPDOWN_ITEM_HEIGHT + 2 * DROPDOWN_PADDING;

    if (menu->height < DROPDOWN_ITEM_HEIGHT + 2 * DROPDOWN_PADDING) {
        menu->height = DROPDOWN_ITEM_HEIGHT + 2 * DROPDOWN_PADDING;
        menu->item_count = 1;
    }

    int max_text_width = 0;
    for (int i = 0; i < wifi_state.network_count; i++) {
        WifiNetwork *net = &wifi_state.networks[i];
        char label[128];
        snprintf(label, sizeof(label), "%s %d%%", net->ssid, net->signal);
        int text_width = get_text_width(label);
        if (text_width > max_text_width) {
            max_text_width = text_width;
        }
    }
    int min_width = 250;
    int calculated_width = max_text_width + 2 * DROPDOWN_PADDING + 30;
    menu->width = (calculated_width > min_width) ? calculated_width : min_width;

    if (menu->window == None) {
        XSetWindowAttributes swa;
        swa.override_redirect = True;
        swa.background_pixel = dwn->config->colors.panel_bg;
        swa.border_pixel = dwn->config->colors.border_focused;
        swa.event_mask = ExposureMask | ButtonPressMask | PointerMotionMask |
                         LeaveWindowMask | EnterWindowMask;

        menu->window = XCreateWindow(dwn->display, dwn->root,
                                     menu->x, menu->y,
                                     menu->width, menu->height,
                                     1,
                                     CopyFromParent, InputOutput, CopyFromParent,
                                     CWOverrideRedirect | CWBackPixel | CWBorderPixel | CWEventMask,
                                     &swa);
    } else {
        XMoveResizeWindow(dwn->display, menu->window,
                          menu->x, menu->y, menu->width, menu->height);
    }

    menu->visible = true;
    XMapRaised(dwn->display, menu->window);
    dropdown_render(menu);
}

void dropdown_hide(DropdownMenu *menu)
{
    if (menu == NULL || menu->window == None) {
        return;
    }

    menu->visible = false;
    XUnmapWindow(dwn->display, menu->window);
}

void dropdown_render(DropdownMenu *menu)
{
    if (menu == NULL || menu->window == None || !menu->visible) {
        return;
    }

    if (dwn == NULL || dwn->display == NULL) {
        return;
    }

    Display *dpy = dwn->display;
    const ColorScheme *colors = config_get_colors();

    int font_height = 12;
    if (dwn->xft_font != NULL) {
        font_height = dwn->xft_font->ascent;
    } else if (dwn->font != NULL) {
        font_height = dwn->font->ascent;
    }
    int text_y_offset = (DROPDOWN_ITEM_HEIGHT + font_height) / 2;

    XSetForeground(dpy, dwn->gc, colors->panel_bg);
    XFillRectangle(dpy, menu->window, dwn->gc, 0, 0, menu->width, menu->height);

    if (wifi_state.network_count == 0) {
        draw_utf8_text(menu->window, DROPDOWN_PADDING, DROPDOWN_PADDING + text_y_offset,
                       "No networks found", colors->workspace_inactive);
    } else {
        for (int i = 0; i < wifi_state.network_count && i < MAX_WIFI_NETWORKS; i++) {
            WifiNetwork *net = &wifi_state.networks[i];
            int y = DROPDOWN_PADDING + i * DROPDOWN_ITEM_HEIGHT;

            if (i == menu->hovered_item) {
                XSetForeground(dpy, dwn->gc, colors->workspace_active);
                XFillRectangle(dpy, menu->window, dwn->gc,
                               2, y, menu->width - 4, DROPDOWN_ITEM_HEIGHT);
            }

            unsigned long text_color = (i == menu->hovered_item) ? colors->panel_bg : colors->panel_fg;

            char label[80];
            if (net->connected) {
                snprintf(label, sizeof(label), "> %s", net->ssid);
            } else {
                snprintf(label, sizeof(label), "  %s", net->ssid);
            }

            if (strlen(label) > 25) {
                label[22] = '.';
                label[23] = '.';
                label[24] = '.';
                label[25] = '\0';
            }

            draw_utf8_text(menu->window, DROPDOWN_PADDING, y + text_y_offset, label, text_color);

            char signal[8];
            snprintf(signal, sizeof(signal), "%d%%", net->signal);
            int signal_width = get_text_width(signal);
            int signal_x = menu->width - DROPDOWN_PADDING - signal_width;

            unsigned long signal_color = (i == menu->hovered_item) ? colors->panel_bg : colors->workspace_inactive;
            draw_utf8_text(menu->window, signal_x, y + text_y_offset, signal, signal_color);
        }
    }

    XFlush(dpy);
}

int dropdown_hit_test(DropdownMenu *menu, int x, int y)
{
    (void)x;

    if (menu == NULL || !menu->visible) {
        return -1;
    }

    if (y < DROPDOWN_PADDING || y >= menu->height - DROPDOWN_PADDING) {
        return -1;
    }

    int item = (y - DROPDOWN_PADDING) / DROPDOWN_ITEM_HEIGHT;
    if (item >= 0 && item < menu->item_count) {
        return item;
    }

    return -1;
}

void dropdown_handle_click(DropdownMenu *menu, int x, int y)
{
    if (menu == NULL || !menu->visible) {
        return;
    }

    int item = dropdown_hit_test(menu, x, y);
    if (item >= 0 && item < wifi_state.network_count) {
        WifiNetwork *net = &wifi_state.networks[item];

        if (net->connected) {
            wifi_disconnect();
        } else {
            wifi_connect(net->ssid);
        }

        dropdown_hide(menu);
    }
}

void dropdown_handle_motion(DropdownMenu *menu, int x, int y)
{
    if (menu == NULL || !menu->visible) {
        return;
    }

    int old_hovered = menu->hovered_item;
    menu->hovered_item = dropdown_hit_test(menu, x, y);

    if (menu->hovered_item != old_hovered) {
        dropdown_render(menu);
    }
}


int systray_get_width(void)
{
    pthread_mutex_lock(&state_mutex);
    AudioState audio_snap = audio_state;
    WifiState wifi_snap;
    wifi_snap.connected = wifi_state.connected;
    wifi_snap.enabled = wifi_state.enabled;
    wifi_snap.signal_strength = wifi_state.signal_strength;
    memcpy(wifi_snap.current_ssid, wifi_state.current_ssid, sizeof(wifi_snap.current_ssid));
    pthread_mutex_unlock(&state_mutex);

    char audio_label[32];
    const char *audio_icon = (audio_snap.muted || audio_snap.volume == 0) ? ASCII_VOL_MUTE : ASCII_VOL_HIGH;
    snprintf(audio_label, sizeof(audio_label), "%s%d%%", audio_icon, audio_snap.volume);

    char wifi_label[128];
    const char *wifi_icon_str = (!wifi_snap.enabled || !wifi_snap.connected) ? ASCII_WIFI_OFF : ASCII_WIFI_ON;
    if (wifi_snap.connected && wifi_snap.current_ssid[0] != '\0') {
        snprintf(wifi_label, sizeof(wifi_label), "%s %s %d%%",
                 wifi_icon_str, wifi_snap.current_ssid, wifi_snap.signal_strength);
    } else {
        snprintf(wifi_label, sizeof(wifi_label), "%s", wifi_icon_str);
    }

    return get_text_width(audio_label) + SYSTRAY_SPACING + get_text_width(wifi_label);
}

void systray_render(Panel *panel, int x, int *width)
{
    if (panel == NULL || width == NULL) {
        return;
    }

    const ColorScheme *colors = config_get_colors();

    pthread_mutex_lock(&state_mutex);
    AudioState audio_snap = audio_state;
    WifiState wifi_snap;
    wifi_snap.connected = wifi_state.connected;
    wifi_snap.enabled = wifi_state.enabled;
    wifi_snap.signal_strength = wifi_state.signal_strength;
    memcpy(wifi_snap.current_ssid, wifi_state.current_ssid, sizeof(wifi_snap.current_ssid));
    pthread_mutex_unlock(&state_mutex);

    int font_height = 12;
    if (dwn->xft_font != NULL) {
        font_height = dwn->xft_font->ascent;
    } else if (dwn->font != NULL) {
        font_height = dwn->font->ascent;
    }
    int text_y = (panel->height + font_height) / 2;

    systray_x = x;
    int current_x = x;

    audio_icon_x = current_x;
    char audio_label[32];
    const char *audio_icon = (audio_snap.muted || audio_snap.volume == 0) ? ASCII_VOL_MUTE : ASCII_VOL_HIGH;
    snprintf(audio_label, sizeof(audio_label), "%s%d%%", audio_icon, audio_snap.volume);

    unsigned long audio_color = audio_snap.muted ? colors->workspace_inactive : colors->panel_fg;
    draw_utf8_text(panel->buffer, current_x, text_y, audio_label, audio_color);
    current_x += get_text_width(audio_label) + SYSTRAY_SPACING;

    wifi_icon_x = current_x;
    char wifi_label[128];
    const char *wifi_icon_str = (!wifi_snap.enabled || !wifi_snap.connected) ? ASCII_WIFI_OFF : ASCII_WIFI_ON;

    if (wifi_snap.connected && wifi_snap.current_ssid[0] != '\0') {
        snprintf(wifi_label, sizeof(wifi_label), "%s %s %d%%",
                 wifi_icon_str, wifi_snap.current_ssid, wifi_snap.signal_strength);
    } else {
        snprintf(wifi_label, sizeof(wifi_label), "%s", wifi_icon_str);
    }

    unsigned long wifi_color = wifi_snap.connected ? colors->panel_fg : colors->workspace_inactive;
    draw_utf8_text(panel->buffer, current_x, text_y, wifi_label, wifi_color);
    current_x += get_text_width(wifi_label);

    systray_width = current_x - x;
    *width = systray_width;
}

int systray_hit_test(int x)
{
    if (x >= wifi_icon_x) {
        return 0;
    }
    if (x >= audio_icon_x && x < wifi_icon_x) {
        return 1;
    }
    return -1;
}

void systray_handle_click(int x, int y, int button)
{
    int widget = systray_hit_test(x);

    if (widget == 0) {
        if (volume_slider != NULL && volume_slider->visible) {
            volume_slider_hide(volume_slider);
        }

        if (button == 1) {
            if (wifi_menu == NULL) {
                int panel_height = config_get_panel_height();
                wifi_menu = dropdown_create(wifi_icon_x, panel_height, DROPDOWN_WIDTH);
            }

            if (wifi_menu->visible) {
                dropdown_hide(wifi_menu);
            } else {
                wifi_menu->x = wifi_icon_x;
                wifi_menu->y = config_get_panel_height();
                dropdown_show(wifi_menu);
            }
        } else if (button == 3) {
            if (wifi_state.connected) {
                wifi_disconnect();
            }
        }
    } else if (widget == 1) {
        if (wifi_menu != NULL && wifi_menu->visible) {
            dropdown_hide(wifi_menu);
        }

        if (button == 1) {
            if (volume_slider == NULL) {
                int panel_height = config_get_panel_height();
                volume_slider = volume_slider_create(audio_icon_x, panel_height);
            }

            if (volume_slider->visible) {
                volume_slider_hide(volume_slider);
            } else {
                volume_slider->x = audio_icon_x;
                volume_slider->y = config_get_panel_height();
                volume_slider_show(volume_slider);
            }
        } else if (button == 3) {
            audio_toggle_mute();
            panel_render_all();
        } else if (button == 4) {
            audio_set_volume(audio_state.volume + 5);
            if (volume_slider != NULL && volume_slider->visible) {
                volume_slider_render(volume_slider);
            }
            panel_render_all();
        } else if (button == 5) {
            audio_set_volume(audio_state.volume - 5);
            if (volume_slider != NULL && volume_slider->visible) {
                volume_slider_render(volume_slider);
            }
            panel_render_all();
        }
    }

    (void)y;
}

void systray_update(void)
{

    if (wifi_menu != NULL && wifi_menu->visible) {
        long now = get_time_ms();
        pthread_mutex_lock(&state_mutex);
        long last_scan = wifi_state.last_scan;
        pthread_mutex_unlock(&state_mutex);

        if (now - last_scan >= WIFI_SCAN_INTERVAL) {
            wifi_scan_networks();
            dropdown_render(wifi_menu);
        }
    }
}


void systray_lock(void)
{
    pthread_mutex_lock(&state_mutex);
}

void systray_unlock(void)
{
    pthread_mutex_unlock(&state_mutex);
}

BatteryState systray_get_battery_snapshot(void)
{
    BatteryState snapshot;
    pthread_mutex_lock(&state_mutex);
    snapshot = battery_state;
    pthread_mutex_unlock(&state_mutex);
    return snapshot;
}

AudioState systray_get_audio_snapshot(void)
{
    AudioState snapshot;
    pthread_mutex_lock(&state_mutex);
    snapshot = audio_state;
    pthread_mutex_unlock(&state_mutex);
    return snapshot;
}