import sys,os,argparse,yaml,types,logging,select,time,json
from datetime import datetime

import multiprocessing
from multiprocessing import Process, Pipe

from picadae_api  import Picadae
from AudioDevice  import AudioDevice
from result       import Result

class AttackPulseSeq:
    """ Sequence a fixed chord over a list of attack pulse lengths."""
    
    def __init__(self, audio, api, noteDurMs=1000, pauseDurMs=1000, holdDutyPct=50 ):
        self.audio       = audio
        self.api         = api
        self.outDir      = None           # directory to write audio file and results
        self.pitchL      = None           # chord to play
        self.pulseUsL    = []             # one onset pulse length in microseconds per sequence element
        self.noteDurMs   = noteDurMs      # duration of each chord in milliseconds
        self.pauseDurMs  = pauseDurMs     # duration between end of previous note and start of next
        self.holdDutyPct = holdDutyPct    # hold voltage duty cycle as a percentage (0-100)
        
        self.pulse_idx            = 0     # Index of next pulse 
        self.state                = None  # 'note_on','note_off'
        self.next_ms              = 0     # Time of next event (note-on or note_off)
        self.eventTimeL           = []    # Onset/offset time of each note [ [onset_ms,offset_ms] ]
        self.beginMs              = 0

    def start( self, ms, outDir, pitchL, pulseUsL ):
        self.outDir     = outDir         # directory to write audio file and results
        self.pitchL     = pitchL         # chord to play
        self.pulseUsL   = pulseUsL       # one onset pulse length in microseconds per sequence element
        
        self.pulse_idx  = 0
        self.state      = 'note_on'
        self.next_ms    = ms + 500       # wait for 500ms to play the first note (this will guarantee that there is some empty space in the audio file before the first note)
        self.eventTimeL = [[0,0]] * len(pulseUsL) # initialize the event time         
        self.beginMs    = ms
        self.audio.record_enable(True)   # start recording audio
        self.tick(ms)                    # play the first note
        
    def stop(self, ms):
        self._send_note_off() # be sure that all notes are actually turn-off
        self.audio.record_enable(False)  # stop recording audio
        self._disable()          # disable this sequencer
        self._write()            # write the results

    def is_enabled(self):
        return self.state is not None
    
    def tick(self, ms):

        self.audio.tick(ms)
        
        # if next event time has arrived
        if self.is_enabled() and  ms >= self.next_ms:

            # if waiting to turn note on
            if self.state == 'note_on':
                self._note_on(ms)
        
            # if waiting to turn a note off
            elif self.state == 'note_off':
                self._note_off(ms)                
                self.pulse_idx += 1
                
                # if all notes have been played
                if self.pulse_idx >= len(self.pulseUsL):
                    self.stop(ms)
                    
            else:                
                assert(0)
                    
        
    def _note_on( self, ms ):

        self.eventTimeL[ self.pulse_idx ][0] = ms - self.beginMs
        self.next_ms = ms + self.noteDurMs
        self.state = 'note_off'

        for pitch in self.pitchL:
            self.api.note_on_us( pitch, int(self.pulseUsL[ self.pulse_idx ]) )
            print("note-on:",pitch,self.pulse_idx)

    def _note_off( self, ms ):
        self.eventTimeL[ self.pulse_idx ][1] = ms - self.beginMs
        self.next_ms = ms + self.pauseDurMs
        self.state   = 'note_on'
        
        self._send_note_off()        

    
    def _send_note_off( self ):
        for pitch in self.pitchL:
            self.api.note_off( pitch )
            print("note-off:",pitch,self.pulse_idx)

    def _disable(self):
        self.state = None
        
            
    def _write( self ):

        d = {
            "pulseUsL":self.pulseUsL,
            "pitchL":self.pitchL,
            "noteDurMs":self.noteDurMs,
            "pauseDurMs":self.pauseDurMs,
            "holdDutyPct":self.holdDutyPct,
            "eventTimeL":self.eventTimeL,
            "beginMs":self.beginMs
            }

        print("Writing: ", self.outDir )

        outDir = os.path.expanduser(self.outDir)

        if  not os.path.isdir(outDir):
            os.mkdir(outDir)
        
        with open(os.path.join( outDir, "seq.json" ),"w") as f:
            f.write(json.dumps( d ))

        self.audio.write_buffer( os.path.join( outDir, "audio.wav" ) )
        
            
