function play_soundtrack(melody) {
  let played_notes = [];
  let secs = [];
  let position = [];
  let secs_to_wait = 0;
  let elapsed_time = 0;

  console.log("Melody playback initiated.")

  // Rearrange the melody in ascending order of commencement. Additionally, notes commencing at the same time are ordered by duration.
  melody.sort((a, b) => a.starts_at - b.starts_at || a.lasts - b.lasts);

  for (let key in melody) {
    played_notes.push(melody[key].note);
    secs.push(melody[key].lasts);
    position.push(melody[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 for " + secs_to_wait + " second(s).");
      console.log("Playing " + played_notes[i]);
    } else {
      console.log("Playing " + played_notes[i]);
    }

    if (position[i] == position[i - 1] && secs[i] == secs[i - 1] || position[i] + secs[i] == secs[i - 1]) {
      //no action is necessary.
    } else {
      elapsed_time += secs[i];
    }

    if ((secs[i] + position[i]) < elapsed_time || secs[i] < elapsed_time) {
      console.log(played_notes[i] + " release.")
    }
  }
  return "Melody completion.";
}

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

console.log(play_soundtrack(my_melody))

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',
        starts_at: 0,
        lasts: 4
    },
    {
        note: 'E',
        starts_at: 0,
        lasts: 4
    },
    {
        note: 'G',
        starts_at: 2,
        lasts: 2
    },

    {
        note: 'G#',
        starts_at: 3,
        lasts: 2
    },
    {
        note: 'Eb',
        starts_at: 3,
        lasts: 2
    },
];

console.log(play_music(my_song));