import numpy as np
import scipy.io.wavfile
from features import mfcc
from features import logfbank
from features import base


def fadeinout(s,slength,elength):
    for i in range(0,slength):
        m = float(i)/slength;
        s[i]*=m
    for i in range(0,elength):
        m = float(i)/elength;
        s[(len(s)-1)-i]*=m
    return s

def normalise(s):
    m = 0
    for i in range(0,len(s)):
        if m<s[i]: m=s[i]
    if m>0:
        s/=float(m/10000.0)
    return s

def chop(wav,size,overlap):
    ret = []
    pos = 0
    seg = []
    samples = wav[1]
    while (pos+size<len(samples)):
        ret.append(fadeinout(samples[pos:pos+size],50,100))
        pos+=(size-overlap)
    return ret

def fftify(chopped):
    return map(lambda i: np.fft.fft(i), chopped)

def mfccify(chopped,rate):
    ret = []
    for sig in chopped:
        ret.append(logfbank(sig,rate))
    return ret

def fftdiff(a,b):
    return (abs(a-b)).sum(dtype=np.float128)

def diffify(a,b):
    return map(lambda a,b: fftdiff(a,b), a, b)

def search(fft,bank):
    closest = 99999999999999999
    ret = -1
    for i,tfft in enumerate(bank):
        dist = fftdiff(fft,tfft)
        if dist<closest:
            ret = i
            closest = dist
    print(ret)
    return ret

def unit_test():
    print(fftdiff(np.array([0,0,0,0]),np.array([1,1,1,1])))
    #assert(fftdiff(np.array([0,0,0,0]),np.array([1,1,1,1]))==1)
    print(fftdiff(np.array([-100,-1000,0,0]),np.array([-1,-1,-1,-1])))
    print(fadeinout(np.array([10,10,10,10,10,10,10]),3))

#unit_test()

class transponge():
    def __init__(self,chp_size,chp_overlap,dst_filename):
        dst =  scipy.io.wavfile.read(dst_filename)
        self.src_chp=[]
        self.src_fft=[]
        self.chp_size = chp_size
        self.chp_overlap = chp_overlap
        self.dst_chp = chop(dst,self.chp_size,self.chp_overlap)
        print(self.chp_overlap)
        print (len(self.dst_chp))
        #self.dst_fft = mfccify(self.dst_chp,dst[0])
        self.dst_fft = fftify(self.dst_chp)
        self.dst_chp = [] # clear
        self.dst_size = len(dst[1])

    def add(self,src_filename):
        src =  scipy.io.wavfile.read(src_filename)
        src_chp=chop(src,self.chp_size,self.chp_overlap)
        self.src_chp+=src_chp
        #self.src_fft+=mfccify(src_chp,src[0])
        self.src_fft+=fftify(src_chp)

    def process(self):
        out = np.zeros(self.dst_size,dtype=self.src_chp[0].dtype)
        pos = 0
        for i,seg in enumerate(self.dst_fft):
            # collect indices of closest sections
            ii = search(seg,self.src_fft)
            for s in range(0,self.chp_size):
                if pos+s<self.dst_size:
                    out[pos+s]+=self.src_chp[ii][s]*0.5
            pos+=(self.chp_size-self.chp_overlap)
            print((i/float(len(self.dst_fft)))*100.0)
            if i%10==0: scipy.io.wavfile.write("mfcc-outr.wav",44100,out)



    def render(self):
        t = []
        ret = np.zeros(self.dst_size,dtype=self.src_chp[0].dtype)
        pos = 0
        for i in self.indices:
            #t.append(self.src_chp[i])
            #print(pos)
            for s in range(0,self.chp_size):
                if pos+s<self.dst_size:
                    ret[pos+s]+=self.src_chp[i][s]*0.5
            pos+=(self.chp_size-self.chp_overlap)
        return ret
        #return np.concatenate(t)

def run(l):
    t = transponge(l,int(l*0.75),"pw2.wav")
#    t.add("water.wav")
#    t.add("cumbia.wav")
#    t.add("pista07.wav")
    t.add("sailingbybit.wav")
#    t.add("full.wav")
    print("processing")
    t.process()

run(68)