#pragma once

#include <core/producer/frame_producer.h>
#include <modules/ffmpeg_file_validation.h>
#include <core/video_format.h>
#include <core/frame/draw_frame.h>
#include <string>
#include <vector>
#include <queue>
#include <modules/ffmpeg/util/av_util.h>
#include "vlc/vlc.h"


using namespace caspar::modules;

namespace caspar { namespace vlc { namespace producer {
class vlc_producer;
struct FrameContext
{
    uint8_t*      data;
    AVPixelFormat video_format;
    AVSampleFormat audio_format;
    int            line_size;
    int           width;
    int           height;
    int64_t           pts;
    int           nb_samples;
    int            channels;
    int            sample_rate;
    vlc_producer* producer;
    bool              valid;
};

class vlc_producer : public core::frame_producer
{
  public:
    static libvlc_instance_t* vlcInstance;
    vlc_producer(spl::shared_ptr<core::frame_factory> frame_factory,
                 core::video_format_desc              format_desc,
                 ffmpeg_param*                        param);

    ~vlc_producer();

    bool try_pop(FrameContext& video_frame, FrameContext& audio_frame);

    core::draw_frame receive_impl(const core::video_field field, int nb_samples) override;

    core::draw_frame last_frame(const core::video_field field) override;

    core::draw_frame first_frame(const core::video_field field) override;

    std::wstring print() const override;

    std::wstring name() const override;

    core::monitor::state state() const override;

    private:
    static void* video_lock(void* opaque, void** planes);

    static void video_display(void* data, void* picture);

    static void audio_play(void* data, const void* samples, unsigned count, int64_t pts);

  private:
    const spl::shared_ptr<core::frame_factory> frame_factory_;
    core::video_format_desc                    format_desc_;
    const std::wstring                         filename_;
    core::draw_frame                           last_frame_;
    core::monitor::state                       state_;
    std::queue<FrameContext>                   video_data_;
    std::queue<FrameContext>                   audio_data_;
    mutable std::mutex                         video_frames_mutex_;
    mutable std::mutex                         audio_frames_mutex_;
    spl::shared_ptr<diagnostics::graph>        graph_;
    libvlc_media_player_t*                     media_player = nullptr;
    uint8_t*                                   pixel_data;
};

spl::shared_ptr<core::frame_producer> create_producer(const core::frame_producer_dependencies& dependencies,
                                                      const std::vector<std::wstring>&         params);

}}} // namespace caspar::vlc::producer