#include "note.h"
#include "classictimeline.h"
#include <iostream>

ClassicTimeline::ClassicTimeline()
{
    // BPM of METEOR is 170.
    // Length is 1:14
    // I calculated that the time between beats is about 1412162 microseconds

    std::string song_filename = "METEOR.flac";

    _music.openFromFile(song_filename);
    _music.setVolume(10);
}

void ClassicTimeline::run(std::vector<Note*>&& notes, const microsec& visibility)
{
    _visibility_offset = visibility;
    _timeline = std::move(notes);

    _top_note = _timeline.begin();
    expire(_first_visible_note);
    expire(_last_visible_note);
    expire(_active_note);

    fetchVisibleNotes();
    _music.play();
}

ClassicTimeline::~ClassicTimeline()
{
    clear();
}

void ClassicTimeline::clear()
{
    for (auto& note : _timeline)
        delete note;

    _timeline.clear();
}

void ClassicTimeline::update()
{
    const auto& music_offset = currentMusicOffset();
    checkCurrentActiveNote(music_offset);
    checkForNextActiveNote(music_offset);
    updateVisibleSprites(music_offset);
}

void ClassicTimeline::checkCurrentActiveNote(const microsec& music_offset)
{
    if (isExpired(_active_note))
        return;

    auto note = *_active_note;

    if (!note->isActive(music_offset))
    {
        expire(_active_note);
        ++_top_note;
    }
}

void ClassicTimeline::checkForNextActiveNote(const microsec& music_offset)
{
    if (!isExpired(_active_note))
        return;

    auto top_note = *_top_note;
    if (top_note->isActive(music_offset))
        _active_note = _top_note;
}

void ClassicTimeline::updateVisibleSprites(const microsec& music_offset)
{
    if (nothingToDraw())
        return;

    std::for_each(_first_visible_note, _last_visible_note,
                  [&music_offset](const auto& note)
                  {
                      note->update(music_offset);
                  });
}

ClassicTimeline::Iterator ClassicTimeline::getActiveNote() noexcept
{
    return _active_note;
}

bool ClassicTimeline::isExpired(const Iterator& iterator) const
{
    return iterator == _timeline.end();
}

void ClassicTimeline::expire(Iterator& iterator)
{
    iterator = _timeline.end();
}

microsec ClassicTimeline::currentMusicOffset() const
{
    return _music.getPlayingOffset().asMicroseconds();
}

bool ClassicTimeline::isVisiblyClose(const Iterator& iterator, const microsec& music_offset) const
{
    return ((*iterator)->offset() - _visibility_offset) <= music_offset;
}

void ClassicTimeline::fetchVisibleNotes()
{
    const microsec music_offset = currentMusicOffset();
    findLastVisibleNote(music_offset);
    findFirstVisibleNote();
}

void ClassicTimeline::findLastVisibleNote(const microsec &music_offset)
{
    Iterator note_iterator = _top_note;
    while (isVisiblyClose(note_iterator, music_offset))
    {
        if (nothingToDraw())
            _first_visible_note = note_iterator;

        auto note = *note_iterator;

        if (note->isExpired())
            note->putToGame(music_offset);

        ++note_iterator;
    }

    _last_visible_note = note_iterator;
}

void ClassicTimeline::findFirstVisibleNote()
{
    if (nothingToDraw())
        return;

    auto note_iterator = _first_visible_note;
    while (note_iterator != _last_visible_note)
    {
        auto note = *note_iterator;
        if (note->isExpired())
            ++_first_visible_note;

        ++note_iterator;
    }
}

bool ClassicTimeline::nothingToDraw() const noexcept
{
    return isExpired(_first_visible_note);
}

void ClassicTimeline::drawVisibleNotes() const
{
    if (nothingToDraw())
        return;

    std::for_each(_first_visible_note, _last_visible_note,
                  [](const auto& note)
                  {
                      note->draw();
                  });
}