import numpy as np
import slider as sl
from datetime import timedelta

QUARTER = 1
HALF = 2
NOTE = 4

def beatify(bpm:float, offset:int, time:timedelta) -> float:
    return bpm/60000 * (time.total_seconds()*1000 - offset)

def debeatify(bpm:float, offset:int, beat:int) -> timedelta:
    return timedelta(milliseconds=(beat*60000/bpm) + offset)

def f(intensity): return np.pi/2 - np.arctan(2*intensity) + np.pi/5
#def f(intensity): return np.pi/2 

def greedy(bpm:int, offset:int, timings:list, amplitudes:list):
    """
    input: takes Alexandre's note selection / intensity data
    output: list of object type / position
    """
    new_combo = True
    flow = 0
    notes = [sl.HitObject(sl.Position(260, 188), timedelta(milliseconds=0), 0)] * len(timings)
    beats = [int(beatify(bpm, offset, timing)*4) for timing in timings]
    last_position = (260, 188)
    max_x, max_y, min_x, min_y = -np.inf, -np.inf, np.inf, np.inf
    for (delta, note_beat, intensity, i) in zip(timings, beats, amplitudes, range(len(timings))):
        try:
            if int(note_beat/32) % 2: #test si la mesure est impaire ou non
                new_combo = not (flow == 1)
                flow = 1
            else:
                new_combo = (flow == 1)
                flow = -1
            duration = abs(note_beat - beats[i + 1])
            print(duration)
            """
            if duration in (QUARTER, HALF):
                notes[i] = sl.Circle(sl.Position(0, 0), delta, 0)
            notes[i] = sl.Circle(sl.Position(0, 0), delta, 0)
            """
            """
            elif duration % 2 == 0:
                rhythms.insert(0, f"slider {duration}")
            else:
                rhythms.insert(0, f"reverse_slider {duration}")
        """
        except IndexError:
            notes[i] = sl.Circle(sl.Position(0, 0), delta, 0)

        if len(notes) > 2:
            if duration == QUARTER:
                x2, y2 = int(notes[i-1].position.x), int(notes[i-1].position.y)
                notes[i] = sl.Circle(sl.Position(x2, y2), delta, 0)
           
            else:
                    angle = flow * f(intensity/100)
                    x1, y1 = int(notes[i-2].position.x), int(notes[i-2].position.y)
                    x2, y2 = int(notes[i-1].position.x), int(notes[i-1].position.y)
                    old_angle = np.arctan2([y2-y1], [x2-x1])
                    x3 = x2 + ((duration + new_combo*4)* np.cos(angle + old_angle))
                    y3 = y2 + ((duration + new_combo*4) * np.sin(angle + old_angle))
                    notes[i] = sl.Circle(sl.Position(int(x3[0]), int(y3[0])), delta, 0)
        else:
            notes[i] = sl.Circle(sl.Position(260, 188), delta, 0)
        if notes[i].position.x > max_x:
            max_x = notes[i].position.x
        elif notes[i].position.x < min_x:
            min_x = notes[i].position.x
        if notes[i].position.y > max_y:
            max_y = notes[i].position.y
        elif notes[i].position.y < min_y:
            min_y = notes[i].position.y

        notes[i].new_combo = new_combo
    factor_x = 1/(max_x - min_x)
    factor_y = 1/(max_y - min_y)
    for note in notes:
        note.position = sl.Position((note.position.x-min_x)*factor_x*512, (note.position.y-min_y)*factor_y*384)

    return notes