#!/usr/bin/env python

# this is a fork from semprini/ascotalmi to use mpd

""" a separate player program from Semprini.py. name means 'listen to

me' in italian.

features and limitations:

  xmlrpc interface for:

    getting the current time in the playing song

    requesting what song is playing

    saying what song should play

todo:

presong and postsong silence

never continue through playlist. maybe use 1-song mpd playlists?

install pympd, (pypi too)

"""

from __future__ import division,nested_scopes

from optparse import OptionParser

import os,math

import Tkinter as tk

from twisted.internet import reactor,tksupport

from twisted.internet.error import CannotListenError

from twisted.web import xmlrpc, server

import run_local

from light9 import networking, showconfig

import sys

sys.path.append("/home/drewp/projects/pympd")

from pympd import Mpd

appstyle={'fg':'white','bg':'black'}

class XMLRPCServe(xmlrpc.XMLRPC):

    def __init__(self,player):

        xmlrpc.XMLRPC.__init__(self)

        self.player=player

    def xmlrpc_echo(self,x):

        return x

    def xmlrpc_playfile(self,musicfilename):

        self.player.play(musicfilename)

        return 'ok'

    def xmlrpc_stop(self):

        self.player.state.set('stop')

        return 'ok'

    def xmlrpc_gettime(self):

        """returns seconds from start of song"""

        return float(self.player.current_time.get())

    def xmlrpc_songlength(self):

        """song length, in seconds"""

        return float(self.player.total_time.get())

    def xmlrpc_songname(self):

        """song filename, or None"""

        return self.player.filename or "No song"

class Player:

    """semprini-style access to mpd"""

    def __init__(self, app, playlist, media=None):

        self.mpd = Mpd()

        reactor.connectTCP('dash',6600,self.mpd)

        self.state = tk.StringVar()

        self.state.set("stop") # 'stop' 'pause' 'play'

        self.current_time = tk.DoubleVar()

        self.total_time = tk.DoubleVar()

        self.filename_var = tk.StringVar()

        self.pollStatus()

    def pollStatus(self):

        self.mpd.status().addCallback(self.pollStatus2)

    def pollStatus2(self,stat):

        for attr1,attr2 in [('state','state'),

                            ('time_elapsed','current_time'),

                            ('time_total','total_time')]:

            if not hasattr(stat,attr1):

                continue

            v = getattr(stat,attr1)

            if getattr(self,attr2).get() != v:

                getattr(self,attr2).set(v)

        self.mpd.currentsong().addCallback(self.pollStatus3)

    def pollStatus3(self,song):

        if hasattr(song,'file'):

            self.filename_var.set(song.file)

        # if we're stopped, there will be no file, and the UI will

        # show a stale filename. that means Play might not play the

        # indicated file (if another mpd client has changed the song

        # choice). another method is needed to get the file that is

        # about to play

        reactor.callLater(.05, self.pollStatus)

    def play(self, song_path):

        self.mpd.play()

    def stop(self):

        self.mpd.stop()

    def seek_to(self, time):

        self.mpd.seek(seconds=time)

    def play_pause_toggle(self):

        def finish(status):

            if status.state == 'play':

                self.mpd.pause()

            else:

                self.mpd.play()

        self.mpd.status().addCallback(finish)

def buildsonglist(root,songfiles,player):

    songlist=tk.Frame(root,bd=2,relief='raised',bg='black')

    prefixlen=len(os.path.commonprefix(songfiles))

    # include to the last os.sep- dont crop path elements in the middle

    prefixlen=songfiles[0].rfind(os.sep)+1 

    maxsfwidth=max([len(x[prefixlen:]) for x in songfiles])

    for i,sf in enumerate(songfiles):

        b=tk.Button(songlist,text=sf[prefixlen:],width=maxsfwidth,

                    anchor='w',pady=0,bd=0,relief='flat',

                    font="arial 17 bold")

        b.bind("<Configure>",lambda ev,b=b:

               b.config(font="arial %d bold" % min(15,int((ev.height-3)*.8))))

        try:

            # rainbow colors

            frac=i/len(songfiles)

            b.config(bg='black',

                     fg="#%02x%02x%02x" % tuple([int(255*(.7+.3*

                                                          math.sin(frac*4+x))

                                                     ) for x in 1,2,3]))

        except Exception,e:

            print "rainbow failed: %s"%e

        b.config(command=lambda sf=sf: player.play(sf))

        b.pack(side='top',fill='both',exp=1,padx=0,pady=0,ipadx=0,ipady=0)

        def color_buttons(x, y, z, sf=sf, b=b):

            name = player.filename_var.get()

            if name == sf[prefixlen:]:

                b['bg'] = 'grey50'

            else:

                b['bg'] = 'black'

        player.filename_var.trace("w", color_buttons)

    return songlist

