#include "classicgamegraphicsmanager.h"
#include "graphics/classicsprite.h"

#include "graphics/classicflyinganimationscenario.h"
#include "graphics/classicdyinganimationscenario.h"

ClassicGameGraphicsManager::ClassicGameGraphicsManager(Timeline<ClassicNote> &timeline, const microsec& visibility_offset) :
    ClassicGraphicsManager(visibility_offset),
    _timeline(&timeline)
{
    _timeline->expire(_first);
    _timeline->expire(_last);
}

void ClassicGameGraphicsManager::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
    if (nothingToDraw())
        return;

    for (auto it = _first; it != _last; ++it)
    {
        (*it)->draw(this, target, states);
    }
}

void ClassicGameGraphicsManager::draw(const std::vector<ClassicArrowNote::ArrowElement>& elements, sf::RenderTarget& target, sf::RenderStates states) const
{
    for (std::size_t i = 0; i < elements.size(); ++i)
    {
        const auto& sprite = elements[i].sprite;

        if (i >= 1)
        {
            const auto& neighbor_sprite = elements[i - 1].sprite;

            const auto c1 = neighbor_sprite->trailCoordinates();
            const auto c2 = sprite->trailCoordinates();

            target.draw(makeLine(c1, c2));
        }

        target.draw(*sprite, states);
    }
}

sf::VertexArray ClassicGameGraphicsManager::makeLine(const Coordinates& c1, const Coordinates& c2) const
{
    sf::VertexArray line(sf::LinesStrip, 2);
    line[0].color = sf::Color::Yellow;
    line[0].position = {c1.x + 10, c1.y};
    line[1].color = sf::Color::Blue;
    line[1].position = {c2.x + 10, c2.y};

    return line;
}

void ClassicGameGraphicsManager::setGraphics(std::vector<ClassicArrowNote::ArrowElement>& elements, TimeRange &&range)
{
    for (auto& element : elements)
    {
        element.sprite = _sprite_container.getSprite(element.type);
        element.sprite->setCoordinates(element.coordinates);
        element.sprite->setTrailCoordinates(Coordinates( 0.f, 9.f ));

        element.animations[ClassicArrowNote::State::NONE] = nullptr;
        element.animations[ClassicArrowNote::State::FLYING] = std::make_shared<ClassicFlyingAnimationScenario>();
        element.animations[ClassicArrowNote::State::DYING] = std::make_shared<ClassicDyingAnimationScenario>();
        element.animations[ClassicArrowNote::State::DEAD] = nullptr;

        element.animations[ClassicArrowNote::State::FLYING]->launch(element.sprite, range.begin, range.end);
    }
}

void ClassicGameGraphicsManager::update(const microsec &offset)
{
    fetchLastNote(offset);
    fetchFirstNote(offset);

    updateVisibleNotes(offset);
}

void ClassicGameGraphicsManager::updateVisibleNotes(const microsec &offset)
{
    for (auto it = _first; it != _last; ++it)
        (*it)->update(offset);
}

void ClassicGameGraphicsManager::fetchFirstNote(const microsec& offset)
{
    (void)offset; // ????

    if (nothingToDraw())
        return;

    Iterator note_iterator = _first;
    while (note_iterator != _last)
    {
        auto note = *note_iterator;
        if (note->shouldRemove())
            ++_first;

        ++note_iterator;
    }
}

void ClassicGameGraphicsManager::fetchLastNote(const microsec& offset)
{
    Iterator note_iterator = _timeline->getTopNote();
    while (!_timeline->isExpired(note_iterator) && isVisiblyClose(note_iterator, offset))
    {
        if (nothingToDraw())
            _first = note_iterator;

        auto note = *note_iterator;

        if (!note->isInGame())
        {
            note->putToGame();
            note->setGraphics(this, TimeRange{offset, note->offset()});
        }

        ++note_iterator;
    }

    _last = note_iterator;
}

bool ClassicGameGraphicsManager::nothingToDraw() const noexcept
{
    return _timeline->isExpired(_first)
        || _timeline->isExpired(_last);
}

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