// 16x16 LED matrix layout with zigzag pattern
// Coordinates: (0,0) = top-left, (15,15) = bottom-right
// LED indexing follows column-based zigzag pattern

static void __breathing_color_effect(void)
{
    OPERATE_RET rt = OPRT_OK;
    PIXEL_COLOR_T current_color = {0};
    uint32_t step = 20;
    uint32_t max_cycles = 3;
    uint32_t color_num = CNTSOF(cCOLOR_ARR);

    // Static variables for frame-by-frame animation
    static uint32_t static_intensity = 0;
    static int32_t static_direction = 1;
    static uint32_t static_cycle_count = 0;
    static uint32_t static_color_index = 0;
    static bool animation_complete = false;

    // Reset animation if complete
    if (animation_complete) {
        static_intensity = 0;
        static_direction = 1;
        static_cycle_count = 0;
        static_color_index = 0;
        animation_complete = false;
    }

    // Single frame update
    static_intensity += (static_direction * step);

    if (static_intensity >= COLOR_RESOLUION) {
        static_intensity = COLOR_RESOLUION;
        static_direction = -1;
    } else if (static_intensity <= 0) {
        static_intensity = 0;
        static_direction = 1;
        static_cycle_count++;
        static_color_index = (static_color_index + 1) % color_num;

        if (static_cycle_count >= max_cycles) {
            animation_complete = true;
        }
    }

    current_color.red = (cCOLOR_ARR[static_color_index].red * static_intensity) / COLOR_RESOLUION;
    current_color.green = (cCOLOR_ARR[static_color_index].green * static_intensity) / COLOR_RESOLUION;
    current_color.blue = (cCOLOR_ARR[static_color_index].blue * static_intensity) / COLOR_RESOLUION;
    current_color.warm = (cCOLOR_ARR[static_color_index].warm * static_intensity) / COLOR_RESOLUION;
    current_color.cold = (cCOLOR_ARR[static_color_index].cold * static_intensity) / COLOR_RESOLUION;

    TUYA_CALL_ERR_GOTO(tdl_pixel_set_single_color(sg_pixels_handle, 0, LED_PIXELS_TOTAL_NUM, &current_color), __ERROR);
    TUYA_CALL_ERR_GOTO(tdl_pixel_dev_refresh(sg_pixels_handle), __ERROR);

__ERROR:
    PR_ERR("breathing color effect error");
    return;
}

