#!bin/python

"""

Collector receives device attrs from multiple senders, combines

them, and sends output attrs to hardware. The combining part has

custom code for some attributes.

Input can be over http or zmq.

"""

import asyncio

import functools

import logging

import subprocess

import traceback

from typing import List

from light9 import networking

from light9.collector.collector import Collector

from light9.collector.output import ArtnetDmx, DummyOutput, Output, Udmx  # noqa

from light9.collector.weblisteners import UiListener, WebListeners

from light9.namespaces import L9

from light9.run_local import log

from light9.zmqtransport import parseJsonMessage

from rdfdb.syncedgraph.syncedgraph import SyncedGraph

from starlette.applications import Starlette

from starlette.endpoints import WebSocketEndpoint

from starlette.requests import ClientDisconnect

from starlette.responses import Response

from starlette.routing import Route, WebSocketRoute

from starlette.types import Receive, Scope, Send

from starlette.websockets import WebSocket

from starlette_exporter import PrometheusMiddleware, handle_metrics

import zmq

import zmq.asyncio

# this is the rate sent to usb

class Updates(WebSocketEndpoint, UiListener):

    def __init__(self, listeners, scope: Scope, receive: Receive, send: Send) -> None:

        super().__init__(scope, receive, send)

        self.listeners = listeners

    async def on_connect(self, websocket: WebSocket):

        await websocket.accept()

        log.info('socket connect %s', self.scope['client'])

        self.websocket = websocket

        self.listeners.addClient(self)

    async def sendMessage(self, msgText: bytes):

        await self.websocket.send_bytes(msgText)

    # async def on_receive(self, websocket, data):

    #     json.loads(data)

    async def on_disconnect(self, websocket: WebSocket, close_code: int):

        self.listeners.delClient(self)

async def PutAttrs(collector: Collector, request):

    try:

        body = await request.body()

    except ClientDisconnect:

        log.warning("PUT /attrs request disconnected- ignoring")

        return Response('', status_code=400)

    client, clientSession, settings, sendTime = parseJsonMessage(collector.graph, body)

    collector.setAttrs(client, clientSession, settings, sendTime)

    return Response('', status_code=202)

async def zmqListener(collector):

    try:

        ctx = zmq.asyncio.Context()

        sock = ctx.socket(zmq.SUB)

        sock.bind('tcp://127.0.0.1:9203')

        sock.subscribe(b'setAttr')

        while True:

            [topic, msg] = await sock.recv_multipart()

            if topic != b'setAttr':

                raise ValueError(topic)

            # log.info(f'zmq recv {len(msg)}')

            client, clientSession, settings, sendTime = parseJsonMessage(collector.graph, msg)

            collector.setAttrs(client, clientSession, settings, sendTime)