import time
import os
import sys
sys.path.append('../../')
import pretty_midi as pm
import numpy as np

from src.music.utils import  get_out_path
from src.music.config import MIN_LEN, MIN_NB_NOTES, MAX_GAP_IN_SONG, REMOVE_FIRST_AND_LAST


def sort_notes(notes):
    starts = np.array([n.start for n in notes])
    index_sorted = np.argsort(starts)
    return [notes[i] for i in index_sorted].copy()


def delete_notes_end_after_start(notes):
    indexes_to_keep = [i for i, n in enumerate(notes) if n.start < n.end]
    return [notes[i] for i in indexes_to_keep].copy()

def compute_largest_gap(notes):
    gaps = []
    latest_note_end_so_far = notes[0].end
    for i in range(len(notes) - 1):
        note_start = notes[i + 1].start
        if latest_note_end_so_far < note_start:
            gaps.append(note_start - latest_note_end_so_far)
        latest_note_end_so_far = max(latest_note_end_so_far, notes[i+1].end)
    if len(gaps) > 0:
        largest_gap = np.max(gaps)
    else:
        largest_gap = 0
    return largest_gap

def analyze_instrument(inst):
    # test that piano plays throughout
    init = time.time()
    notes = inst.notes.copy()
    nb_notes = len(notes)
    start = notes[0].start
    end = inst.get_end_time()
    duration = end - start
    largest_gap = compute_largest_gap(notes)
    return nb_notes, start, end, duration, largest_gap

def remove_beginning_and_end(midi, end_time):
    notes = midi.instruments[0].notes.copy()
    new_notes = [n for n in notes if n.start > REMOVE_FIRST_AND_LAST and n.end < end_time - REMOVE_FIRST_AND_LAST]
    midi.instruments[0].notes = new_notes
    return midi

def remove_blanks_beginning_and_end(midi):
    # remove blanks and the beginning and the end
    shift = midi.instruments[0].notes[0].start
    for n in midi.instruments[0].notes:
        n.start = max(0, n.start - shift)
        n.end = max(0, n.end - shift)
    for ksc in midi.key_signature_changes:
        ksc.time = max(0, ksc.time - shift)
    for tsc in midi.time_signature_changes:
        tsc.time = max(0, tsc.time - shift)
    for pb in midi.instruments[0].pitch_bends:
        pb.time = max(0, pb.time - shift)
    for cc in midi.instruments[0].control_changes:
        cc.time = max(0, cc.time - shift)
    return midi

def is_valid_inst(largest_gap, duration, nb_notes, gap_counts=True):
    error_msg = ''
    valid = True
    if largest_gap > MAX_GAP_IN_SONG and gap_counts:
        valid = False
        error_msg += f'wide gap ({largest_gap:.2f} secs), '
    if duration < (MIN_LEN + 2 * REMOVE_FIRST_AND_LAST):
        valid = False
        error_msg += f'too short ({duration:.2f} secs), '
    if nb_notes < MIN_NB_NOTES * duration / 60:  # nb of notes needs to be superior to the minimum number / min * the duration in minute
        valid = False
        error_msg += f'too few notes ({nb_notes}), '
    return valid, error_msg

def midi2processed(midi_path, processed_path=None, apply_filtering=True, verbose=False, level=0):
    assert midi_path.split('.')[-1] in ['mid', 'midi']
    if not processed_path:
        processed_path, _, _ = get_out_path(in_path=midi_path, in_word='midi', out_word='processed', out_extension='.mid')

    if verbose: print(' ' * level + f'Processing {midi_path}.')

    if os.path.exists(processed_path):
        if verbose: print(' ' * (level + 2) + 'Processed midi file already exists.')
        return processed_path, ''
    error_msg = 'Error in scrubbing. '
   # try:
    inst_error_msg = ''
    # load mid file
    error_msg += 'Error in midi loading?'
    midi = pm.PrettyMIDI(midi_path)
    error_msg += ' Nope. Removing invalid notes?'
    midi.remove_invalid_notes()  # filter invalid notes
    error_msg += ' Nope. Filtering instruments?'
    # filter instruments
    instruments = midi.instruments.copy()
    new_instru = []
    instruments_data = []
    for i_inst, inst in enumerate(instruments):
        if inst.program <= 7 and not inst.is_drum and len(inst.notes) > 5:
            # inst is a piano
            # check data
            inst.notes = sort_notes(inst.notes)  # sort notes
            inst.notes = delete_notes_end_after_start(inst.notes)  # delete invalid notes
            nb_notes, start, end, duration, largest_gap = analyze_instrument(inst)
            is_valid, err_msg = is_valid_inst(largest_gap=largest_gap, duration=duration, nb_notes=nb_notes, gap_counts='maestro' not in midi_path)
            if is_valid or not apply_filtering:
                new_instru.append(inst)
                instruments_data.append([nb_notes, start, end, duration, largest_gap])
            else:
                inst_error_msg += 'inst1: ' + err_msg + '\n'
    instruments_data = np.array(instruments_data)
    error_msg += ' Nope. Taking one instrument?'

    if len(new_instru) == 0:
        error_msg = f'No piano instrument. {inst_error_msg}'
        assert False
    elif len(new_instru) > 1:
        # take instrument playing the most notes
        instrument = new_instru[np.argmax(instruments_data[:, 0])]
    else:
        instrument = new_instru[0]
    instrument.program = 0  # set the instrument to Grand Piano.
    midi.instruments = [instrument]  # put instrument in midi file
    error_msg += ' Nope. Removing blanks?'
    # remove first and last REMOVE_FIRST_AND_LAST seconds (avoid clapping and jingles)
    end_time = midi.get_end_time()
    if apply_filtering: midi = remove_beginning_and_end(midi, end_time)

    # remove beginning and end
    midi = remove_blanks_beginning_and_end(midi)
    error_msg += ' Nope. Saving?'

    # save midi file
    midi.write(processed_path)
    error_msg += ' Nope.'
    if verbose:
        extra = f' Saved to {processed_path}' if midi_path else ''
        print(' ' * (level + 2) + f'Success! {extra}')
    return processed_path, ''
    #except:
     #   if verbose: print(' ' * (level + 2) + 'Scrubbing failed.')
      #  if os.path.exists(processed_path):
       #     os.remove(processed_path)
      #  return None, error_msg + ' Yes.'