# Copyright (c) 2011 Edward Langley
# All rights reserved.

import mpdprotocol
import responsedict
import urwid
import itertools
from twisted.internet import defer

class SelectableText(urwid.Text):
    def keypress(self, __, key): return key
    def selectable(self): return True

class Playlist(urwid.WidgetWrap):
    def __init__(self, columns, col_display, plylst=None):
        if plylst == None:
            plylst = responsedict.ResponseDict()
        self.columns = columns
        self.display_pref = col_display
        self.texts = self.get_texts(plylst.as_list())
        self.body = urwid.SimpleFocusListWalker([])
        self.make_playlist()

        self.titles = self.make_columns()
        self.header = urwid.Pile([self.titles, urwid.Divider('-')])
        widget = urwid.ListBox(self.body)
        widget = urwid.Frame(widget, self.header)
        urwid.WidgetWrap.__init__(self, widget)

    def make_columns(self):
        return urwid.Columns([
                ('weight',self.display_pref[c].weight,SelectableText(self.display_pref[c].dispname))
                    for c in self.columns
            ],1)

    def get_texts(self, choices):
        #TODO: re-work column info to separate data from presentation info
        texts = []
        for x in choices:
            texts.append([])
            for col in self.columns:
                display = self.display_pref[col]
                texts[-1].append((display.weight,display.transform(x.get(col,[""])[0])))
        return texts

    def update_texts(self, choices):
        self.texts = self.get_texts(choices.as_list())
        self.update_playlist()

    def make_body(self):
        for x in self.texts:
            new_widg = [('weight',wgt,SelectableText(it,wrap='clip')) for wgt,it in x]
            new_widg = urwid.Columns(new_widg, 1)
            new_widg = urwid.AttrMap(new_widg, 'unselected', 'selected')
            self.body.append(new_widg)

    def update_playlist(self):
        del self.body[:]
        self.make_body()

    def make_playlist(self):
        self.make_body()

def exit_on_q(key):
    if key in ('q', 'Q'):
        try: raise urwid.ExitMainLoop()
        finally: reactor.stop()

cols = [
    'Pos',
    'Date',
    'Album',
    'Artist',
    'AlbumArtist',
    'Title',
]

import collections
class DisplayDict(collections.Mapping):
    def __init__(self, data):
        self.row_class=collections.namedtuple('displaytuple', ['dispname','weight','transform'])
        self.data = self.normalize(data)
    def normalize(self, data):
        out = {}
        for key,val in data.iteritems():
            dispname,weight,transform = None,1,lambda x:x
            if hasattr(val, '__iter__'):
                if len(val) == 3: dispname,weight,transform = val
                if len(val) == 2: dispname,weight = val
            if dispname is None:
                dispname = key
            out[key] = self.row_class(dispname, weight, transform)
        return out
    def __getitem__(self, key):
        head, _, tail = key.partition('.')
        if tail:
            try:
                return getattr(self.data[head], tail)
            except AttributeError, e:
                raise KeyError('Key not found: %s' % key)
        else:
            return self.data[head]
    def __iter__(self):
        return iter(self.data)
    def __len__(self):
        return len(self.data)


col_display = DisplayDict(
    dict(
        Pos=('#',1,lambda x: x and str(int(x) + 1)),
        Date=('Year', 4),
        Album=(None,8),
        Artist=(None,8),
        AlbumArtist=('Album Artist',5),
        Title=(None,13),
))

@defer.inlineCallbacks
def get_playlist():
    client = yield mpdprotocol.get_client()
    method, data = yield client.sendCommand('playlistinfo')
    loop.widget.update_texts(data)
    loop.draw_screen()
    while True:
        idle = yield client.idle(['playlist'])
        method, data = yield client.sendCommand('playlistinfo')
        loop.widget.update_texts(data)
        loop.draw_screen()

from twisted.internet import reactor
palette = [
    ('selected', 'white', 'black'),
    ('selected', 'black', 'white'),
]
loop = urwid.MainLoop(Playlist(cols, col_display), palette, event_loop=urwid.TwistedEventLoop(), unhandled_input=exit_on_q)
reactor.callWhenRunning(get_playlist)
loop.run()