#pragma once

#include <atomic>
#include <cstdint>
#include <expected>
#include <filesystem>
#include <memory>
#include <vector>

#include <modulus.hpp>


namespace sonus {

namespace detail {

struct sequence_state;

class sequence_player;

}

enum class playback_status : std::uint8_t {
  PLAYING,
  COMPLETED,
  STOPPED,
  FAILED,
};

struct sample_buffer {
  std::uint32_t sample_rate{};
  std::vector<std::float32_t> frames{};
  std::uint64_t loop_start{};
  std::uint64_t loop_end{};
};

struct sample_event {
  std::uint32_t sample{};
  std::uint64_t start_frame{};
  std::uint64_t duration_frames{};
  std::float32_t gain{1.0F};
};

struct sample_sequence {
  std::vector<sonus::sample_buffer> samples{};
  std::vector<sonus::sample_event> events{};
  std::vector<std::float32_t> release_envelope{};
  std::uint64_t duration_frames{};
  std::uint32_t max_voices{64};
  std::float32_t gain{0.25F};
};

class prepared_sequence {
public:
  static auto create(sonus::sample_sequence sequence, std::uint32_t sample_rate) -> std::expected<sonus::prepared_sequence, modulus::error>;
  prepared_sequence(prepared_sequence const &) = delete;
  auto operator=(prepared_sequence const &) -> prepared_sequence & = delete;
  prepared_sequence(prepared_sequence &&) noexcept;
  auto operator=(prepared_sequence &&) noexcept -> prepared_sequence &;
  ~prepared_sequence();
private:
  friend class sonus::detail::sequence_player;
  explicit prepared_sequence(std::unique_ptr<sonus::detail::sequence_state> state);
  std::unique_ptr<sonus::detail::sequence_state> state_;
};

class playback_session {
public:
  playback_session() = default;
  explicit playback_session(std::shared_ptr<std::atomic<sonus::playback_status>> status);
  auto status() const -> sonus::playback_status;
  auto stop() const -> void;
private:
  std::shared_ptr<std::atomic<sonus::playback_status>> status_{};
};

auto load_sample(std::filesystem::path const &path, std::uint32_t sample_rate) -> std::expected<sonus::sample_buffer, modulus::error>;

}