#!/usr/bin/env python
# coding: latin-1
''' Maakt een .b40 file uit een .xml file (MusicXML).
muziek = [parts], part = [maten], maat = [voices]
voice = [[dur, tijd, noot1, noot2, ....]]
per part: len (voices) = maxvoice
vceCnt telt het aantal stemmen in het hele stuk (d.w.z. over meerdere parts)
In deze versie worden eerst alle noten in één part archter elkaar gezet en dan pas worden
gebonden noten samengevoegd. Dit in verband met het terugzetten van de tijd door backup, waardoor
eem gebonden noot tussen twee stemmen verloren gaat als voor de backup (naar de andere stem)
de noot nog een keer voorkomt.
'''
import operator, sys, os
import xml.etree.ElementTree as E

b40List = ['Cbb','Cb','C','C#','C##','-','Dbb','Db','D','D#','D##','-','Ebb','Eb','E','E#','E##','Fbb','Fb','F',
           'F#','F##','-','Gbb','Gb','G','G#','G##','-','Abb','Ab','A','A#','A##','-','Bbb','Bb','B','B#','B##']
b40Dict = dict (zip (b40List, range (len (b40List))))

gtikkenPerKwart = 384   # ticks per quarter note
gC5 = False             # central C == C5 if gC5 else C4

def ntB40 (p, o, alt):
    if alt:
        alt = int (alt)
        while alt > 0: p += '#'; alt -= 1
        while alt < 0: p += 'b'; alt += 1
    b40 = o * 40 + b40Dict[p] + 1
    return str (b40)

def doNote (n):
    global tijd, maxVoice
    chord = n.find ('chord') != None
    p = n.findtext ('pitch/step')
    alt = n.findtext ('pitch/alter')
    o = n.findtext ('pitch/octave')
    r = n.find ('rest')
    dur = int (n.findtext ('duration'))
    v = int (n.findtext ('voice')) - 1
    if v > maxVoice: maxVoice = v
    if r != None: noot = 'z'
    else: noot = ntB40 (p, int (o) + (1 if gC5 else 0), alt)
    tie = n.find ('tie')
    if tie != None and tie.get ('type') == 'stop': noot = '-' + noot
    if chord: addChord (v, noot)
    else:     appendNote (v, dur, noot)

def doAttr (e):
    global durUnit
    kmaj = ['Cb','Gb','Dd','Ab','Eb','Bb','F','C','G','D','A', 'E', 'B', 'F#','C#']
    kmin = ['Ab','Eb','Bb','F', 'C', 'G', 'D','A','E','B','F#','C#','G#','D#','A#']
    dvstxt = e.findtext ('divisions')
    if dvstxt: # niet alle attribuut knopen hebben een divisions (b.v. key change)
        #~ print 'divisions per kwart', int (dvstxt)
        durUnit = int (dvstxt)
    key = ''
    f = e.findtext ('key/fifths')
    m = e.findtext ('key/mode')
    if m == 'major': key = kmaj [7 + int (f)]
    if m == 'minor': key = kmin [7 + int (f)] + 'min'
    if key:
        for v in range (nVoices): appendNote (v, 0, 'K:%s\n' % key)
    beats = e.findtext ('time/beats')
    if beats:
        met = beats + '/' + e.findtext ('time/beat-type')
        for v in range (nVoices): appendNote (v, 0, 'M:%s\n' % met)

def appendNote (v, dur, noot):
    global tijd
    t = vtimes [v]
    if tijd > t: voices [v].append ([tijd - t, t, 'z'])
    if tijd < t: raise 'kenniet'
    voices [v].append ([dur, tijd, noot])
    tijd += int (dur)
    vtimes[v] = tijd

def addChord (v, noot):
    t = voices[v][-1]
    voices[v][-1] = t + [noot]

def addBar ():
    global voices
    for v in range (nVoices): appendNote (v, 0, ' |\n')
    gMaten.append (voices)
    voices = [[] for i in range (nVoices)]

def outMaat (i, mbuf, ns):
    for nx in mbuf:
        dur = nx[0]  * gTikkenPerKwart / durUnit
        tijd = nx[1] * gTikkenPerKwart / durUnit
        if not dur: continue # alleen echte noten
        for noot in nx[2:]: # de noot of noten in chord
            if 'z' in noot: continue # skip rusten
            ns.append ((tijd, noot, dur))