class CalibrateKeys:
    def __init__(self, cfg, audioDev, api):
        self.cfg      = cfg
        self.seq      = AttackPulseSeq(  audioDev, api, noteDurMs=1000, pauseDurMs=1000, holdDutyPct=50 )
        
        self.label     = None
        self.pulseUsL  = None
        self.chordL   = None
        self.pitch_idx = -1

        
    def start( self, ms, label, chordL, pulseUsL ):
        if len(chordL) > 0:
            self.label     = label
            self.pulseUsL  = pulseUsL
            self.chordL   = chordL
            self.pitch_idx = -1
            self._start_next_chord( ms )
        
        
    def stop( self, ms ):
        self.pitch_idx = -1
        self.seq.stop(ms)

    def is_enabled( self ):
        return self.pitch_idx >= 0

    def tick( self, ms ):
        if self.is_enabled():
            self.seq.tick(ms)

            # if the sequencer is done playing 
            if not self.seq.is_enabled():
                self._start_next_chord( ms ) # ... else start the next sequence

        return None

    def _start_next_chord( self, ms ):

        self.pitch_idx += 1

        # if the last chord in chordL has been played ...
        if self.pitch_idx >= len(self.chordL):
            self.stop(ms)  # ... then we are done
        else:

            pitchL = self.chordL[ self.pitch_idx ]
            
            # be sure that the base directory exists
            outDir = os.path.expanduser( cfg.outDir )
            if not os.path.isdir( outDir ):
                os.mkdir( outDir )

            # form the output directory as "<label>_<pitch0>_<pitch1> ... "
            dirStr = self.label + "_" + "_".join([ str(pitch) for pitch in pitchL ])

            outDir = os.path.join(outDir, dirStr )

            # start the sequencer
            self.seq.start( ms, outDir, pitchL, self.pulseUsL )
        
    

# This is the main application API it is running in a child process.
class App:
    def __init__(self ):
        self.cfg       = None
        self.audioDev  = None
        self.api       = None
        self.calibrate = None
        
    def setup( self, cfg ):
        self.cfg = cfg

        self.audioDev = AudioDevice()

        #
        # TODO: unify the result error handling
        # (the API and the audio device return two diferent 'Result' types
        #
        
        res = self.audioDev.setup(**cfg.audio)

        if res:
            self.api = Picadae( key_mapL=cfg.key_mapL)

            # wait for the letter 'a' to come back from the serial port
            api_res = self.api.wait_for_serial_sync(timeoutMs=cfg.serial_sync_timeout_ms)

            # did the serial port sync fail?
            if not api_res:
                res.set_error("Serial port sync failed.")
            else:
                print("Serial port sync'ed")

                self.calibrate = CalibrateKeys( cfg, self.audioDev, self.api )

    
        return res

    def tick( self, ms ):
        if self.calibrate:
            self.calibrate.tick(ms)

    def audio_dev_list( self, ms ):
        portL = self.audioDev.get_port_list( True )

        for port in portL:
            print("chs:%4i label:%s" % (port['chN'],port['label']))

    def calibrate_keys_start( self, ms, pitchRangeL ):
        chordL = [ [pitch]  for pitch in range(pitchRangeL[0], pitchRangeL[1]+1)]
        self.calibrate.start(  ms, "full", chordL, cfg.full_pulseL )

    def calibrate_keys_stop( self, ms ):
        self.calibrate.stop(ms)

    def quit( self, ms ):
        if self.api:
            self.api.close()
    

def _send_error( pipe, res ):
    if res is None:
        return
    
    if res.msg:
        pipe.send( [{"type":"error", 'value':res.msg}] )

def _send_error_msg( pipe, msg ):
    _send_error( pipe, Result(None,msg))

def _send_quit( pipe ):
    pipe.send( [{ 'type':'quit' }] )
            
# This is the application engine async. process loop
def app_event_loop_func( pipe, cfg ):

    multiprocessing.get_logger().info("App Proc Started.")

    # create the asynchronous application object
    app = App()
    
    res = app.setup(cfg)

    # if the app did not initialize successfully
    if not res:
        _send_error( pipe, res )
        _send_quit(pipe)
        return

    dt0 = datetime.now()

    ms = 0

    while True:
        
        # have any message arrived from the parent process?
        if pipe.poll():

            msg = None
            try:
                msg = pipe.recv()
            except EOFError:
                return

            if not hasattr(app,msg.type):
                _send_error_msg( pipe, "Unknown message type:'%s'." % (msg.type) )
            else:

                # get the command handler function in 'app'
                func = getattr(app,msg.type)

                ms  = int(round( (datetime.now() - dt0).total_seconds() * 1000.0) )
                
                # call the command handler
                if msg.value:
                    res = func( ms, msg.value )
                else:
                    res = func( ms )

                # handle any errors returned from the commands
                _send_error( pipe, res )

            # if a 'quit' msg was recived then break out of the loop
            if msg.type == 'quit':
                _send_quit(pipe)
                break


        # give some time to the system
        time.sleep(0.1)
        
        # calc the tick() time stamp
        ms  = int(round( (datetime.now() - dt0).total_seconds() * 1000.0) )

        # tick the app
        app.tick( ms )
        

