#pragma once
#include <memory>
#include <chrono>
#include <SFML/Graphics/Rect.hpp>
#include <SFML/Graphics/Sprite.hpp>
#include <SFML/System/Clock.hpp>
#include <SFML/System/Time.hpp>
#include <functional>
#include "ease2.hpp"
#include <fmt/core.h>
#include "json_mods.hpp"

namespace animate2 {

  template <typename T> struct NameOf;

  struct Sheet {
    int frames{0};
    int frame_width{0};
    int frame_height{0};
  };

  struct Timer {
    double DELTA = 1.0/60.0;
    double accumulator = 0.0;
    double prev_time = 0.0;
    double current_time = 0.0;
    double frame_duration = 0.0;
    double alpha = 0.0;
    sf::Clock clock{};

    std::pair<int, double> commit();
    void start();
    void reset();
    void restart();
    sf::Time getElapsedTime();
  };

  struct Sequence {
    std::vector<int> frames{};
    std::vector<std::chrono::milliseconds> durations{};
    size_t current{0};
    int loop_count{0};
    size_t frame_count{0};
    Timer timer{};
    float subframe{0.0f};
  };

  struct Transform {
    // how to know when a transform ends?
    float min_x{1.0f};
    float min_y{1.0f};
    float max_x{1.0f};
    float max_y{1.0f};
    bool simple{true};
    bool flipped{false};
    float ease_rate{0.5f};
    bool scaled{false};

    // handled by onLoop
    bool toggled{false};
    bool looped{false};

    std::shared_ptr<sf::Shader> shader{nullptr};
    // change to using a callback function for these
    ease2::EaseFunc easing = ease2::in_out_back;
    ease2::MoveFunc motion = ease2::move_rush;

    void lerp(Sequence& seq, sf::Vector2f& pos_out, sf::Vector2f& scale_out);
  };

  /* Gets the number of times it looped, and returns if it should stop. */
  using OnLoopHandler = std::function<bool(Sequence& seq, Transform& tr)>;
  using OnFrameHandler = std::function<void()>;

  inline bool DefaultOnLoop(Sequence& seq, Transform& tr) {
    if(tr.toggled) {
      seq.current = seq.frame_count - 1;
    } else {
      seq.current = 0;
    }

    return tr.looped;
  }

  class Animate2 {
    public:
      Sheet sheet;
      Sequence sequence;
      Transform transform;
      OnFrameHandler onFrame = nullptr;

      std::vector<sf::IntRect> $frame_rects{calc_frames()};
      OnLoopHandler onLoop = DefaultOnLoop;
      bool playing = false;

      std::vector<sf::IntRect> calc_frames();
      void play();
      void stop();
      void apply(sf::Sprite& sprite);
      void update_frame();
      void update();
      void motion(sf::Sprite& sprite, sf::Vector2f pos, sf::Vector2f scale);
      std::pair<int, double> commit();
  };

  Animate2 load(const std::string &file, const std::string &anim_name);

  ENROLL_COMPONENT(Sheet, frames, frame_width, frame_height);
  ENROLL_COMPONENT(Sequence, frames, durations);
  ENROLL_COMPONENT(Transform, min_x, min_y, max_x, max_y, simple, flipped, ease_rate, scaled, toggled, looped);
  ENROLL_COMPONENT(Animate2, sheet, sequence, transform);
}