eri

import wave_helper
import os.path
import math

SAMPLE_RATE = 2000
MAX_VOLUME = 32767
MIN_VOLUME = -32768
FREQUENCYDICT = {"A": 440, "B": 494, "C": 523, "D": 587, "E": 659, "F": 698,
                 "G": 784, "Q": 0}


def composeWav():
    """ accepts input of composition instruction file, creates composition and returns to edit menu (if file not found
    or invalid it repeats the promp until a correct file name is entered"""

    while True:
        fileName = input("Enter name of composition instructions file\n")
        if os.path.isfile(fileName):

            print("Composition complete")
            wavfile = createCompList(fileName)
            return wavfile

        else:
            print("Invalid File")


def calcSampleVal(frequency, index):
    """ calculation formula for sample value given frequency, index"""
    if frequency == 0:
        return 0
    return MAX_VOLUME * math.sin(
        math.pi * 2 * (index / (SAMPLE_RATE / frequency)))


def createCompList(compFile):
    f = open(compFile)
    f1 = f.readlines()
    f.close()
    noteList = list()
    for lines in f1:
        if (lines.split() != ""):
            noteList.extend(lines.split())

    compList = list()

    for i in range(0, len(noteList), 2):
        for ind in range(int((float(noteList[i + 1]) / 16) * SAMPLE_RATE)):
            compList.append(
                [int(calcSampleVal(FREQUENCYDICT.get(noteList[i]), ind)),
                 int(calcSampleVal(FREQUENCYDICT.get(noteList[i]), ind))])

    return compList


def finish_creating_menu(frame_rate, audio_data):
    new_file_name = input("please enter the file name you "
                          "wish to save the new wav file in: ")

    save_wave(frame_rate, audio_data, new_file_name)


def get_file_rate_data():
    file_name = input("Please enter the file name")
    return wave_helper.load_wave(file_name)