class AppProcess(Process):
    def __init__(self,cfg):
        self.parent_end, child_end = Pipe()
        super(AppProcess, self).__init__(target=app_event_loop_func,name="AppProcess",args=(child_end,cfg))
        self.doneFl    = False
        

    def send(self, d):
        # This function is called by the parent process to send an arbitrary msg to the App process
        self.parent_end.send( types.SimpleNamespace(**d) )
        return None
        
    def recv(self):
        # This function is called by the parent process to receive lists of child messages.
        
        msgL = None
        if not self.doneFl and self.parent_end.poll():
            
            msgL = self.parent_end.recv()

            for msg in msgL:
                if msg['type'] == 'quit':
                    self.doneFl = True
            
        return msgL
    
    def isdone(self):
        return self.doneFl
        

class Shell:
    def __init__( self, cfg ):
        self.appProc = None
        self.parseD  = {
            'q':{ "func":'quit',                  "minN":0,  "maxN":0, "help":"quit"},
            '?':{ "func":"_help",                 "minN":0,  "maxN":0, "help":"Print usage text."},
            'a':{ "func":"audio_dev_list",        "minN":0,  "maxN":0, "help":"List the audio devices."},
            'c':{ "func":"calibrate_keys_start",  "minN":1,  "maxN":2, "help":"Calibrate a range of keys."},
            's':{ "func":"calibrate_keys_stop",   "minN":0,  "maxN":0, "help":"Stop key calibration"}
            }

    def _help( self, _=None ):
        for k,d in self.parseD.items():
            s = "{} = {}".format( k, d['help'] )
            print(s)
        return None


    def _syntaxError( self, msg ):
        return Result(None,"Syntax Error: " + msg )
    
    def _exec_cmd( self, tokL ):

        if len(tokL) <= 0:
            return None

        opcode = tokL[0]
        
        if opcode not in self.parseD:
            return self._syntaxError("Unknown opcode: '{}'.".format(opcode))

        d = self.parseD[ opcode ]

        func_name = d['func']
        func      = None

        # find the function associated with this command
        if hasattr(self, func_name ):
            func = getattr(self, func_name )

        try:
            # convert the parameter list into integers
            argL = [ int(tokL[i]) for i in range(1,len(tokL)) ]
        except:
            return self._syntaxError("Unable to create integer arguments.")

        # validate the count of command args
        if  d['minN'] != -1 and (d['minN'] > len(argL) or len(argL) > d['maxN']):                
            return self._syntaxError("Argument count mismatch. {} is out of range:{} to {}".format(len(argL),d['minN'],d['maxN']))


        # call the command function
        if func:
            result = func(*argL)
        else:
            result = self.appProc.send( { 'type':func_name, 'value':argL } )

        return result


    
    def run( self ):

        # create the API object
        self.appProc = AppProcess(cfg)

        self.appProc.start()
            
        print("'q'=quit '?'=help")
        time_out_secs = 1

        # this is the shell main loop
        while True:

            # wait for keyboard activity
            i, o, e = select.select( [sys.stdin], [], [], time_out_secs )

            if i:
                # read the command
                s = sys.stdin.readline().strip() 

                # tokenize the command
                tokL = s.split(' ')


                # execute the command
                result = self._exec_cmd( tokL )

                        
                # if this is the 'quit' command
                if tokL[0] == 'q':
                    break

            # check for msg's from the async application process
            if self._handle_app_msgs( self.appProc.recv() ):
                break


        # wait for the appProc to complete                    
        while not self.appProc.isdone():
            self.appProc.recv()  # drain the AppProc() as it shutdown
            time.sleep(0.1)
        

    def _handle_app_msgs( self, msgL ):
        quitAppFl = False
        if msgL:
            for msg in msgL:
                if msg:
                    if msg['type'] == 'error':
                        print("Error: {}".format(msg['value']))

                    elif msg['type'] == 'quit':
                        quitAppFl = True
                    else:
                       print(msg) 

        return quitAppFl

def parse_args():
    """Parse the command line arguments."""
    
    descStr  = """Picadae auto-calibrate."""
    logL     = ['debug','info','warning','error','critical']
    
    ap = argparse.ArgumentParser(description=descStr)


    ap.add_argument("-c","--config",                     default="cfg/p_ac.yml",  help="YAML configuration file.")
    ap.add_argument("-l","--log_level",choices=logL,     default="warning",             help="Set logging level: debug,info,warning,error,critical. Default:warning")

    return ap.parse_args()
    
            
def parse_yaml_cfg( fn ):
    """Parse the YAML configuration file."""
    
    cfg  = None
    
    with open(fn,"r") as f:
        cfgD = yaml.load(f, Loader=yaml.FullLoader)

        cfg = types.SimpleNamespace(**cfgD['p_ac'])

    return cfg


    

    
if __name__ == "__main__":
    
    logging.basicConfig()

    #mplog = multiprocessing.log_to_stderr()
    #mplog.setLevel(logging.INFO)
    

    args = parse_args()

    cfg = parse_yaml_cfg(args.config)

    shell = Shell(cfg)

    shell.run()