import inspect

import logging

from dataclasses import dataclass

from typing import Callable, List, Optional

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from rdflib import RDF

from rdflib.term import Node

from light9.effect.effect_function_library import EffectFunctionLibrary

from light9.effect.settings import DeviceSettings, EffectSettings

from light9.namespaces import L9

class EffectEval2:

    """Runs one effect code to turn EffectSettings (e.g. strength) into DeviceSettings"""

    graph: SyncedGraph

    uri: EffectUri

    lib: EffectFunctionLibrary

    config: Optional[Config] = None

    def __post_init__(self):

        self.graph.addHandler(self._compile)

    def _compile(self):

        if not self.graph.contains((self.uri, RDF.type, L9['Effect'])):

            return

        try:

            effectFunction = typedValue(EffectFunction, self.graph, self.uri, L9['effectFunction'])

            effSets = []

            devSettings = None

            for s in self.graph.objects(self.uri, L9['setting']):

                attr = typedValue(EffectAttr, self.graph, s, L9['effectAttr'])

                if attr == L9['deviceSettings']:

                    value = typedValue(Node, self.graph, s, L9['value'])

            try:

                effectFunction = typedValue(EffectFunction, self.graph, self.uri, L9['effectFunction'])

            except ValueError:

                raise ValueError(f'{self.uri} has no :effectFunction')

            func = self.lib.getFunc(effectFunction)

            # This should be in EffectFunctionLibrary

            funcArgs = list(inspect.signature(func).parameters.values())

            self.config = Config(effectFunction, esettings, devSettings, func, funcArgs)

        except Exception:

            log.error(f"while compiling {self.uri}")

    def compute(self, songTime: float, inputs: EffectSettings) -> DeviceSettings:

        """

        calls our function using inputs (publishedAttr attrs, e.g. :strength)

        and effect-level settings including a special attr called :deviceSettings

        with DeviceSettings as its value

        """

        if self.config is None:

            return DeviceSettings(self.graph, [])

        c = self.config

        kw = {}