"""
This python script is used for direction detection.
We design the direction detection for 3 wav files types which has
4, 6 and 8 channels.
"""
import os
import numpy as np
from scipy.io import wavfile
from scipy.signal import butter, lfilter, freqz
from scipy import signal
import matplotlib
import matplotlib.pyplot as plt

offsetVector = []

"""
The funtion butter_highpass, butter_highpass_filter and calculateResidues are shared
Function offset is used for getAngle_for_eight
"""
def butter_highpass(cutoff, fs, order=5):
    nyq = 0.5 * fs
    normal_cutoff = cutoff / nyq
    b, a = signal.butter(order, normal_cutoff, btype='high', analog=False)
    return b, a


def butter_highpass_filter(data, cutoff, fs, order=5):
    b, a = butter_highpass(cutoff, fs, order=order)
    y = signal.filtfilt(b, a, data)
    return y


def calculateResidues(Chan1, Chan2, fs):
    S1 = butter_highpass_filter(Chan1, 100, fs, 7)
    S2 = butter_highpass_filter(Chan2, 100, fs, 7)

    index1 = -1
    index2 = -1
    index = -1

    for i in range(len(S1)):
        if S1[i] > 0.03:
            index1 = i
            break

    for i in range(len(S2)):
        if S2[i] > 0.03:
            index2 = i
            break

    if (index1 < index2):
        index = index1
    else:
        index = index2

    residues = np.mean(np.square(S1[index:index + 401] - S2[index:index + 401]))
    # offsetVector.append( index1 )

    return residues


def do_iac(signal, pairs, fs):
    # signal = data / 32767
    residuesVector = []

    for offset in [5, -5]:

        # Computer overall cancellation error for this angle
        iterator = 0
        residues = 0
        for mic1, mic2 in pairs:

            Chan1 = signal[:, mic1]
            Chan2 = signal[:, mic2]

            S1 = Chan1  # butter_highpass_filter(Chan1 , 100 , fs , 7)
            S2 = Chan2  # butter_highpass_filter(Chan2 , 100 , fs , 7)

            index = -1
            for i in range(len(S1)):
                if (S1[i] > 0.003 and i > 40):
                    index = i
                    break

            if (iterator == 0 or iterator == 4):
                a = S1[index - 15:index + 15]
                b = S2[index - 15:index + 15]
                residues += np.square(np.subtract(a, b))
            elif (iterator == 1 or iterator == 3):
                a = S1[index - 15 + offset // 2:index + 15 + offset // 2]
                b = S2[index - 15:index + 15]
                residues += np.square(np.subtract(a, b))
            elif (iterator == 2):
                a = S1[index - 15 + offset:index + 15 + offset]
                b = S2[index - 15:index + 15]
                residues += np.square(np.subtract(a, b))
            elif (iterator == 5 or iterator == 7):
                a = S1[index - 15 - offset // 2:index + 15 - offset // 2]
                b = S2[index - 15:index + 15]
                residues += np.square(np.subtract(a, b))
            elif (iterator == 6):
                a = S1[index - 15 - offset:index + 15 - offset]
                b = S2[index - 15:index + 15]
                residues += np.square(np.subtract(a, b))

            iterator += 1

        residuesVector.append(np.mean(residues))

    return residuesVector[0] < residuesVector[1]


def calculateResidues_eight(Chan1, Chan2, fs):
    S1 = Chan1  # butter_highpass_filter(Chan1 , 100 , fs , 7 )
    S2 = Chan2  # butter_highpass_filter(Chan2 , 100 , fs , 7 )

    index1 = -1
    index2 = -1
    index = -1

    for i in range(len(S1)):
        if S1[i] > 0.01:
            index1 = i
            break

    for i in range(len(S2)):
        if S2[i] > 0.01:
            index2 = i
            break

    if (index1 < index2):
        index = index1
    else:
        index = index2

    residues = np.mean(np.square(S1[index:index + 401] - S2[index:index + 401]))

    return residues


def getAngle_for_eight(data, fs):
    signal = data / 32767
    for i in range(8):
        column = butter_highpass_filter(signal[:, i], 100, fs, 7)
        signal[:, i] = column

    pairs = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 0)]
    smallestResidues = 100
    closestPair = (0, 0)
    offsetIndex = -1

    for iter in range(8):

        chan1 = signal[:, pairs[iter][0]]
        chan2 = signal[:, pairs[iter][1]]

        residues = calculateResidues_eight(chan1, chan2, fs)

        if (residues < smallestResidues):
            smallestResidues = residues
            closestPair = (pairs[iter])
            offsetIndex = iter

    if do_iac(signal, pairs, fs) == True:
        d1 = abs(offsetIndex - 4)
        d2 = abs((offsetIndex + 4) % 8 - 4)
        if (d1 < d2):
            pass
        else:
            closestPair = pairs[(offsetIndex + 4) % 8]

    mics = (closestPair[0] + 1, closestPair[1] + 1)

    return mics


def getAngle_for_six(data, fs):
    signal = data / 32767
    pairs = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 0)]
    smallestResidues = 100
    closestPair = (0, 0)
    offsetIndex = -1

    for iter in range(6):

        chan1 = signal[:, pairs[iter][0]]
        chan2 = signal[:, pairs[iter][1]]

        residues = calculateResidues(chan1, chan2, fs)

        if (residues < smallestResidues):
            smallestResidues = residues
            closestPair = (pairs[iter])
            offsetIndex = iter

    """ if (offsetVector[offsetIndex] > offsetVector[(offsetIndex+3)%6]   ):
        closestPair = pairs[(offsetIndex+3)%6] """

    mics = (closestPair[0] + 1, closestPair[1] + 1)
    # print(offsetVector)

    return mics


def getAngle_for_four(data, fs):
    signal = data / 32767
    pairs = [(0, 1), (1, 2), (2, 3), (3, 0)]
    smallestResidues = 100
    closestPair = (0, 0)
    offsetIndex = -1

    for iter in range(4):

        chan1 = signal[:, pairs[iter][0]]
        chan2 = signal[:, pairs[iter][1]]

        residues = calculateResidues(chan1, chan2, fs)

        if (residues < smallestResidues):
            smallestResidues = residues
            closestPair = (pairs[iter])
            offsetIndex = iter

    """ if (offsetVector[offsetIndex] > offsetVector[(offsetIndex+3)%6]   ):
        closestPair = pairs[(offsetIndex+3)%6] """

    mics = (closestPair[0] + 1, closestPair[1] + 1)
    # print(offsetVector)

    return mics


def getDirection_Pair(closestPair, num_chan):
    """
    :param closestPair: two closet pair, such as (0,1)
    :param num_chan: channel numbers, such as 8
    :return: in above parameters, should be [7 0 1 2]
    """
    pairs = [0, 0, 0, 0]
    pairs[1] = closestPair[0] - 1
    pairs[2] = closestPair[1] - 1
    pairs[0] = (pairs[1] - int(num_chan/2)) % num_chan
    pairs[3] = (pairs[2] + int(num_chan/2)) % num_chan

    return pairs