import sys
# So "from ws2812 import WS2812B" finds pico/lib when run from device / or test/
if "lib" not in sys.path:
    sys.path.insert(0, "lib")
if "../lib" not in sys.path:
    sys.path.insert(0, "../lib")
from ws2812 import WS2812B
import time

# --- Rainbow pattern (outside ws2812): pregen double buffer, show via head offset ---

def hue_to_rgb(hue):
    """Hue 0..360 -> (r, g, b). Simple HSV with S=V=1."""
    h = hue % 360
    x = 1 - abs((h / 60) % 2 - 1)
    if h < 60:
        r, g, b = 1, x, 0
    elif h < 120:
        r, g, b = x, 1, 0
    elif h < 180:
        r, g, b = 0, 1, x
    elif h < 240:
        r, g, b = 0, x, 1
    elif h < 300:
        r, g, b = x, 0, 1
    else:
        r, g, b = 1, 0, x
    return (int(r * 255), int(g * 255), int(b * 255))


def make_rainbow_double(num_leds, brightness=1.0):
    """Build 2 full rainbow cycles (2*num_leds pixels, GRB). Returns (double_buf, strip_len).
    head must be in 0..strip_len-1 so DMA reads double_buf[head:head+strip_len] with no copy."""
    n = 2 * num_leds
    double_buf = bytearray(n * 3)
    for i in range(n):
        hue = (i / n) * 360 * 2
        r, g, b = hue_to_rgb(hue)
        g = int(g * brightness) & 0xFF
        r = int(r * brightness) & 0xFF
        b = int(b * brightness) & 0xFF
        o = i * 3
        double_buf[o] = g
        double_buf[o + 1] = r
        double_buf[o + 2] = b
    strip_len = num_leds * 3
    return (double_buf, strip_len)


def show_rainbow(strip, double_buf, strip_len, head):
    """DMA reads directly from double_buf at head; no copy. head in 0..strip_len-1."""
    strip.show(double_buf, head)


# --- Strips + rainbow buffers per strip ---

strips = []
pins = ((2, 291), 
        (3, 290), 
        (4, 283), 
        (7, 278),
        (0, 275), 
        (28, 278),
        (29, 283),
        (6, 290))
sm = 0
for pin, num_leds in pins:
    print(pin, num_leds)
    ws = WS2812B(num_leds, pin, sm, brightness=1.0)  # 1.0 so fill() is visible
    strips.append(ws)
    sm += 1

# One rainbow double buffer per strip (num_leds can differ); no transfer buffer
now = time.ticks_ms()
rainbow_data = [make_rainbow_double(ws.num_leds, ws.brightness) for ws in strips]
# Cumulative LEDs before each strip so rainbow lines up around the ring
cumulative_leds = [0]
for ws in strips[:-1]:
    cumulative_leds.append(cumulative_leds[-1] + ws.num_leds)
# Global phase (bytes); each strip gets head = (phase + cumulative_leds * 3) % strip_len
total_ring_leds = cumulative_leds[-1] + strips[-1].num_leds
bytes_per_cycle = total_ring_leds * 3
print(time.ticks_diff(time.ticks_ms(), now), "ms")
rainbow_head = 0
step = 3

while True:
    now = time.ticks_ms()
    for i, (strip, (double_buf, strip_len)) in enumerate(zip(strips, rainbow_data)):
        head = (rainbow_head + cumulative_leds[i] * 3) % strip_len
        show_rainbow(strip, double_buf, strip_len, head)
    rainbow_head = (rainbow_head + step) % bytes_per_cycle
    #print(time.ticks_diff(time.ticks_ms(), now), "ms")
    time.sleep_ms(10)