#!/usr/bin/python
"""Simple demo of oscillating colors."""
from __future__ import division
import colorsys
import lumiversepython
import math
import random
import time

FRAME_RATE = 44
MIN_VALUE = 0
MAX_VALUE = 1
MAX_TIME = 4
MIN_TIME = 0.3
MAX_HUE = 169 / 360
MIN_HUE = 250 / 360

class Vector(object):
    """N-dimensional vector class."""
    def __init__(self, *components):
        """Create a vector from its components."""
        self.components = components

    def __add__(self, other):
        """Add two vectors."""
        return Vector(
            *map(lambda x, y: x + y, zip(self.components, other.components))
        )

    def __sub__(self, other):
        """Subtract two vectors."""
        return Vector(
            *map(lambda x, y: x - y, zip(self.components, other.components))
        )

    def __mul__(self, other):
        """Multiply a vector by a constant."""
        return Vector(*map(lambda x: x * other, self.components))

    def __rmul__(self, other):
        """Multiply a constant by a vector."""
        return self.__mul__(other)

    def __abs__(self):
        """Return the 2-norm of the vector."""
        return math.sqrt(sum(map(lambda x: x * x, self.components)))


def HSV(Vector):
    """HSV 3-vector."""
    def __init__(self, hue, saturation, value)
        super().__init__(hue, saturation, value)

    def h(self):
        """Return hue."""
        return self.components[0]

    def s(self):
        """Return saturation."""
        return self.components[1]

    def v(self):
        """Return value."""
        return self.components[2]


def get_all_lights(rig):
    """Return a list of all panels."""
    return [
        rig.select('$side={}[$sequence={}]'.format(j, i))
            for j in ['top', 'bot'] for i in range(1, 200)
    ]


def pick_HSV():
    """Return a random color in an appropriate interval."""
    hue = random.random() * (MAX_HUE - MIN_HUE) + MIN_HUE
    saturation = random.random()
    value = random.random()
    return HSV(hue, saturation, value)


def transition(start, end, step):
    """Return a vector equal to (end - start) * step + start."""
    return (end - start) * step + start


def random_change():
    """Return a random amount that a light should change each frame."""
    min_time = int(MIN_TIME * FRAME_RATE)
    max_time = int(MAX_TIME * FRAME_RATE)
    return 1 / random.randint(min_time, max_time)


def HSV_to_RGB(h):
    """Convert HSV to a 3-tuple of RGB."""
    return colorsys.hsv_to_rgb(h.h(), h.s(), h.v())


def demo(lights, rig):
    """Do some light things."""
    light_status = [
        {
            'change': 0,
            'light': light,
            'current value': Vector(0, 0, 0),
            'transitioning to': Vector(0, 0, 0),
        }
            for light in lights
    ]
    while True:
        for light_s in light_status:
            change = light_s['change']
            light = light_s['light']
            current_value = light_s['current value']
            transitioning_to = light_s['transitioning to']
            if abs(transitioning_to - current_value) < change:
                change = random_change()
                light_s['change'] = change
                transitioning_to = pick_HSV()
                light_s['transitioning to'] = transitioning_to
            new_color = transition(current_value, transitioning_to, change)
            rgb = HSV_to_RGB(new_color)
            light.setRGBRaw(*rgb)
            light_s['current value'] = new_color
        rig.updateOnce()
        time.sleep(1 / FRAME_RATE)


def main():
    """Run show."""
    rig = lumiversepython.Rig('/home/teacher/Lumiverse/PBridge.rig.json')
    rig.init()
    lights = get_all_lights(rig)
    demo(lights, rig)

if __name__ == '__main__':
    main()