#!bin/python

from run_local import log

from rdflib import URIRef
from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks, Deferred

import logging
import optparse
import os
import time
import treq
import cyclone.web, cyclone.websocket, cyclone.httpclient
from greplin import scales

from cycloneerr import PrettyErrorHandler

from light9.namespaces import L9, RDF
from light9 import networking, showconfig
from rdfdb.syncedgraph import SyncedGraph

from greplin.scales.cyclonehandler import StatsHandler
from light9.effect.settings import DeviceSettings
from rdfdb.patch import Patch

stats = scales.collection('/webServer', scales.PmfStat('setAttr',
                                                       recalcPeriod=1))


def launch(graph):
    if 0:
        reactor.listenTCP(
            networking.captureDevice.port,
            cyclone.web.Application(handlers=[
                (r'/()', cyclone.web.StaticFileHandler, {
                    "path": "light9/web",
                    "default_filename": "patchServer.html"
                }),
                (r'/stats/(.*)', StatsHandler, {
                    'serverName': 'patchServer'
                }),
            ]),
            interface='::',
        )
        log.info('serving http on %s', networking.captureDevice.port)

    def prn():
        width = {}
        for dc in graph.subjects(RDF.type, L9['DeviceClass']):
            for attr in graph.objects(dc, L9['attr']):
                width[dc] = max(
                    width.get(dc, 0),
                    graph.value(attr, L9['dmxOffset']).toPython() + 1)

        user = {}  # chan: [dev]
        for dev in set(graph.subjects(L9['dmxBase'], None)):
            dc = graph.value(dev, RDF.type)
            base = graph.value(dev, L9['dmxBase']).toPython()
            for offset in range(0, width[dc]):
                chan = base + offset
                user.setdefault(chan, []).append(dev)

        for chan in range(1, max(user) + 1):
            dev = user.get(chan, None)
            print(f'chan {chan} used by {dev}')

    graph.addHandler(prn)


def main():
    parser = optparse.OptionParser()
    parser.add_option("-v",
                      "--verbose",
                      action="store_true",
                      help="logging.DEBUG")
    (options, args) = parser.parse_args()
    log.setLevel(logging.DEBUG if options.verbose else logging.INFO)

    graph = SyncedGraph(networking.rdfdb.url, "captureDevice")

    graph.initiallySynced.addCallback(lambda _: launch(graph)).addErrback(
        log.error)
    reactor.run()


if __name__ == '__main__':
    main()