def file_editing_main(inner_action_editing, file_data):
    def reverse(data_to_reverse):
        """
        switch the position of the first and last, seconde and last -1 and so
        on lists in data
        :param data_to_reverse: list of data made of list of 2 ints each
        :return: the reversed data
        """
        data_len = len(data_to_reverse)
        if data_len == 1:
            return data_to_reverse
        elif data_len % 2 == 0:
            for i in range(int(data_len / 2)):
                temp = data_to_reverse[i]
                data_to_reverse[i] = data_to_reverse[(data_len - 1) - i]
                data_to_reverse[(data_len - 1) - i] = temp
        else:
            for i in range(int(data_len / 2)):
                temp = data_to_reverse[i]
                data_to_reverse[i] = data_to_reverse[(data_len - 1) - i]
                data_to_reverse[(data_len - 1) - i] = temp
        return data_to_reverse

    def increase_speed(data_to_speedup):
        """
        cut even notes from the list of lists, which make the overoall music shorter
        :param data_to_speedup:list of list that represents the volume data
        needed shortening
        :return: the shortened list of lists
        """
        data_len = len(data_to_speedup)
        sped_up_data = []
        if data_len % 2 == 0:
            if data_len != 2:
                for i in range(int(data_len / 2)):
                    sped_up_data.append(data_to_speedup[i * 2])
            else:
                return
        else:
            for i in range(int(data_len / 2)):
                sped_up_data.append(data_to_speedup[i * 2])
            sped_up_data.append(data_to_speedup[data_len - 1])
        return sped_up_data

    def decrease_speed(data_to_slowdown):
        """
        adds note between every 2 existing notes, made of the average sound of its nighboores
        from the list of lists, which make the overoall music slower
        :param data_to_speedup:list of list that represents the volume data
        needed lengthening (slowing)
        :return: the slow downed list
        """
        data_len = len(data_to_slowdown)
        slowed_down_data = []
        for i in range(
                (data_len - 1)):  # append for each stands for each cell,
            # 2 inserts minos the last one thats only last
            slowed_down_data.append(data[i])
            left_ear_data_to_add = int((data[i][0] + data[i + 1][0]) / 2)
            right_ear_data_to_add = int((data[i][1] + data[i + 1][1]) / 2)
            slowed_down_data.append(
                [left_ear_data_to_add, right_ear_data_to_add])
        slowed_down_data.append(data[data_len - 1])
        return slowed_down_data

    def increase_volume(data_to_voul_up):
        """
        multiply the values of the 'play-List' list by 1.2 up to the value
        +- 32767
        :param data_to_voul_up:
        :return: list of modifide lists made of [left ear sound, right ear sound]
        """

        for i in range(len(data_to_voul_up)):
            data_to_voul_up[i][0] = int(data_to_voul_up[i][0] * 1.2)
            data_to_voul_up[i][1] = int(data_to_voul_up[i][1] * 1.2)

            if data_to_voul_up[i][0] > MAX_VOLUME:
                data_to_voul_up[i][0] = MAX_VOLUME
            elif data_to_voul_up[i][0] < MIN_VOLUME:
                data_to_voul_up[i][0] = MIN_VOLUME

            if data_to_voul_up[i][1] > MAX_VOLUME:
                data_to_voul_up[i][1] = MAX_VOLUME
            elif data_to_voul_up[i][1] < MIN_VOLUME:
                data_to_voul_up[i][1] = MIN_VOLUME

        return data_to_voul_up

    def decrease_volume(data_to_voul_down):
        """
        devides the values of the 'play-List' list by 1.2 up to the value
        +- 32767
        :param data_to_voul_down: the list of list to modify
        :return: list of modifide lists made of [left ear sound, right ear sound]
        """
        for i in range(len(data_to_voul_down)):
            data_to_voul_down[i][0] = int(data_to_voul_down[i][0] / 1.2)
            data_to_voul_down[i][1] = int(data_to_voul_down[i][1] / 1.2)

            if data_to_voul_down[i][0] > MAX_VOLUME:
                data_to_voul_down[i][0] = MAX_VOLUME
            elif data_to_voul_down[i][0] < MIN_VOLUME:
                data_to_voul_down[i][0] = MIN_VOLUME

            if data_to_voul_down[i][1] > MAX_VOLUME:
                data_to_voul_down[i][1] = MAX_VOLUME
            elif data_to_voul_down[i][1] < MIN_VOLUME:
                data_to_voul_down[i][1] = MIN_VOLUME

        return data_to_voul_down

    def lowpass_filter(data_to_filter):
        """
        recive list of lists made of [left ear sound, right ear sound] and
        change the values of each 'ear' to be the average of the current ear
        the following  and the previus ear (if possible)
        :param data_to_filter: list of lists made of
        :return: filttered_data - the lowpass-ed list of lists
        """
        # The returned list:
        filttered_data = []

        if len(data_to_filter) > 1:
            # code that takes care of the first note
            filttered_left = int((data_to_filter[0][0] +
                                  data_to_filter[1][0]) / 2)
            filttered_right = int((data_to_filter[0][1] +
                                   data_to_filter[1][1]) / 2)
            filttered_data.append([filttered_left, filttered_right])

            # code that append the right values to the list
            for i in range(1, len(data_to_filter) - 1):
                filttered_left = int((data_to_filter[i][0] +
                                      data_to_filter[i - 1][0] +
                                      data_to_filter[i + 1][0]) / 3)
                filttered_right = int((data_to_filter[i][1] +
                                       data_to_filter[i - 1][1] +
                                       data_to_filter[i + 1][1]) / 3)
                filttered_data.append([filttered_left, filttered_right])
            # next pice of code take care of the last note
            if len(data_to_filter) > 1:
                filttered_left = int((data_to_filter[-2][0] +
                                      data_to_filter[-1][0]) / 2)
                filttered_right = int((data_to_filter[-2][1] +
                                       data_to_filter[-1][1]) / 2)
                filttered_data.append([filttered_left, filttered_right])
        return filttered_data

    if inner_action_editing == 1:
        file_data = reverse(file_data)

    if inner_action_editing == 2:
        file_data = increase_speed(file_data)

    if inner_action_editing == 3:
        file_data = decrease_speed(file_data)

    if inner_action_editing == 4:
        file_data = increase_volume(file_data)

    if inner_action_editing == 5:
        file_data = decrease_volume(file_data)

    if inner_action_editing == 6:
        file_data = lowpass_filter(file_data)

    return file_data


if __name__ == "__main__":
    keep_going = True
    while keep_going:
        action = int(input(
            "what would you like to do:\n"
            "Enter 1 to change the music file \n"
            "Enter 2 to compose music\n"
            "Enter 3 to exit\n"))

        if action == 1 or action == 2:

            if action == 1:
                check = wave_helper.load_wave(input("Please enter wav file"))
                if check == -1:
                    print("please enter a legit wav file if you still want to edit"
                          ". ")
                    continue
                else:
                    data = check[1]
                    rate = check[0]
            keep_editing = True

            if action == 2:
                data = composeWav()
                rate = SAMPLE_RATE

            while keep_editing:
                # editing continusly until the user enters 7 for breaking out
                editing_action = int(input(
                    "Choose one of the following editing options\n"
                    "Press 1 to :Reverse\n"
                    "Press 2 to :Increase speed\n"
                    "Press 3 to :Decrease speed\n"
                    "Press 4 to :Increase volume\n"
                    "Press 5 to :Decrease volume\n"
                    "Press 6 to :Low pass filter\n"
                    "Press 7 to :Save \n"))
                if editing_action == 7:
                    keep_editing = False
                elif editing_action in [0, 1, 2, 3, 4, 5, 6]:
                    file_editing = file_editing_main(editing_action, data)
                else:
                    print(
                        "not legit input,if you still want to edit next time"
                        " choose one the next options please")
            # saves the wav file
            finish_creating_menu(rate, data)

        elif action == 3:
            keep_going = False