def remTies (ns):
    global noten
    tieBufDur = {}  # tijdelijk vasthouden van noten voor evt. volgende tie
    tieBufTijd = {} # twee aparte buffers voor duur en tijd
    ns.sort ()
    for tijd, noot, dur in ns: # nu nog voor gebonden noten checken
        if noot.startswith ('-'): tieBufDur [noot[1:]] += dur
        else:
            if noot in tieBufDur: # bij de volgdende niet gebonden noot vorige uitvoeren
                noten.append ((tieBufTijd [noot], noot, tieBufDur[noot]))
            tieBufTijd [noot] = tijd # alle noten vast houden voor evt. volgende tie
            tieBufDur [noot] = dur
    for noot, dur in tieBufDur.iteritems (): # alle vastgehouden noten nu uitvoeren
        noten.append ((tieBufTijd[noot], noot, dur))

def outVoices (vceCnt):         # output alle stemmen in een part, nummering begint bij vceCnt
    global tijd, gMaten, voices, vtimes, tupcnt, maxVoice, noten
    ns = []
    for maat in gMaten: # aantal gebruikte voices in gMaten = maxVoice + 1
        mbuf = reduce (operator.concat, maat[:maxVoice + 1]) # plak de gebruikte voices aanelkaar
        outMaat (vceCnt, mbuf, ns)    # alle stemmen in deze maat => ns, en nummer telkens vanaf vceCnt
    remTies (ns)
    vceCnt += maxVoice + 1 # de volgende part start met aansluitend hogere voice nummers
    gMaten = []
    voices = [[] for i in range (nVoices)]
    vtimes = nVoices * [0]
    tijd = 0
    tupcnt = 0
    maxVoice = 0
    return vceCnt

def xml2b40 (fnmext, tpk=384, C5=1): # base name, ticks per quarter, central C == C5
    global nVoices, gMaten, voices, vtimes, tijd, tupcnt, maxVoice, vceCnt, noten, gTikkenPerKwart, gC5
    gTikkenPerKwart = tpk
    gC5 = C5
    nVoices = 10
    gMaten = []
    voices = [[] for i in range (nVoices)]
    vtimes = nVoices * [0]
    tijd = 0
    tupcnt = 0
    maxVoice = 0
    vceCnt = 1
    noten = []

    e = E.parse (fnmext)
    parts = e.findall ('part')
    noten = []      # de uitvoer van alle noten
    for p in parts:
        maten = p.findall ('measure')
        for maat in maten:
            es = maat.getchildren ()
            for e in es:
                if e.tag == 'note': doNote (e)
                elif e.tag == 'attributes': doAttr (e)
                elif e.tag == 'backup':
                    dt = int (e.findtext ('duration'))
                    tijd -= dt
                elif e.tag == 'forward':
                    dt = int (e.findtext ('duration'))
                    tijd += dt
                else: pass
            addBar ()
        vceCnt = outVoices (vceCnt)
    offnoten = []
    for tijd, noot, dur in noten:
        noot = int (noot) # straks numeriek ordenen i.v.m. vergelijken oude b40 files
        offnoten.append ((tijd, noot))
        offnoten.append ((tijd + dur, -noot))
    noten = offnoten
    noten.sort ()
    return noten


if __name__ == '__main__':
    from optparse import OptionParser
    parser = OptionParser (usage='%prog [-h] [-g TPQ] [--C5] <file1>')
    parser.add_option ("-t", action="store", type="int", help="ticks per quarternote", default=120, metavar='TPQ')
    parser.add_option ("--C5", action="store_true", help="central C is C5", default=False)
    parser.add_option ("-w", action="store_true", help="write .b40 file", default=False)
    options, args = parser.parse_args ()
    if len (args) < 1: parser.error ('file argument needed')
    fnmext = args [0]
    fnm, ext = os.path.splitext (fnmext)
    if ext != '.xml': parser.error ('.xml file needed file needed')
    if not os.path.exists (fnmext): parser.error ('%s does not exist' % fnmext)
    xml2b40 (fnmext, options.t, options.C5)
    if options.w:
        g = file (fnm + '.b40', 'w')
        for tijd, noot in noten: g.write ('%d %s\n' % (tijd, noot))
        g.close ()
        print fnm + '.b40 written'
    else:
        for tijd, noot in noten: print tijd, noot