#include <iostream>
#include <iomanip>
#include <memory>
#include <thread>
#include <atomic>
#include <vector>
#include <libcamera/libcamera.h>

using namespace libcamera;
using namespace std::chrono_literals;

static std::atomic<bool> capturing{true};

static std::shared_ptr<Camera> camera;

static void requestComplete(Request *request)
{
    if (request->status() == Request::RequestCancelled)
        return;

    for (auto const &bufferPair : request->buffers()) {
        FrameBuffer *buffer = bufferPair.second;
        const FrameMetadata &metadata = buffer->metadata();
        if (metadata.status != FrameMetadata::FrameSuccess)
            continue;

        int fd = buffer->planes()[0].fd.get(); // Import this dma-buf fd into EGL/OpenGL.
        std::cout << "frame " << std::setw(6) << std::setfill('0') << metadata.sequence
                  << " fd " << fd << " bytes " << metadata.planes()[0].bytesused
                  << std::endl;
    }

    request->reuse(Request::ReuseBuffers);
    if (capturing)
        camera->queueRequest(request);
}

int main()
{
    std::unique_ptr<CameraManager> cm = std::make_unique<CameraManager>();
    cm->start();

    auto cameras = cm->cameras();
    if (cameras.empty()) {
        std::cerr << "What? No cmaera?" << std::endl;
        cameras.clear();
        cm->stop();
        return 1;
    }

    camera = cm->get(cameras[0]->id());
    cameras.clear();
    camera->acquire();

    std::unique_ptr<CameraConfiguration> config = camera->generateConfiguration({StreamRole::Viewfinder});
    StreamConfiguration &streamConfig = config->at(0);
    /*streamConfig.size.width = 640;
    streamConfig.size.height = 480;*/
    config->validate();
    camera->configure(config.get());

    FrameBufferAllocator *allocator = new FrameBufferAllocator(camera);
    Stream *stream = streamConfig.stream();
    if (allocator->allocate(stream) < 0) {
        std::cerr << "Can't allocate buffers" << std::endl;
        delete allocator;
        camera->release();
        cm->stop();
        return 1;
    }

    const std::vector<std::unique_ptr<FrameBuffer>> &buffers = allocator->buffers(stream);
    std::vector<std::unique_ptr<Request>> requests;
    for (const std::unique_ptr<FrameBuffer> &buffer : buffers) {
        std::unique_ptr<Request> request = camera->createRequest();
        if (!request || request->addBuffer(stream, buffer.get()) < 0) {
            std::cerr << "Can't create request" << std::endl;
            allocator->free(stream);
            delete allocator;
            camera->release();
            cm->stop();
            return 1;
        }
        requests.push_back(std::move(request));
    }

    camera->requestCompleted.connect(requestComplete);
    camera->start();
    for (auto &req : requests) {
        camera->queueRequest(req.get());
    }

    std::this_thread::sleep_for(10000ms);

    // end the cameras
    capturing = false;
    camera->stop();
    camera->requestCompleted.disconnect();
    requests.clear();
    allocator->free(streamConfig.stream());
    delete allocator;
    camera->release();
    camera.reset();
    cm->stop();
    cm.reset();

    return 0;
}