#pragma once

#include <nan.h>
#include <mutex>
#include <deque>
#include <include/NanEventCallback.h>

namespace tc {
	namespace audio {
		class AudioInput;
		class AudioConsumer;

		namespace filter {
			class Filter;
		}

		namespace recorder {
			class AudioFilterWrapper;
			class AudioRecorderWrapper;
			/*
	            get_filters() : ConsumeFilter[];

                register_filter(filter: ConsumeFilter);
                unregister_filter(filter: ConsumeFilter);

                create_filter_vad() : VADConsumeFilter;
                create_filter_threshold() : ThresholdConsumeFilter;
			 */

			class AudioConsumerWrapper : public Nan::ObjectWrap {
					friend class AudioRecorderWrapper;
				public:
					static NAN_MODULE_INIT(Init);
					static NAN_METHOD(NewInstance);
					static inline Nan::Persistent<v8::Function> & constructor() {
						static Nan::Persistent<v8::Function> my_constructor;
						return my_constructor;
					}

					static inline Nan::Persistent<v8::FunctionTemplate> & constructor_template() {
						static Nan::Persistent<v8::FunctionTemplate> my_constructor_template;
						return my_constructor_template;
					}

					AudioConsumerWrapper(AudioRecorderWrapper*, const std::shared_ptr<AudioConsumer>& /* handle */);
					~AudioConsumerWrapper() override;

					static NAN_METHOD(_get_filters);
					static NAN_METHOD(_unregister_filter);

					static NAN_METHOD(_create_filter_vad);
					static NAN_METHOD(_create_filter_threshold);
					static NAN_METHOD(_create_filter_state);

					std::shared_ptr<AudioFilterWrapper> create_filter(const std::string& /* name */, const std::shared_ptr<filter::Filter>& /* filter impl */);
					void delete_filter(const AudioFilterWrapper*);

					inline std::deque<std::shared_ptr<AudioFilterWrapper>> filters() {
						std::lock_guard lock(this->_filters_lock);
						return this->_filters;
					}

					inline std::shared_ptr<AudioConsumer> native_consumer() { return this->_handle; }

					std::mutex native_read_callback_lock;
					std::function<void(const void * /* buffer */, size_t /* samples */)> native_read_callback;
				private:
					AudioRecorderWrapper* _recorder;

					std::mutex execute_lock;
					std::shared_ptr<AudioConsumer> _handle;

					std::mutex _filters_lock;
					std::deque<std::shared_ptr<AudioFilterWrapper>> _filters;
					bool last_consumed = false;

					void do_wrap(const v8::Local<v8::Object>& /* object */);

					void unbind(); /* called  with execute_lock locked */
					void process_data(const void* /* buffer */, size_t /* samples */);

					struct DataEntry {
						void* buffer = nullptr;
						size_t sample_count = 0;

						~DataEntry() {
							if(buffer)
								free(buffer);
						}
					};

					std::mutex _data_lock;
					std::deque<std::unique_ptr<DataEntry>> _data_entries;

					Nan::callback_t<> _call_data;
					Nan::callback_t<> _call_ended;
					Nan::callback_t<> _call_started;
					/*
		                callback_data: (buffer: Float32Array) => any;
		                callback_ended: () => any;
					 */
			};
		}
	}
}