extern "C" {
    #include <libavformat/avformat.h>
    #include <libavcodec/avcodec.h>
    #include <libavutil/avutil.h>
    #include <libswscale/swscale.h>
    #include <libavutil/imgutils.h>
}

#include <string>
#include <mxl/flow.h>
#include <mxl/time.h>
#include "V210.hpp"
#include "FlowDef.hpp"
#include "NodeBase.hpp"
#include "VideoReader.hpp"

class VideoInNode : public dmf::NodeBase {
    void run() override {
        const std::string filename = config().value("file", std::string{});
        if (filename.empty()) { log("config missing 'file'"); return; }
        log("file: %s", filename.c_str());

        dmf::VideoReader video_reader(filename);
        if (!video_reader.have_video) { log("no video stream found"); return; }

        const auto video_flow_info = config().at("video_flow_id");
        const auto video_flow_id   = video_flow_info.at("id").get<std::string>();
        const int  width    = video_flow_info.value("width",   video_reader.source_info.width);
        const int  height   = video_flow_info.value("height",  video_reader.source_info.height);
        const int  fps_num  = video_flow_info.value("fps_num", video_reader.source_info.fps_num);
        const int  fps_den  = video_flow_info.value("fps_den", video_reader.source_info.fps_den);

        log("video flow=%s  %dx%d @ %d/%d fps", video_flow_id.c_str(), width, height, fps_num, fps_den);

        mxlFlowWriter    video_writer = nullptr;
        mxlFlowConfigInfo video_cfg   = {};
        bool created = false;
        mxlStatus vst = mxlCreateFlowWriter(
            instance(),
            dmf::make_video_flow_def(video_flow_id, node_id(), width, height, fps_num, fps_den).c_str(),
            "", &video_writer, &video_cfg, &created);
        if (vst != MXL_STATUS_OK) {
            log("mxlCreateFlowWriter failed (%s)", dmf::mxl_status_str(vst));
            return;
        }
        const uint32_t video_stride = video_cfg.discrete.sliceSizes[0];
        log("video stride=%u B/line  grain=%u B  ring=%u grains",
            video_stride, video_stride * static_cast<uint32_t>(height), video_cfg.discrete.grainCount);

        const mxlRational video_rate = {fps_num, fps_den};
        uint64_t video_index = mxlGetCurrentIndex(&video_rate);

        while (dmf::g_running.load(std::memory_order_relaxed)) {
            uint8_t*     buf = nullptr;
            mxlGrainInfo grain{};
            vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &buf);
            if (vst == MXL_STATUS_OK) {
                if (!video_reader.get_next_frame(buf, video_stride)) break;
                grain.flags       = 0;
                grain.validSlices = grain.totalSlices;
                mxlFlowWriterCommitGrain(video_writer, &grain);
            }
            const uint64_t ns = mxlGetNsUntilIndex(video_index + 1, &video_rate);
            if (ns > 0 && ns < 2'000'000'000ULL) mxlSleepForNs(ns);
            video_index++;
        }

        log("stopped at video_index=%llu", video_index);
        mxlReleaseFlowWriter(instance(), video_writer);
    }
};

int main() {
    VideoInNode node;
    return node.execute();
}