# 7 Segment display test file
#
# By Tim

from smbus2 import SMBus
import time
import math
import random

"""
Each segment of the 14‑segment display is represented by a single bit
in a 16‑bit integer. We use a dictionary to map segment names ("a", "b", ...)
to their corresponding bitmask.

Bitmask example:
    1 << 0  = 0000 0000 0000 0001
    1 << 1  = 0000 0000 0000 0010
    1 << 2  = 0000 0000 0000 0100
"""

SEG = {
    "a":  1 << 0,
    "b":  1 << 1,
    "c":  1 << 2,
    "d":  1 << 3,
    "e":  1 << 4,
    "f":  1 << 5,
    "g1": 1 << 6,
    "g2": 1 << 7,
    "h":  1 << 8,
    "i":  1 << 9,
    "j":  1 << 10,
    "k":  1 << 11,
    "l":  1 << 12,
    "m":  1 << 13,
    "dp": 1 << 14,
}

# A convenience list used by some effects
ALL_SEGMENTS = list(SEG.values())

"""
This function takes any number of segment names and returns a combined
bitmask. It lets us write:

    seg("a", "b", "c")

instead of manually OR-ing bits together.
"""

def seg(*names: str) -> int:
    value = 0
    for n in names:
        value |= SEG[n]   # bitwise OR
    return value

"""
FONT is a dictionary mapping characters ("A", "b", "3", etc.)
to the bitmask that lights up the correct segments.

This is a canonical HP‑style font, designed for clarity and legibility.
"""

FONT = {
    # punctuation
    " ": 0,
    "-": seg("g1","g2"),
    "_": seg("d"),
    ".": seg("dp"),
    ":": seg("i","l"),
    "!": seg("i","dp"),
    "?": seg("a","b","g2","k","dp"),
    "/": seg("j","m"),
    "\\": seg("h","k"),
    "'": seg("h"),
    "\"": seg("h","j"),
    ",": seg("m"),

    # digits
    "0": seg("a","b","c","d","e","f"),
    "1": seg("b","c"),
    "2": seg("a","b","g1","g2","e","d"),
    "3": seg("a","b","c","d","g1","g2"),
    "4": seg("f","g1","g2","b","c"),
    "5": seg("a","f","g1","g2","c","d"),
    "6": seg("a","f","e","d","c","g1","g2"),
    "7": seg("a","b","c"),
    "8": seg("a","b","c","d","e","f","g1","g2"),
    "9": seg("a","b","c","d","f","g1","g2"),

    # uppercase
    "A": seg("a","b","c","e","f","g1","g2"),
    "B": seg("a","j","m","g1","d","e","f"),
    "C": seg("a","f","e","d"),
    "D": seg("a","b","c","d","i","l"),
    "E": seg("a","f","e","d","g1","g2"),
    "F": seg("a","f","e","g1","g2"),
    "G": seg("a","f","e","d","c","g2"),
    "H": seg("f","e","b","c","g1","g2"),
    "I": seg("a","d","i","l"),
    "J": seg("b","c","d","e"),
    "K": seg("f","e","g1","j","m"),
    "L": seg("f","e","d"),
    "M": seg("f","e","b","c","h","j"),
    "N": seg("f","e","b","c","h","m"),
    "O": seg("a","b","c","d","e","f"),
    "P": seg("a","b","f","e","g1","g2"),
    "Q": seg("a","b","c","d","e","f","m"),
    "R": seg("a","b","f","e","g1","g2","m"),
    "S": seg("a","f","g1","g2","c","d"),
    "T": seg("a","i","l"),
    "U": seg("f","e","b","c","d"),
    "V": seg("f","e","j","k"),
    "W": seg("f","e","b","c","k","m"),
    "X": seg("h","j","k","m"),
    "Y": seg("b","f","g1","g2","l"),
    "Z": seg("a","j","k","d"),

    # lowercase
    "a": seg("l","g2","c","d"),
    "b": seg("f","e","d","c","g1","g2"),
    "c": seg("g1","g2","e","d"),
    "d": seg("b","c","d","e","g1","g2"),
    "e": seg("g1","g2","e","d","c"),
    "f": seg("a","f","e","g1"),
    "g": seg("m","c","d","g2"),
    "h": seg("f","e","g1","g2","c"),
    "i": seg("i","l"),
    "j": seg("b","c","d"),
    "k": seg("f","e","g1","j","k"),
    "l": seg("f","e"),
    "m": seg("e","l","c","h","j"),
    "n": seg("e","g1","g2","c"),
    "o": seg("g1","g2","c","d","e"),
    "p": seg("a","b","f","e","g1","g2"),
    "q": seg("a","b","c","d","g1","g2"),
    "r": seg("e","g1"),
    "s": seg("a","f","g1","g2","c","d"),
    "t": seg("f","e","d","g1"),
    "u": seg("e","c","d"),
    "v": seg("e","c","j"),
    "w": seg("e","c","k","m"),
    "x": seg("h","j","k","m"),
    "y": seg("h","g2","b","c","d"),
    "z": seg("a","b","d","e","k"),
}

