#!/bin/python

################################################################################
#
#	MarkovSamp - Joe Mariglio <www.joemariglio.com>
#
#===============================================================================
#
#	reads in a raw analysis file containing a transition matrix
#	generates a markov chain of length <length> * <depth> * <reps> 
#	samps
#	outputs a .wav file
#
################################################################################
import re, sys, string, os.path, getopt, random, math, wave, array, cPickle

def parse(infile):
	bytes = infile.readframes(infile.getnframes())
	ints = array.array('h',bytes)
	output = []
	it = iter(ints)
	for i in it:
		output.append(i)
	return output
	
def iter_flatten(iterable):
	it = iter(iterable)
	for e in it:
		if isinstance(e, (list, tuple)):
			for f in iter_flatten(e):
			        yield f
		else:
			yield e
			
def flatten(signal):
	return [i for i in iter_flatten(signal)]
	
def analyze(array, depth, var, dic):
	i = 0
	for item in array:
		print int(100*(float(i) / len(array)))
		context = []
		end = i + depth +1
		if item in dic.keys():		
			for j in range(i+1,end):
				context.append(array[j%len(array)])
			if var == True:
				addContextVar(item, context, dic)
			elif var == False:
				addContext(item, context, dic)
		else:
			for j in range(i+1,end):
				context.append(array[j%len(array)])				
			dic[item] = [context]
		i = i + 1
	return dic
def addContextVar(token, context, dic):
	it = 1
	for item in context:
		dic[token].append(context[0:it])
		it = it + 1

def addContext(token, context, dic):
	dic[token].append(context)
	
def generate(depth, length, reps, dic):
	start = random.choice(dic.keys())
	output = []
	for i in range(0,length):
#		print "start="
#		print start
#		print "value="
#		print dic[start]
		value = random.choice(dic[start])
		start = value[len(value)-1]
		for j in range(0, reps):
			output.append(value)
	print "flattening sample matrix..."
	output = flatten(output)
	return output
	
def main(argv):
	if len(sys.argv) == 7:
		inpath = sys.argv[1]
		outpath = sys.argv[6]
		depth = int(sys.argv[2])
		length = int(sys.argv[3])
		reps = int(sys.argv[4])
		mode = sys.argv[5]
		if mode == "from_data":
			infile = open(inpath, "r")
			dic = cPickle.load(infile)
			print "generating markov chain..."
			output = generate(depth, length, reps, dic)
			print "writing output to file..."
			signal = ''
			for i in range(len(output)):
				signal += wave.struct.pack('h',output[i])
			outfile = wave.open(str(outpath), "wb")
			outfile.setnchannels(1)
			outfile.setsampwidth(2)
			outfile.setframerate(44100)
			outfile.setnframes(length*depth*reps)
			outfile.writeframes(signal)
		elif mode == "to_data":
			var = False
			dic = {}
			infile = wave.open(inpath, "rb")
			lines = parse(infile)
			print "building transition tables for:"
			dic = analyze(lines, depth, var, dic)
			print "pickling matrix..."
			outfile = open(outpath, 'w')
			cPickle.dump(dic, outfile)
			print "writing output to file..."
		elif mode == "to_data_var":
			var = True
			dic = {}
			infile = wave.open(inpath, "rb")
			lines = parse(infile)
			print "building transition tables for:"
			dic = analyze(lines, depth, var, dic)
			print "pickling matrix..."
			outfile = open(outpath, 'w')
			cPickle.dump(dic, outfile)
			print "writing output to file..."
		elif mode == "wave":
			var = False
			dic = {}
			infile = wave.open(inpath, "rb")
			lines = parse(infile)
			print "building transition tables for:"
			dic = analyze(lines, depth, var, dic)
			print "generating markov chain..."
			output = generate(depth, length, reps, dic)
			print "writing output to file..."
			signal = ''
			for i in range(len(output)):
				signal += wave.struct.pack('h',output[i])
			outfile = wave.open(str(outpath), "wb")
			outfile.setnchannels(infile.getnchannels())
			outfile.setsampwidth(infile.getsampwidth())
			outfile.setframerate(infile.getframerate())
			outfile.setnframes(length*depth*reps)
			outfile.writeframes(signal)
		elif mode == "wave_var":
			var = True
			dic = {}
			infile = wave.open(inpath, "rb")
			lines = parse(infile)
			print "building transition tables for:"
			dic = analyze(lines, depth, var, dic)
			print "generating markov chain..."
			output = generate(depth, length, reps, dic)
			print "writing output to file..."
			signal = ''
			for i in range(len(output)):
				signal += wave.struct.pack('h',output[i])
			outfile = wave.open(str(outpath), "wb")
			outfile.setnchannels(infile.getnchannels())
			outfile.setsampwidth(infile.getsampwidth())
			outfile.setframerate(infile.getframerate())
			outfile.setnframes(length*depth*reps)
			outfile.writeframes(signal)
		infile.close()
		outfile.close()
		#print output
	else:
		print "usage: markovSamp.py <inFile> <depth> <length> <reps> <mode> <outFile>"
		print "where <depth> is maximum number of samples per unit,"
		print "<length> is the output length in units,"
		print "<reps> is the number of repeats per unit," 
		print "and <mode> selects from the following behaviors:"
		print "'from_data' makes a wave file from a data file"
		print "'to_data' makes a data file from a wave file, with synchronous units"
		print "'to_data_var' makes a data file from a wave file, with variable units"
		print "'wave' makes a wave from a wave, with synchronous units"
		print "'wav_var' makes a wave from a wave, with variable units"
if __name__ == '__main__':
	import re, sys, string, os.path, getopt, random, math, cPickle
	main(sys.argv[1:])