static void __2d_wave_effect(void)
{
    OPERATE_RET rt = OPRT_OK;
    PIXEL_COLOR_T tinted_color = {0};
    uint32_t max_cycles = 2;  // Reduced cycles to match other effects
    float max_radius = 11.0f; // Maximum radius to cover the 16x16 matrix
    float wave_speed = 0.5f;  // Faster wave speed for smoother transitions
    float color_saturation = 1.0f;
    float color_value = 1.0f;

    // Static variables for frame-by-frame animation
    static uint32_t static_cycle_count = 0;
    static float static_wave_radius = 0.0f;
    static float static_color_hue = 0.0f;
    static bool animation_complete = false;

    // Reset animation if complete
    if (animation_complete) {
        static_cycle_count = 0;
        static_wave_radius = 0.0f;
        static_color_hue = 0.0f;
        animation_complete = false;
    }

    // Clear LEDs for each frame
    PIXEL_COLOR_T off_color = {0};
    TUYA_CALL_ERR_GOTO(tdl_pixel_set_single_color(sg_pixels_handle, 0, LED_PIXELS_TOTAL_NUM, &off_color), __ERROR);

    // Calculate current wave radius
    static_wave_radius += wave_speed;
    if (static_wave_radius > max_radius) {
        static_wave_radius = 0.0f;
        static_cycle_count++;

        if (static_cycle_count >= max_cycles) {
            animation_complete = true;
        }
    }

    // Continuous color spectrum transition at center
    static_color_hue += 2.0f; // Faster color transition for smoother effect
    if (static_color_hue >= 360.0f) {
        static_color_hue = 0.0f;
    }

    // Base color from spectrum is calculated per LED in the loop below

    // Apply wave effect to each LED
    for (uint32_t y = 0; y < 16; y++) {
        for (uint32_t x = 0; x < 16; x++) {
            float distance = __distance_from_center(x, y);
            float angle = __calculate_angle(x, y);

            // Check if LED is within the expanding wave
            if (distance <= static_wave_radius) {
                // Calculate hue based on distance from center for constant color bands
                float distance_hue = (distance / max_radius) * 180.0f; // Reduced range for smoother transitions
                float current_hue = static_color_hue - distance_hue;   // Hue shifts based on distance
                if (current_hue < 0.0f)
                    current_hue += 360.0f;

                // Convert hue to RGB for constant color
                float h = current_hue / 60.0f;
                float c = color_value * color_saturation;
                float x_val = c * (1.0f - fabsf(fmodf(h, 2.0f) - 1.0f));
                float m = color_value - c;

                float r, g, b;
                if (h < 1.0f) {
                    r = c;
                    g = x_val;
                    b = 0;
                } else if (h < 2.0f) {
                    r = x_val;
                    g = c;
                    b = 0;
                } else if (h < 3.0f) {
                    r = 0;
                    g = c;
                    b = x_val;
                } else if (h < 4.0f) {
                    r = 0;
                    g = x_val;
                    b = c;
                } else if (h < 5.0f) {
                    r = x_val;
                    g = 0;
                    b = c;
                } else {
                    r = c;
                    g = 0;
                    b = x_val;
                }

                // Set constant color (no intensity fade)
                tinted_color.red = (uint32_t)((r + m) * COLOR_RESOLUION);
                tinted_color.green = (uint32_t)((g + m) * COLOR_RESOLUION);
                tinted_color.blue = (uint32_t)((b + m) * COLOR_RESOLUION);
                tinted_color.warm = 0;
                tinted_color.cold = 0;

                // Apply 8-directional tinting
                __apply_directional_tint(&tinted_color, angle, &tinted_color);

                // Set LED color
                uint32_t led_index = __matrix_coord_to_led_index(x, y);
                if (led_index > 0 && led_index <= LED_PIXELS_TOTAL_NUM) {
                    TUYA_CALL_ERR_GOTO(tdl_pixel_set_single_color(sg_pixels_handle, led_index, 1, &tinted_color),
                                       __ERROR);
                }
            }
        }
    }

    TUYA_CALL_ERR_GOTO(tdl_pixel_dev_refresh(sg_pixels_handle), __ERROR);
    // tal_system_sleep(30); // Removed - main loop controls timing // Faster refresh for smoother transitions

__ERROR:
    PR_ERR("2D wave effect error");
    return;
}

static uint32_t __matrix_coord_to_led_index(uint32_t x, uint32_t y)
{
    // Convert 2D matrix coordinates to 1D LED index
    // Handles zigzag pattern for proper LED addressing
    if (x % 2 == 0) {
        // Even column: top to bottom
        led_index = (x * 16 + y);
    } else {
        // Odd column: bottom to top
        led_index = (x + 1) * 16 - 1 - y;
    }
    return led_index;
}

// HSV to RGB conversion for smooth color transitions
float h = hue / 60.0f;
float c = saturation * value;
float x = c * (1.0f - fabsf(fmodf(h, 2.0f) - 1.0f));
// ... RGB calculation based on hue sector

// Frame-by-frame animation using static variables
static uint32_t frame_count = 0;
static float wave_radius = 0.0f;
static bool animation_complete = false;

// Reset animation when complete
if (animation_complete) {
    frame_count = 0;
    wave_radius = 0.0f;
    animation_complete = false;
}

// Choose your LED type by uncommenting the appropriate driver
TUYA_CALL_ERR_RETURN(tdd_ws2812_driver_register(device_name, &dev_init_cfg));
// TUYA_CALL_ERR_RETURN(tdd_sk6812_driver_register(device_name, &dev_init_cfg));
// TUYA_CALL_ERR_RETURN(tdd_sm16703p_driver_register(device_name, &dev_init_cfg));

// Modify effect parameters
#define LED_PIXELS_TOTAL_NUM 256    // Total LED count
#define LED_CHANGE_TIME      800    // Effect timing (ms)
#define COLOR_RESOLUION      1000u  // Color depth

// Adjust animation speed and duration
static uint32_t max_cycles_per_effect = 200;  // Effect duration
tal_system_sleep(50);  // Frame delay (ms)

static void __custom_effect(void)
{
    // Your custom animation logic here
    // Use the matrix coordinate system
    // Apply color mathematics
    // Refresh display
}

// Extend the font database in led_font.h
{'@', {0x00, 0x3C, 0x66, 0x6E, 0x6A, 0x6E, 0x60, 0x3C}, 8},