# Helper to fetch glyphs
def glyph_for(ch: str, dot=False) -> int:
    value = FONT.get(ch, 0)
    if dot:
        value |= SEG["dp"]
    return value

"""
This class represents the entire display system.

A class bundles:
• data (the display buffer)
• behavior (methods like scroll_text, chase, rainbow)

Every method that begins with "self" operates on the display instance.
"""

class StarburstHT16K33:

    # Constructor: runs when you create the object
    def __init__(self, bus=1, addr0=0x70, addr1=0x71, brightness=15):
        """
        __init__ is the constructor. It sets up the I²C bus and
        initializes the display chips.
        """
        self.bus = SMBus(bus)
        self.addr = [addr0, addr1]   # two HT16K33 chips
        self.buffer = [0] * 8        # 8 digits
        self.brightness = max(0, min(15, brightness))

        # Initialize each chip
        for ht16k55_addr in self.addr:
            self._cmd(ht16k55_addr, 0x21)              # turn on oscillator
            self._cmd(ht16k55_addr, 0xE0 | self.brightness)
            self._cmd(ht16k55_addr, 0x81)              # display on

    # Low-level I²C helpers
    def _cmd(self, address, cmd):
        """Send a single command byte to the chip."""
        self.bus.write_byte(address, cmd)

    def _write_digit_block(self, address, values):
        """
        Write 4 digits (8 bytes) to one HT16K33 chip.
        Each digit is 16 bits, so we split into two bytes.
        """
        data = []
        for v in values:
            data.append(v & 0xFF)         # low byte
            data.append((v >> 8) & 0xFF)  # high byte
        self.bus.write_i2c_block_data(address, 0x00, data)

    # Basic display operations
    def set_brightness(self, brightness):
        """Set brightness 0–15."""
        self.brightness = max(0, min(15, brightness))
        for a in self.addr:
            self._cmd(a, 0xE0 | self.brightness)

    def set_char(self, pos, ch, dot=False):
        """Write a single character to a position."""
        if 0 <= pos < 8:
            self.buffer[pos] = glyph_for(ch, dot)

    def set_raw(self, pos, mask):
        """Write a raw bitmask to a digit."""
        if 0 <= pos < 8:
            self.buffer[pos] = mask

    def clear(self):
        """Clear the display buffer."""
        for i in range(8):
            self.buffer[i] = 0

    def show(self):
        """Send the buffer to the hardware."""
        self._write_digit_block(self.addr[0], self.buffer[0:4])
        self._write_digit_block(self.addr[1], self.buffer[4:8])

    # Static text writer
    def write_text(self, text: str, align: str = "left"):
        """
        Write up to 8 characters of text.
        Demonstrates:
        • slicing
        • alignment logic
        • enumerate()
        """
        text = text[:8]
        self.clear()

        if align == "right":
            start = max(0, 8 - len(text))
        elif align == "center":
            start = max(0, (8 - len(text)) // 2)
        else:
            start = 0

        for i, ch in enumerate(text):
            self.set_char(start + i, ch)

        self.show()

    # Animated scrolling text with easing curves
    def scroll_text(self, text, scroll_speed=8, pulse=False, loop=False, easing="linear"):
        """
        Demonstrates:
        • nested functions
        • closures
        • easing curves
        • animation loops
        • time-based effects
        """

        scroll_speed = max(0, min(15, scroll_speed))
        base_delay = 0.35 * (0.85 ** scroll_speed)

        # Local function: easing curve
        def ease(t):
            if easing == "linear": return t
            if easing == "in": return t * t
            if easing == "out": return 1 - (1 - t)**2
            if easing == "inout": return 0.5 * (1 - math.cos(math.pi * t))
            return t

        pad = " " * 8
        s = pad + text + pad
        n = len(s)

        pulse_phase = 0.0
        pulse_step = 0.25 + (scroll_speed / 60)
        base_brightness = self.brightness

        while True:
            for offset in range(n - 7):
                t = offset / (n - 8) if n > 8 else 0
                delay = base_delay * (0.5 + ease(t))

                window = s[offset:offset + 8]
                self.clear()
                for i, ch in enumerate(window):
                    self.set_char(i, ch)
                self.show()

                if pulse:
                    pulse_phase += pulse_step
                    wave = 0.5 * (1 - math.cos(pulse_phase))
                    b = 1 + int(wave * 14)
                    self.set_brightness(b)

                time.sleep(delay)

            if not loop:
                break

        self.set_brightness(base_brightness)

    # Marquee wrapper
    def marquee(self, text, scroll_speed=8, pulse=False, cycles=1, easing="linear"):
        """Just calls scroll_text() multiple times."""
        for _ in range(cycles):
            self.scroll_text(text, scroll_speed, pulse, False, easing)

    # Per-segment chase effect
    def chase(self, speed=8, cycles=2):
        """Lights one segment at a time across all digits."""
        delay = 0.15 * (0.85 ** speed)
        for _ in range(cycles):
            for segmask in ALL_SEGMENTS:
                for pos in range(8):
                    self.buffer[pos] = segmask
                self.show()
                time.sleep(delay)

    # Rainbow brightness sweep
    def rainbow(self, cycles=2, speed=8):
        """Brightness follows a sine wave."""
        steps = 60
        delay = 0.05 * (0.85 ** speed)

        for _ in range(cycles):
            for i in range(steps):
                phase = i / steps
                b = 1 + int(14 * 0.5 * (1 - math.cos(2 * math.pi * phase)))
                self.set_brightness(b)
                self.show()
                time.sleep(delay)

    # Sparkle effect
    def sparkle(self, duration=2.0, density=0.15, speed=8):
        """Random segments flicker like stars."""
        delay = 0.05 * (0.85 ** speed)
        end = time.time() + duration

        while time.time() < end:
            self.clear()
            for pos in range(8):
                if random.random() < density:
                    self.buffer[pos] = random.choice(ALL_SEGMENTS)
            self.show()
            time.sleep(delay)

def main():
    """
    Demonstrates:
    • object creation
    • calling methods
    • sequencing animations
    """
    disp = StarburstHT16K33(brightness=10)

    disp.write_text("HELLO")
    time.sleep(1)

    disp.scroll_text("Learning Python!", scroll_speed=1, easing="inout", pulse=True)
    disp.marquee("HP FONT DEMO ", scroll_speed=8, cycles=2)
    disp.marquee("Learning Python! ", scroll_speed=1, cycles=5)

    disp.chase(speed=8)
    disp.write_text("RAINBOW")
    disp.rainbow()

    disp.write_text("SPARKLE")
    disp.sparkle(duration=2.0)

    disp.write_text("DONE")
    time.sleep(1)
    disp.clear()
    disp.show()

if __name__ == "__main__":
    main()