%matplotlib inline

from collections import Counter, defaultdict
from sklearn.cluster import KMeans, Ward
from itertools import izip, groupby
from mingus.midi import fluidsynth
from mingus.containers.Bar import Bar
import mingus.core.value as value
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import sys, copy, random, re, cPickle
fluidsynth.init('/usr/share/sounds/sf2/FluidR3_GM.sf2',"alsa")

# Read in the data and generate the offsets.
# It's okay to generate offsets here since are trigram notes.
# Recall: len = how long note lasts, offset = when it's hit (e.g. stopwatch).
numberofitems = 12345678910112 # some huge placeholder
data = pd.read_csv('./oscar2ngrams.txt', names=['Note','Len'])

# toggle if want to limit to first k items
# 1078 notes in original MIDI file
# numberofitems = 1078
# data = data[:numberofitems]

# Re-add offsets
totaloffset = 0
offsets = []
for i in data['Len']:
    offsets.append(totaloffset)
    totaloffset += i
data["Offset"] = pd.Series(offsets)
data.head()

""" Read in the chord data. """

# Import the chord data.
allchords = pd.read_csv('oscar2chords.txt', skiprows=2)[:].sort("Offset")
allchords.index = xrange(1, len(allchords) + 1)
with open('oscar2chords.txt', 'rb') as f:
    metmark = float(f.readline())
    tsig_num, tsig_den = [i for i in f.readline().replace(' /', '').split()]
    
print "Metronome, Timesig Numerator, Timesig Denominator, # chords played"
print metmark, tsig_num, tsig_den, len(allchords)
allchords.sort(columns="Offset", ascending=True)[:10]
allchords.head()

""" Parse chords into form suitable for analysis. """

# Iterate over a list in chunks of size n. Return tuples (for dict).
def chunks(iterable, n):
    for ix, item in enumerate(iterable):
        if ix == len(iterable) - (n-1): return
        yield tuple(iterable[ix:ix+n])
        
# Convert music21 note to mingus note.
# This version (different from that in 3. Play Notes)
# doesn't return a Note object: returns a string.
def mingifytext(note):
    accidental = re.compile("[A-Z](-|#)[0-9]")
    if accidental.match(note):
        if '-' not in note: note = "%s%s-%s" % (note[0], note[1], note[2])
        else: note = note.replace('-', 'b-')
    else: note = "%s-%s" % (note[0], note[1])
    return note

# Given a MUSIC21 note, such as C5 or D#7, convert it
# into a note on the keyboard between 0 and 87 inclusive.
# Don't convert it for mingus; try to use music21 note style
# as much as possible for all this stuff.
def quantify(note):
    notevals = {
        'C' : 0,
        'D' : 2,
        'E' : 4,
        'F' : 5,
        'G' : 7,
        'A' : 9,
        'B' : 11
    }
    quantized = 0
    octave = int(note[-1]) - 1
    for i in note[:-1]:
        if i in notevals: quantized += notevals[i]
        if i == '-': quantized -= 1
        if i == '#': quantized += 1
    quantized += 12 * octave
    return quantized

# Extract notes in chords.
# Shorter single-note chords: lowest prob of being played
def getChords(allchords, mingify=True, minNoteCount=3):
    chords_poss = []
    for chordname in allchords['FullName']:
        notenames = re.findall("[CDEFGAB]+[-]*[sharp|flat]*[in octave]*[1-9]", chordname)
        for ix in xrange(len(notenames)):
            notenames[ix] = notenames[ix].replace(" in octave ", '').replace("-sharp","#").replace("-flat","-")
        if mingify==True:
            notenames = [mingifytext(note) for note in notenames]
        else:
            notenames = [note for note in notenames]
        toDel = [ix for ix in xrange(len(notenames)) if "6" in notenames[ix] 
                 or "5" in notenames[ix]] # rm chords with notes too high, e.g. oct == 6 or 5
        notenames = [i for ix, i in enumerate(notenames) if ix not in toDel]
        
        # Prune and add the chord, which is a list of notes
        # 1. Does # of notes > min threshold for # of notes needed for a chord?
        # 2. Skip chord if it has half-notes in it (simplify chord comping).
        minReq = True if len(notenames) >= minNoteCount else False
        noHalfNote = True
        for a, b in chunks(notenames, 2):
            if np.abs(quantify(a) - quantify(b)) % 12 == 1:
                noHalfNote = False
                break
        if minReq and noHalfNote:
            chords_poss.append(sorted(notenames))
    result = sorted(list(chords_poss for chords_poss,_ in groupby(chords_poss)))
    result = list(result for result,_ in groupby(result))
    return result

oscarchords = getChords(allchords) # the chordbank
len(oscarchords) # should be same as in (7)

""" The K-Means clustering function for this program. """

# Read in notes and convert into bitwise frame. But might be expensive.
# note sequence is a list in music 21 style, (D/D-)
# note that chordbank and notesequence should be in same format (mingus/m21)
# Returns default dict with notes in whatever music21/mingus style chordbank is already in.

def comp(notesequence, chordbank, limitChords=True, minClustDist=3):
    
    # Load the ML classifier from disk
    with open('part7clf.pkl', 'rb') as fid:
        clf = cPickle.load(fid)
        
    # Load the chord default dictionary from disk
    with open('part7cdict.pkl', 'rb') as fid:
        cdict = cPickle.load(fid)
        
    # Cluster notes into chunks
    quantizednotes = np.array([quantify(note) for note in notesequence]).reshape(-1, 1)
    km = KMeans(n_clusters=random.randrange(2, 4))
    km.fit(quantizednotes)
    
    # get each cluster with its notes
    firstixs = [0]
    clusters = [] # list of (list of notes)s
    currLabel = km.labels_[0]
    currnotes = []
    for ix, (label, note) in enumerate(zip(km.labels_, notesequence)):
        if note == notesequence[-1]:
            currnotes.append(note)
            clusters.append(currnotes)
            break
        if label == currLabel:
            currnotes.append(note)
        else:
            clusters.append(currnotes)
            firstixs.append(ix)
            currLabel = label
            currnotes = []
            currnotes.append(note)

    # Prune clusters (with firstixs): min dist between clusters
    # For example: if clusters at 2 and 3, remove cluster 3 (front load clusters)
    firstIxsDel = []
    for ix in xrange(len(firstixs)):
        if ix == len(firstixs) - 1:
            break
        diff = firstixs[ix + 1] - firstixs[ix]
        if diff <= minClustDist:
            firstIxsDel.append(ix)
    firstixs = [i for ix, i in enumerate(firstixs) if ix not in firstIxsDel]
    clusters = [i for ix, i in enumerate(clusters) if ix not in firstIxsDel]
    
    # for each cluster, find chord that matches
    allmatches = defaultdict()
    for ix, (cluster, firstix) in enumerate(zip(clusters, firstixs)):
        quantized = map(lambda x: quantify(x), cluster)
        npvect = np.zeros((1, 88))
        for q in quantized:
            npvect[0, q] = 1
        matchchordID = clf.predict(npvect)[0]
        allmatches[firstix] = cdict[matchchordID]
            
    # Prune the default dict
    # If # of things > some threshold, remove random items until threshold
    if limitChords == True:
        threshold = random.choice((0, 2))
        if len(allmatches) > threshold:
            for i in xrange(len(allmatches) - threshold):
                allmatches.pop(random.choice(allmatches.keys()))
            
    
    return allmatches

testnotes = ['D5','F5','C6','B5','A-5','A5','C6','B5','A-5','G5','A-5','A5','C6','B5','F5','E5']
comp(testnotes, oscarchords)