"""

alternate to the mpd music player, for ascoltami

"""

from twisted.internet import task

from light9.metrics import metrics

log = logging.getLogger()

class Player:

    def __init__(self, autoStopOffset=4, onEOS=None):

        """autoStopOffset is the number of seconds before the end of

        song before automatically stopping (which is really pausing).

        onEOS is an optional function to be called when we reach the

        task.LoopingCall(self.watchTime).start(.050)

        #bus = self.pipeline.get_bus()

        # not working- see notes in pollForMessages

        #self.watchForMessages(bus)

    def watchTime(self):

        try:

            self.pollForMessages()

            t = self.currentTime()

            if self._lastWatchTime < self._autoStopTime < t:

                log.info("autostop")

                self.pause()

            self._lastWatchTime = t

        except Exception:

            traceback.print_exc()

    def watchForMessages(self, bus):

        """this would be nicer than pollForMessages but it's not working for

        me. It's like add_signal_watch isn't running."""

        bus.add_signal_watch()

            # working.

            if msg.type == mt.ERROR:

                log.error(repr(msg.parse_error()))

            if msg.type == mt.EOS:

                if self._onEOS is not None:

                    self._onEOS(self.getSong())

            if msg.type == mt.STREAM_STATUS:

                (statusType, _elem) = msg.parse_stream_status()

                if statusType == Gst.StreamStatusType.ENTER:

                    self.setupAutostop()

    def seek(self, t):

        if not isSeekable:

            raise ValueError('seek_simple failed')

        self._playStartTime = time.time()

    def setSong(self, songLoc, play=True):

        """

        uri like file:///my/proj/light9/show/dance2010/music/07.wav

        """

        log.info("set song to %r" % songLoc)

        self.pipeline.set_state(Gst.State.READY)

        self.preload(songLoc)

        self.pipeline.set_property("uri", songLoc)

        return cur / Gst.SECOND

    def duration(self):

        success, dur = self.playbin.query_duration(Gst.Format.TIME)

        if not success:

            return 0

        return dur / Gst.SECOND

    def states(self):

        """json-friendly object describing the interesting states of

        the player nodes"""

        success, state, pending = self.playbin.get_state(timeout=0)

    def pause(self):

        self.pipeline.set_state(Gst.State.PAUSED)

    def isAutostopped(self):

        """

        are we stopped at the autostop time?

        """

        if self.autoStopOffset < .01:

            return False

        pos = self.currentTime()

        autoStop = self.duration() - self.autoStopOffset

    def resume(self):

        self.pipeline.set_state(Gst.State.PLAYING)

    def setupAutostop(self):

        dur = self.duration()

        if dur == 0:

            raise ValueError("duration=0, can't set autostop")

        self._autoStopTime = (dur - self.autoStopOffset)

        log.info("autostop will be at %s", self._autoStopTime)

        # pipeline.seek can take a stop time, but using that wasn't

        # working out well. I'd get pauses at other times that were

import asyncio

import json

import logging

import socket

import subprocess

import time

from typing import cast

from rdflib import RDFS, Graph, URIRef

from sse_starlette.sse import EventSourceResponse

from starlette.requests import Request

from starlette.responses import JSONResponse, PlainTextResponse

from light9.namespaces import L9

from light9.showconfig import getSongsFromShow, showUri, songOnDisk

log = logging.getLogger()

_songUris = {}  # locationUri : song

def songLocation(graph, songUri):

    loc = URIRef("file://%s" % songOnDisk(songUri))

    _songUris[loc] = songUri

    return loc

    if params.get('pause', False):

        player.pause()

    if params.get('resume', False):

        player.resume()

    if 't' in params:

        player.seek(params['t'])

    return PlainTextResponse("ok")

async def timeStream(request: Request):

    graph = cast(Graph, request.app.state.graph)

    player = cast(Player, request.app.state.player)

    async def event_generator():

        last_sent = None

        last_sent_time = 0.0

        while True:

            now = time.time()

            msg = currentState(graph, player)

            if msg != last_sent or now > last_sent_time + 2:

                event_data = json.dumps(msg)

                yield event_data

                last_sent = msg

                last_sent_time = now