#include <cstring>
#include <vector>
#include <mxl/flow.h>
#include <mxl/time.h>
#include "NodeBase.hpp"
#include "FlowDef.hpp"
#include "DeckLinkReceiver.hpp"

class DeckLinkInNode : public dmf::NodeBase {
    void run() override {
        dmf::DeckLinkReceiver receiver;

        log("Available DeckLink devices:");
        for (const auto& d : receiver.devices)
            log("  %u) %s", d.index, d.name.c_str());

        const uint32_t device_index = config().value("device_index", 0u);
        receiver.start_capture(device_index);
        log("Capturing from: %s", receiver.devices[device_index].name.c_str());

        if (!receiver.wait_for_format(5000)) {
            log("Timeout waiting for format detection");
            return;
        }
        const auto& vi = receiver.video_info;
        if (vi.width == 0 || vi.fps_num == 0) { log("Invalid format detected"); return; }
        log("Detected: %dx%d @ %d/%d fps", vi.width, vi.height, vi.fps_num, vi.fps_den);

        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",   vi.width);
        const int  height  = video_flow_info.value("height",  vi.height);
        const int  fps_num = video_flow_info.value("fps_num", vi.fps_num);
        const int  fps_den = video_flow_info.value("fps_den", vi.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);
        log("start video_index=%llu", video_index);

        std::vector<uint8_t> frame_buf(static_cast<size_t>(video_stride) * static_cast<size_t>(height), 0);

        while (dmf::g_running.load(std::memory_order_relaxed)) {
            if (!receiver.wait_for_frame(frame_buf.data(), video_stride, width, height)) break;

            mxlGrainInfo grain{};
            uint8_t*     video_buf = nullptr;
            vst = mxlFlowWriterOpenGrain(video_writer, video_index, &grain, &video_buf);
            if (vst == MXL_STATUS_OK) {
                std::memcpy(video_buf, frame_buf.data(), frame_buf.size());
                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 = mxlGetCurrentIndex(&video_rate);
            }
        }

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

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