function play_music(song) {
  let played_notes = [];
  let secs = [];
  let position = [];
  let secs_to_wait = 0;
  let time_elapsed = 0;

  console.log("Song started.")

  // Sort song in order of start. Notes that start at the same time are in order of duration
  song.sort((a,b) => a.starts_at - b.starts_at || a.lasts - b.lasts);

  for (let key in song) {
    played_notes.push(song[key].note);
    secs.push(song[key].lasts);
    position.push(song[key].starts_at);
  }

  for (let i in position) {
    if (position[i] > position[i - 1]) {
      secs_to_wait = position[i] - secs_to_wait;
      console.log("Wait " + secs_to_wait + " second(s).");
      console.log("Play " + played_notes[i]);
    } else {
      console.log("Play " + played_notes[i]);
    }

    if (position[i] == position[i - 1] && secs[i] == secs[i - 1] || position[i] + secs[i] == secs[i - 1]) {
      //do nothing.
    } else {
      time_elapsed += secs[i];
    }

    if ((secs[i] + position[i]) < time_elapsed || secs[i] < time_elapsed) {
      console.log(played_notes[i] + " released.")
    }
  }
  return "Song ends.";
}

let my_song = [{
    note: 'C',starts_at: 0,lasts: 4
  },{
    note: 'E',{
    note: 'G',starts_at: 2,lasts: 2
  },{
    note: 'G#',starts_at: 3,{
    note: 'Eb',lasts: 2
  }
];

console.log(play_music(my_song))

function play_music(song) { 
    let elapsedInSeconds = -1; //song running time -1 song havent started yet
    let waitTimeInSeconds = 0; //wait time
    let songLengthInSeconds = -1; //total song length
    let noteToPlayIndex = 0; //note index to play in song

    song.sort((a,b) => {
        //the song total length will be the last note starts and how long it lasts
        const aNoteLengthInSeconds = a.starts_at + a.lasts;
        const bNoteLengthInSeconds = b.starts_at + b.lasts;
        //inject this here so we dont have to waste another loop
        songLengthInSeconds = Math.max(songLengthInSeconds,aNoteLengthInSeconds,bNoteLengthInSeconds);
        //we make sure the last note with longest duration be at the bottom of list
        return a.starts_at - b.starts_at || aNoteLengthInSeconds - bNoteLengthInSeconds; //a.lasts - b.lasts would work too
    });

    console.log('Song started.');
    //play until the end of the song
    while(elapsedInSeconds < songLengthInSeconds) {
        elapsedInSeconds++;
        //when we wait,a second went by so subtract and prevent going below 0
        waitTimeInSeconds = Math.max(0,--waitTimeInSeconds);
        //keep track if this is a waiting tick,we would need to track which keys needed to be released
        let isWaitingTick = waitTimeInSeconds > 0;
        for (let i=0; i < song.length; i++) {
            //if its waiting tick,we don't need to loop through the keys we haven't played
            if (isWaitingTick && i >= noteToPlayIndex) {
                break;
            }
            
            //keep track of the time that we need to release the keys
            const keyReleasedAt = song[i].starts_at + song[i].lasts;

            //doesnt matter if we are in waiting tick or not,if its ready to be release,then release it
            if (keyReleasedAt == elapsedInSeconds) { 
                console.log(song[i].note + " released.");
            }else if (!isWaitingTick) { 
                //play the key if its exact second to play
                if (song[i].starts_at == elapsedInSeconds) {
                    console.log("Play " + song[i].note,song[i].lasts);
                    noteToPlayIndex++;
                //other wise if it needs wait some time,we set our wait timer    
                } else if (song[i].starts_at > elapsedInSeconds) {
                    waitTimeInSeconds = song[i].starts_at - elapsedInSeconds;
                    console.log("Wait " + waitTimeInSeconds + " second(s).");
                    //break so it doesnt look at other notes; other keys would be >= of this note starts_at because of sort
                    break; 
                    
                //if we played all the keys then we should see if we need to wait any time for it to be released
                }  else if ( noteToPlayIndex >= song.length && keyReleasedAt > elapsedInSeconds) {
                    //wait time should be the diff between the second of the song it supposed to be released and current elapse time 
                    waitTimeInSeconds = keyReleasedAt - elapsedInSeconds;
                    console.log("Wait " + waitTimeInSeconds + " second(s).");
                    break;
                }
            }
        }
    }
    return "Song ends.";
}

let my_song = [
    {
        note: 'C',lasts: 4
    },{
        note: 'E',{
        note: 'G',lasts: 2
    },{
        note: 'G#',{
        note: 'Eb',];

console.log(play_music(my_song));