#pragma once
#include "misc/delegates.h"
#include "misc/singleton/singleton.h"

#include <string>
#include <unordered_map>

#include "../../misc/mempool.h"
#include "mixer_processor.h"
#include "mixer_track.h"
#include "taskflow/taskflow.hpp"

class plugin_host;
class channel_interface;
class mixer_track;

class mixer : public singleton_t<mixer> {
    typedef std::pair<int32_t, std::vector<mixer_track*>> layer_type;
public:
    void init(singleton_initliazer& initliazer) override;
    void begin_release(singleton_release_guard &release_guard) override;
    void release(singleton_release_guard& release_guard) override;
    const char* get_name() override { return "mixer"; }

    dummy_track* create_dummy_track(const std::string& in_name);
    instrument_track* create_instrument_track(plugin_host* in_instrument);
    void remove_track(mixer_track* track);
    [[nodiscard]] const std::vector<mixer_track*>& get_tracks() const { return tracks_; }

    void process(uint32_t in_frames, circular_buffer_vector_type& out_buffer);
    void reset();

    [[nodiscard]] auto get_master() const -> dummy_track* { return master_; }
    [[nodiscard]] auto get_zero_track() const -> dummy_track* { return zero_track_; }
    void request_build_process_node();
    bool is_ready() const { return ready_; }
    void ready_dirty() { ready_ = false; }

    multicast_delegate<mixer_track*> on_add_track;
    multicast_delegate<mixer_track*> on_add_track_main_thread;
    multicast_delegate<mixer_track*> on_remove_track;
    multicast_delegate<mixer_track*> on_remove_track_main_thread;

    mixer_track* selected_track = nullptr;
private:
    void push_track(mixer_track* track);

    void thread_register_track(mixer_track* track);

    void on_mixer_latency_changed();

    dummy_track* master_;
    dummy_track* zero_track_; // 用于没有任何音频输出的通道
    std::vector<mixer_track*> tracks_;
    mixer_processor processor_;
    std::atomic<bool> ready_ = false;
};

DEFINE_SINGLETON_INSTANCE(mixer)