#include "classicnote.h"
#include "classicsprite.h"
#include <SFML/Graphics/RenderTarget.hpp>
#include <iostream>

ClassicNote::ClassicNote(const std::vector<microsec>& intervals, microsec perfect_offset,
                         Action action, const Coordinates& coord) :
    Note(perfect_offset),
    _coordinates(coord),
    _evaluator(intervals, _perfect_offset),
    _action(action),
    _state(State::NONE),
    _appearance_time(0)
{}

bool ClassicNote::isActive(const microsec& music_offset) const
{
    return _evaluator.isActive(music_offset);
}

static int getPt( int n1 , int n2 , float perc )
{
    int diff = n2 - n1;

    return n1 + ( diff * perc );
}

void ClassicNote::update(const microsec& music_offset)
{
    switch (_state)   // States will be objects
    {
    case State::DYING:
        _sprite->update();
        if (_sprite->isDead())
            setState(State::DEAD);
        break;

    case State::FLYING:
    {
        auto update_time = music_offset - _appearance_time;   // This all will be inside ::update
        auto i = update_time / _trail_path_percent / 100;      //         of an animation object

        int xa = getPt( 720./2. , 1280./2. , i );
        int ya = getPt( 0 , 720./2. , i );
        int xb = getPt( 1280./2. , _coordinates.x , i );
        int yb = getPt( 720./2. , _coordinates.y , i );

        _sprite->update(getPt( xa , xb , i ), getPt( ya , yb , i ));
        break;
    }

    default:
        break;
    }
}

void ClassicNote::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
    target.draw(*_sprite, states);
}

auto ClassicNote::input(ClassicInputType&& input_data) -> Grade
{ 
    auto grade = ClassicNote::Grade::BAD;

    if (input_data == _action)
        grade = _evaluator.calculatePrecision(input_data.timestamp());

    setState(State::DYING);

    std::cout << "User input: " << static_cast<int>(grade) << "\n";

    return grade;
}

Action ClassicNote::action() const
{
    return _action;
}

auto ClassicNote::state() const -> State
{
    return _state;
}

void ClassicNote::setState(State next_state)
{
    switch (next_state)   // States will be objects
    {
    case State::DYING:
        _sprite->pulse();
        break;

    case State::FLYING:
        _sprite->setCoordinates(_coordinates.x, _coordinates.y, 720/2, 50);
        break;

    case State::NONE:
        _sprite->reset();
        break;

    default:
        break;
    }

    _state = next_state;
}

std::shared_ptr<ClassicSprite> ClassicNote::sprite() const noexcept
{
    return _sprite;
}

void ClassicNote::saveAppearanceTime(const microsec &offset)
{
    _appearance_time = offset;
    _trail_path_percent = ((_perfect_offset - _appearance_time) * 0.01);
}

void ClassicNote::setSprite(const std::shared_ptr<ClassicSprite>& sprite) noexcept
{
    _sprite = sprite;
    if (_sprite)
        setState(State::FLYING);
}

const Coordinates& ClassicNote::getCoordinates() const noexcept
{
    return _coordinates;
}