### rainbow.py
### Author: Matthew Reed
### Rainbow array scrolls across the display. Rainbow generated using overlapping sin waves. The frequency, phase shift, center, and width all affect the output.
### Inspired by https://krazydad.com/tutorials/makecolors.php

import sys
import time
import signal
import logging
import configparser
from enum import Enum

import math
import matrix

class Rainbow:

    class MODES(Enum):
        TWO_D = 0
        LINEAR = 1
        SOLID = 2

    def __init__(self, config, parent, matrix, controller):
        self.logger = logging.getLogger('paint')
        self.config = config
        self.parent = parent
        self.matrix = matrix
        self.controller = controller
        
    def reset(self):
        pass
        
    def splash(self):
    
        r = matrix.Colors.RED.value
        o = matrix.Colors.ORANGE.value
        y = matrix.Colors.YELLOW.value
        g = matrix.Colors.GREEN.value
        b = matrix.Colors.BLUE.value
        p = matrix.Colors.PURPLE.value
        q = matrix.Colors.OFF.value
        
        splash = [
            [q, q, q, q, q, q, q, q],
            [q, q, q, q, q, q, q, q],
            [q, q, q, q, q, q, q, q],
            [q, r, o, y, g, b, p, q],
            [q, r, o, y, g, b, p, q],
            [q, q, q, q, q, q, q, q],
            [q, q, q, q, q, q, q, q],
            [q, q, q, q, q, q, q, q],
        ]
        
        for x in range(0, self.matrix.WIDTH):
            for y in range(0, self.matrix.HEIGHT):
                self.matrix.set_pixel(x, y, splash[y][x])
        
        self.matrix.update()
        
    def run(self):
    
        center = 128;
        width = 127;
        frequency = .1;
        
        mode = self.MODES.TWO_D
    
        #start timers and counters
        self.start_time = time.time()
        last_time = time.time()
        
        led_iteration_count = 0
        frame_count = 0
        
        keep_going = True
        
        while keep_going:
            
            for event in self.controller.read_input():
                if event.code == 313 and event.value == 1:
                    keep_going = False
                elif event.code == 305 and event.value == 1:
                    mode = self.MODES((mode.value + 1) % len(self.MODES))
                elif event.code == 16:
                    if event.value == 1:
                        #dpad right
                        pass
                    if event.value == -1:
                        #dpad left
                        pass
                elif event.code == 17:
                    if event.value == 1:
                        #dpad down
                        frequency = frequency - 0.05
                        if frequency <= 0.05:
                            frequency = 0.05
                        print(frequency)
                    if event.value == -1:
                        #dpad up
                        frequency = frequency + 0.05
                        if frequency >= 1:
                            frequency = 1
                        print(frequency)
                        
            
            if time.time() > last_time + 0.1:
                last_time = time.time()
                    
                for y in range(self.matrix.HEIGHT):
                    if mode == self.MODES.TWO_D:
                        phaseShift = 2*math.pi - y*(math.pi/(self.matrix.HEIGHT-1))
                    else:
                        phaseShift = 4
                    for x in range(self.matrix.WIDTH):
                        if mode == self.MODES.SOLID:
                            i = frame_count % 128
                        else:
                            i = (x + frame_count) % 128
                        red = math.sin(frequency*i + 0) * width + center;
                        green = math.sin(frequency*i + phaseShift/2) * width + center;
                        blue = math.sin(frequency*i + phaseShift) * width + center;
                        
                        self.matrix.set_pixel(x, y, (red, green, blue))
                
                self.matrix.update()
                
                led_iteration_count = (led_iteration_count + 1) % self.matrix.NUM_LEDS
                frame_count = frame_count + 1
                
            time.sleep(0.01)