def buildseeker(master,player):

    seeker=tk.Frame(master,bg='black')

    scl=tk.Scale(seeker, orient="horiz",

                 from_=-4,to_=100,

                 sliderlen=20,width=20,

                 res=0.001,

                 showvalue=0,

                 variable=player.current_time,

                 troughcolor='black',

                 bg='lightblue3',

                 )

    scl.pack(fill='x',side='top')

    left_var=tk.DoubleVar()

    for txt,var,fmt in (('Current',player.current_time,"%.2f"),

                    ('Song len',player.total_time,"%.2f",),

                    ('Left',left_var, "%.2f"),

                    ('Song',player.filename_var, "%s"),

                    ('State', player.state, "%s")):

        tk.Label(seeker,text=txt,

                 relief='raised',bd=1,font='arial 9',

                 **appstyle).pack(side='left')

        l = tk.Label(seeker,width=7, anchor='w', text=var.get(),

                 relief='sunken',bd=1,font='arial 12 bold',

                 bg='#800000',fg='white')

        if txt == 'Song':

            l.config(anchor='e')

        l.pack(side='left',expand=1, fill='x')

        var.trace_variable('w', lambda a,b,c,l=l,fmt=fmt,var=var: l.config(text=fmt % var.get()))

    # update end time as the song changes

    player.total_time.trace("w",lambda *args: (

        scl.config(to_=player.total_time.get()+15)))

    def fixleft(*args):

        # update time-left variable

        left_var.set(player.total_time.get()-player.current_time.get())

        if 1: # new dmcc code

            if player.current_time.get() < 0 or left_var.get() < 0:

                scl['troughcolor'] = 'blue'

            else:

                scl['troughcolor'] = 'black'

    player.total_time.trace("w",fixleft)

    player.current_time.trace("w",fixleft)

    # dragging the scl changes the player time (which updates the scl)

    # due to mpd having to seemingly play a whole block at every new

    # seek point, we may want a mode that pauses playback while the

    # mouse is down (or is moving too fast; or we've sent a seek too

    # recently)

    scl.mouse_state=0

    def set_mouse_state(evt):

        scl.mouse_state = evt.state

    def seeker_cb(time):

        if scl.mouse_state:

            player.seek_to(float(time))

    scl.config(command=seeker_cb)

    scl.bind("<Motion>", set_mouse_state)

    scl.bind("<B1-Motion>",set_mouse_state)

    def b1down(evt):

        scl.mouse_state = 1

    def b1up(evt):

        scl.mouse_state = 0

    scl.bind("<ButtonPress-1>", b1down)

    scl.bind("<ButtonRelease-1>", b1up)

    return seeker

############################

parser=OptionParser()

(options,songfiles)=parser.parse_args()

if len(songfiles)<1:

    songfiles = [f for f in os.listdir(showconfig.musicDir())

                 if f.endswith('wav')]

root=tk.Tk()

root.wm_title("ascoltami")

root.wm_geometry("656x736+263+0")

root.config(bg="black")

player=Player(None,None)

songlist=buildsonglist(root,songfiles,player)

songlist.pack(fill='both',exp=1)

f2=tk.Frame(bg='black')

f3=tk.Frame(f2,bg='black')

statebuttons = {} # lowercased name : Button

for txt,cmd,key in (('Stop', player.stop, "<Control-s>"),

                ('Pause', player.play_pause_toggle, "<Control-p>"),

                ('Skip Intro',lambda: player.seek_to(-.5), "<Control-i>"),

                ):

    b = tk.Button(f3,text=txt,command=cmd, font='arial 16 bold', height=3,**appstyle)

    b.pack(side='left', fill='x', expand=1)

    # keyboard bindings

    root.bind(key, lambda evt, cmd=cmd: cmd())

    statebuttons[txt.lower()] = b

f3.pack(side='top',fill='x')

def update_state_buttons(*args):

    global statebuttons

    state = player.state.get()

    print "State", state

    if state in ('stop', 'pause'):

        statebuttons['pause']['text'] = 'Play'

    else:

        statebuttons['pause']['text'] = 'Pause'

    colors = {'stop' : 'red',

              'play' : 'blue',

              'pause' : 'green'} # very confusing -- play and pause supply colors

                                 # for each other!

    for name, button in statebuttons.items():

        if name == 'pause' and state not in ('stop', 'pause'):

            name = 'play'

        if state == name: # name gets changed sometimes for 'pause' -- see right above

            button['bg'] = colors.get(name, 'black')

        else:

            button['bg'] = 'black'

player.state.trace_variable('w', update_state_buttons)

update_state_buttons()

seeker=buildseeker(f2,player)

seeker.pack(fill='x',exp=1)

f2.pack(side='bottom',fill='x')

tksupport.install(root,ms=10)

try:

  reactor.listenTCP(networking.musicPort(),server.Site(XMLRPCServe(player)))

  print "started server on %s" % networking.musicPort()

except CannotListenError:

  print "no server started- %s is in use" % networking.musicPort()

root.bind("<Destroy>",lambda ev: reactor.stop)

root.protocol('WM_DELETE_WINDOW', reactor.stop)

def func_tracer(frame, event, arg):

    if event == "call":

        co = frame.f_code

        if 'twisted' not in co.co_filename and \

            'python2.3' not in co.co_filename and \

            co.co_filename != '<string>':

            print co.co_filename, co.co_name #, co_firstlineno

    return func_tracer

# sys.settrace(func_tracer)

reactor.run()