from light9.namespaces import L9, DEV

from webcolors import rgb_to_hex, hex_to_rgb

from colorsys import hsv_to_rgb

import math

from noise import pnoise1

import logging

from light9.effect.settings import DeviceSettings

from light9.effect.scale import scale

from typing import Dict, Tuple, Any

from PIL import Image

import random

SKY = Namespace('http://light9.bigasterisk.com/theater/skyline/device/')

random.seed(0)

log = logging.getLogger('effecteval')

log.info("reload effecteval")

def literalColor(rnorm, gnorm, bnorm):

    return Literal(

        rgb_to_hex([int(rnorm * 255),

                    int(gnorm * 255),

    return max(lo, min(hi, x))

def clamp255(x):

    return min(255, max(0, x))

def _8bit(f):

    if not isinstance(f, (int, float)):

        raise TypeError(repr(f))

    return clamp255(int(f * 255))

class EffectEval(object):

    """

    runs one effect's code to turn effect attr settings into output

    device settings. No state; suitable for reload().

    """

    def __init__(self, graph, effect, simpleOutputs):

        self.graph = graph

        self.effect = effect

        self.simpleOutputs = simpleOutputs

    def outputFromEffect(self, effectSettings, songTime, noteTime):

    ]

    out = {}

    col = rgb_to_hex([int(255 * strength)] * 3)

    for i, dev in enumerate(devs):

        n = noise(songTime * 8 + i * 6.543)

        if n > .4:

            out[(dev, L9['color'])] = col

    return out

def sample8(img, x, y, repeat=False):

    if not (0 <= y < img.height):

    if 0 <= x < img.width:

        return img.getpixel((x, y))

    elif not repeat:

        return (0, 0, 0)

    else:

        return img.getpixel((x % img.width, y))

def effect_image(effectSettings, strength, songTime, noteTime):

    out = {}

    imageSetting = effectSettings.get(L9["image"], 'specks.png')

    imgPath = f'cur/anim/{imageSetting}'

    t_offset = effectSettings.get(L9['tOffset'], 0)

    pxPerSec = effectSettings.get(L9['pxPerSec'], 30)

    img = Image.open(imgPath)

    x = (noteTime * pxPerSec)

    ]:

        color8 = sample8(img, x, y, effectSettings.get(L9['repeat'], True))

        color = map(lambda v: v / 255 * strength, color8)

        color = [v * cs / 255 for v, cs in zip(color, colorScale)]

        if dev in ['cyc1', 'cyc2', 'cyc3', 'cyc4']:

            column = dev[-1]

            out[(SKY[f'cycGreen{column}'], L9['brightness'])] = color[1]

        else:

            out[(dev, L9['color'])] = rgb_to_hex(map(_8bit, color))

    return out

def effect_cyc(effectSettings, strength, songTime, noteTime):

    colorScale = effectSettings.get(L9['colorScale'], '#ffffff')

    r, g, b = map(lambda x: strength * x / 255, hex_to_rgb(colorScale))

        (SKY['cycRed1'], L9['brightness']): r,

        (SKY['cycRed2'], L9['brightness']): r,

        (SKY['cycRed3'], L9['brightness']): r,

        (SKY['cycRed4'], L9['brightness']): r,

        (SKY['cycGreen1'], L9['brightness']): g,

        (SKY['cycGreen2'], L9['brightness']): g,

        (SKY['cycGreen3'], L9['brightness']): g,

        (SKY['cycGreen4'], L9['brightness']): g,

        (SKY['cycBlue1'], L9['brightness']): b,

        (SKY['cycBlue2'], L9['brightness']): b,

        (SKY['cycBlue3'], L9['brightness']): b,

        (SKY['cycBlue4'], L9['brightness']): b,

    return out

cycChase1_members = [

cycChase1_members = cycChase1_members * 20

random.shuffle(cycChase1_members)

def effect_cycChase1(effectSettings, strength, songTime, noteTime):

    colorScale = effectSettings.get(L9['colorScale'], '#ffffff')

    r, g, b = map(lambda x: x / 255, hex_to_rgb(colorScale))

    tintAmount = {'Red': r, 'Green': g, 'Blue': b}

    members = cycChase1_members

    out = {}

    period = float(effectSettings.get(L9['period'], 6 / len(members)))

    for i, dev in enumerate(members):

        cursor = (songTime / period) % float(len(members))

        dist = abs(i - cursor)

        radius = 7

        if dist < radius:

            colorFromUri = str(dev).split('/')[-1].split('cyc')[1][:-1]

            scale = strength * tintAmount[colorFromUri]

            out.update({

                (dev, L9['brightness']): (1 - dist / radius) * scale,

            })

    return out

def effect_parNoise(effectSettings, strength, songTime, noteTime):

    colorScale = effectSettings.get(L9['colorScale'], '#ffffff')

    r, g, b = map(lambda x: x / 255, hex_to_rgb(colorScale))

    out = {}

    speed = 10

    gamma = .6

    for dev in [SKY['strip1'], SKY['strip2'], SKY['strip3']]:

    return out