class Ascoltami:

    def __init__(self, graph, show):

        self.graph = graph

        self.player = Player(onEOS=self.onEOS, autoStopOffset=0)

        self.show = show

        self.playlist = Playlist.fromShow(graph, show)

    def onEOS(self, song):

        self.player.pause()

        self.player.seek(0)

        thisSongUri = webapp.songUri(self.graph, URIRef(song))

        try:

            nextSong = self.playlist.nextSong(thisSongUri)

        except NoSuchSong:  # we're at the end of the playlist

            return

        self.player.setSong(webapp.songLocation(self.graph, nextSong), play=False)

def main():

    Gst.init(None)

    graph = showconfig.getGraph()

    asco = Ascoltami(graph, showconfig.showUri())

    app = Starlette(

        debug=True,

        routes=[

            Route("/config", webapp.get_config),

            Route("/time", webapp.get_time, methods=["GET"]),

            Route("/time", webapp.post_time, methods=["POST"]),

            Route("/time/stream", webapp.timeStream),

            Route("/song", webapp.post_song, methods=["POST"]),

            Route("/songs", webapp.get_songs),

            Route("/seekPlayOrPause", webapp.post_seekPlayOrPause),

            Route("/output", webapp.post_output, methods=["POST"]),

            Route("/go", webapp.post_goButton, methods=["POST"]),

        ],

    )

    app.add_middleware(PrometheusMiddleware)

    app.add_route("/metrics", handle_metrics)

    app.state.graph = graph

function byId(id: string): HTMLElement {

  return document.getElementById(id)!;

}

export interface TimingUpdate {

  // GET /ascoltami/time response

  duration: number;

  next: string; // e.g. 'play'

  playing: boolean;

  song: string;

  started: number; // unix sec

  t: number; // seconds into song

  state: { current: { name: string }; pending: { name: string } };

}

(window as any).finishOldStyleSetup = async (times: { intro: number; post: number }, updateFreq: number, timingUpdate: (data: TimingUpdate) => void) => {

  let currentHighlightedSong = "";

  // let lastPlaying = false;

    byId("currentSong").innerText = data.song;

    if (data.song != currentHighlightedSong) {

      showCurrentSong(data.song);

    }

    byId("currentTime").innerText = data.t.toFixed(1);

    byId("leftTime").innerText = (data.duration - data.t).toFixed(1);

    byId("leftAutoStopTime").innerText = Math.max(0, data.duration - times.post - data.t).toFixed(1);

    byId("states").innerText = JSON.stringify(data.state);

    //   document.querySelector("#timeSlider").slider({ value: data.t, max: data.duration });

    timingUpdate(data);

  }

  function showCurrentSong(uri: string) {

    document.querySelectorAll(".songs div").forEach((row: Element, i: number) => {

      if (row.querySelector("button")!.dataset.uri == uri) {

        row.classList.add("currentSong");

      } else {

        row.classList.remove("currentSong");

      }

    });

    currentHighlightedSong = uri;

  }

  const data = await (await fetch("api/songs")).json();

  data.songs.forEach((song: { uri: string; label: string }) => {

    const button = document.createElement("button");

    // link is just for dragging, not clicking

    const link = document.createElement("a");

    const n = document.createElement("span");

    n.classList.add("num");

    n.innerText = song.label.slice(0, 2);

    link.appendChild(n);

    const sn = document.createElement("span");

    sn.classList.add("song-name");

    sn.innerText = song.label.slice(2).trim();

    link.appendChild(sn);

    link.setAttribute("href", song.uri);

    link.addEventListener("click", (ev) => {

      ev.stopPropagation();

      button.click();

    });

    button.appendChild(link);

    button.dataset.uri = song.uri;

    button.addEventListener("click", async (ev) => {

      await fetch("api/song", { method: "POST", body: song.uri });

      showCurrentSong(song.uri);

    });

    const dv = document.createElement("div");

    dv.appendChild(button);

    document.querySelector(".songs")!.appendChild(dv);

  });

};

        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

    return EventSourceResponse(event_generator())

async def get_songs(request: Request) -> JSONResponse:

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

    songs = getSongsFromShow(graph, request.app.state.show)

    songs_data = [

        {  #

            "uri": s,

            "path": graph.value(s, L9['songFilename']),

            "label": graph.value(s, RDFS.label)

        } for s in songs

    ]

    return JSONResponse({"songs": songs_data})

async def post_song(request: Request) -> PlainTextResponse:

    """post a uri of song to switch to (and start playing)"""

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

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