from __future__ import print_function

 import itertools

 from twisted.internet import defer
 from twisted.internet import protocol
 from twisted.internet import reactor

 from twisted.internet import task

 from twisted.protocols import basic

 from responsedict import ResponseDict

 import os
 import sys
 def get_client(host='', port=6600):
     '''returns a deferred'''
     if host is '':
         host = os.getenv('MPD_HOST', 'localhost')
         #print("Using default config: %(host)s:%(port)s" % dict(host=host, port=port), file=sys.stderr)
     ccreator = protocol.ClientCreator(reactor, MPDProtocol)
     return ccreator.connectTCP(host, port)
 
 

 class MPDProtocol(basic.LineReceiver):
     delimiter = '\x0a'

 
     def __init__(self, *a, **kw):

         #basic.LineReceiver.__init__(self, *a, **kw)
         self.commands = []

         self.notifications = []

         self.serverinfo=None

         #self.lineReceived = self.noidlereceive
         self.listeners = {}
         self._idle = False

 
     def fallback(self, data):
         print(data.as_list())
 

     def check_servername(self, line):

         if self.serverinfo is None and line.startswith('OK'):
             self.serverinfo = line.split()

             return True
     set_servname = check_servername
 
     def lineReceived(self, line):
         if self.check_servername(line): pass

         else:

             #print('line received:', repr(line))

             if line.strip() == 'OK':

                 self.reset_idle()

                 method, deferred, data = self.commands.pop(0)
                 d = reactor.callLater(0, deferred.callback, (method, data))

                 for listener in self.listeners.get(method,[]):
                     listener.notify(self, line)

             else:
                 self.commands[0][2].add_line(line.rstrip())
 

     def add_listener(self, listener, command):
         self.listeners.setdefault(command, []).append(listener)
         return listener
 
     def reset_idle(self): self._idle = False
     def idle(self, subsystems=None, listener=None):
         if subsystems is None:subsystems = []
         result = self.sendCommand('idle', *subsystems)
         self._idle = True
         if listener is not None:
             self.add_listener(listener, 'idle')
         return result
 
     def sendCommand(self, command, *args):
         result = None
         if self._idle and command not in {'idle', 'noidle'}:
             if self.commands[0][0] == 'idle': self.commands.pop(0)
             self.sendCommand('noidle')
         if args:
             command = ' '.join(itertools.chain([command], args))

         self.transport.write('%s\n' % command)

         self.commands.append((command, defer.Deferred(), ResponseDict()))
         result = self.commands[-1][1]
         return result

 import pprint
 import traceback, inspect

 @defer.inlineCallbacks

 def run(mpdClient):

     #NOTE: remember, idleHandler not used!
     method, result = yield mpdClient.idle(['playlist'])
     print(method, result)
     method, result = yield mpdClient.sendCommand('playlistinfo')
     print(result.as_list())
     import time
     time.sleep(1)
     run(mpdClient)

 
 def fail(*a, **kw):
     print(*a, **kw)
 
 if __name__ == '__main__':

     get_client().addCallbacks(run,fail)

     reactor.run()