#!bin/python

"""

Read midi events, write fade levels to graph

"""

import asyncio

import logging

import traceback

from typing import Dict, List, cast

from light9.effect.edit import clamp

import mido

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from rdflib import RDF, ConjunctiveGraph, Literal, URIRef

from rdfdb.syncedgraph.readonly_graph import ReadOnlyConjunctiveGraph

from light9 import networking

from light9.namespaces import L9

from light9.newtypes import decimalLiteral

from light9.run_local import log

from light9.showconfig import showUri

mido.set_backend('alsa_midi.mido_backend')

MAX_SEND_RATE = 30

_lastSet = {}  #midictlchannel:value7bit

currentFaders = {}  # midi control channel num : FaderUri

ctx = URIRef(showUri() + '/fade')

def compileCurrents(graph):

    currentFaders.clear()

    try:

        new = getChansToFaders(graph)

    except ValueError:

        return  # e.g. empty-graph startup

    currentFaders.update(new)

def getGraphMappingNode(g: ReadOnlyConjunctiveGraph | SyncedGraph) -> URIRef:

    mapping = g.value(L9['midiControl'], L9['map'])

    if mapping is None:

        raise ValueError('no :midiControl :map ?mapping')

    midiDev = g.value(mapping, L9['midiDev'])

    ourDev = 'bcf2000'

    if midiDev != Literal(ourDev):

        raise NotImplementedError(f'need {mapping} to have :midiDev {ourDev!r}')

    return mapping

def getCurMappedPage(g: SyncedGraph):

    mapping = getGraphMappingNode(g)

    return g.value(mapping, L9['outputs'])

def setCurMappedPage(g: SyncedGraph, mapping: URIRef, newPage: URIRef):

    g.patchObject(ctx, mapping, L9.outputs, newPage)

def getChansToFaders(g: SyncedGraph) -> Dict[int, URIRef]:

    fadePage = getCurMappedPage(g)

    ret = []

    for f in g.objects(fadePage, L9.fader):

        columnLit = cast(Literal, g.value(f, L9['column']))

        col = int(columnLit.toPython())

        ret.append((col, f))

    ret.sort()

    ctl_channels = list(range(81, 88 + 1))

    out = {}

    for chan, (col, f) in zip(ctl_channels, ret):

        out[chan] = f

    return out

def changePage(g: SyncedGraph, dp: int):

    """dp==-1, make the previous page active, etc. Writes to graph"""

    with g.currentState() as current:

        allPages = sorted(current.subjects(RDF.type, L9.FadePage), key=lambda fp: str(fp))

        mapping = getGraphMappingNode(current)

        curPage = current.value(mapping, L9.outputs)

    if curPage is None:

        curPage = allPages[0]

    idx = allPages.index(curPage)

    newIdx = clamp(idx + dp, 0, len(allPages) - 1)

    print('change from ', idx, newIdx)

    newPage = allPages[newIdx]

    setCurMappedPage(g, mapping, newPage)

def writeHwValueToGraph(graph: SyncedGraph, ctx, fader: URIRef, strength: float):

    log.info(f'setFader(fader={fader}, strength={strength:.03f}')

    valueLit = decimalLiteral(round(strength, 3))

    with graph.currentState() as g:

        fadeSet = g.value(fader, L9['setting'])

    if fadeSet is None:

        raise ValueError(f'fader {fader} has no :setting')

    graph.patchObject(ctx, fadeSet, L9['value'], valueLit)