/*M///////////////////////////////////////////////////////////////////////////////////////
//
    @author Viktor V. Smirnov
    @version 1.0 01/03/20
    @e-mail niht@mail.com
//
//M*/

#pragma once

// Argus utils
#include <Error.h>
#include <Thread.h>

#include <Argus/Argus.h>
#include <Argus/Types.h>
#include <Argus/Settings.h>
#include <ArgusHelpers.h>
#include <Argus/Ext/BayerSharpnessMap.h>
#include <Argus/Ext/DeFog.h>
#include <Argus/Ext/InternalFrameCount.h>
#include <Argus/Ext/SensorPrivateMetadata.h>
#include <Argus/Ext/SensorTimestampTsc.h>
#include <Argus/Ext/BayerAverageMap.h>
#include <Argus/Ext/NonLinearHistogram.h>
#include <Argus/Ext/PwlWdrSensorMode.h>
#include <Argus/Ext/DolWdrSensorMode.h>
#include <EGLStream/EGLStream.h>
#include <EGLStream/NV/ImageNativeBuffer.h>
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <NvEglRenderer.h>
#include <NvJpegEncoder.h>
#include <Value.h>

#include <experimental/filesystem>
#include <algorithm>
//#include <opencv2/opencv.hpp>

#include "../../src/Config.hpp"

namespace hc
{

struct SensorParams
{
    double fps{ 30.0 };
    double exposureTime{ 1e9 / 30.0 };
    double analogGain{ 1.0 };
    double digitalGain{ 1.0 };
    double sceneLux{ 10.0 };
    std::vector< double > wbGains{ std::vector< double >( 4, 1.0 ) };
};

class Camera /*: public ArgusSamples::Thread*/
{

public:
    Camera( const Config & config ) : m_config( config )
    {
//        m_recordPath = m_config.jsonRoot[ "recordPath" ].asString();
//        if( not std::experimental::filesystem::exists( m_recordPath ) )
//            std::experimental::filesystem::create_directory( m_recordPath );
        m_frameWidth = m_config.jsonRoot[ "frameResolution" ][ "width" ].asInt();
        m_frameHeight = m_config.jsonRoot[ "frameResolution" ][ "height" ].asInt();
        m_debug = m_config.jsonRoot[ "debug" ].asBool();
        m_frameScale = m_config.jsonRoot[ "frameScale" ].asUInt64();
        m_camerasNum = m_config.jsonRoot[ "camerasNum" ].asUInt();
        m_fps = m_config.jsonRoot[ "fps" ].asFloat();
        m_analogGain = m_config.jsonRoot[ "analogGain" ].asFloat();
        m_digitalGain = m_config.jsonRoot[ "digitalGain" ].asFloat();
        m_exposureTime = m_config.jsonRoot[ "exposureTime" ].asUInt64();
        m_scanShiftNumber = m_config.jsonRoot[ "scanShiftNumber" ].asUInt();
        m_awbAuto = m_config.jsonRoot[ "awbAuto" ].asBool();
        m_expoAuto = m_config.jsonRoot[ "expoAuto" ].asBool();
        m_useCCM = m_config.jsonRoot[ "useCCM" ].asBool();
        m_expoCompensation = m_config.jsonRoot[ "expoCompensation" ].asInt();
        m_captureCropYLeft = m_config.jsonRoot[ "captureCropYLeft" ].asInt();
        m_captureCropYRight = m_config.jsonRoot[ "captureCropYRight" ].asInt();
        m_captureEveryFrameN = m_config.jsonRoot[ "captureEveryFrameN" ].asUInt();
        m_triggerMode = m_config.jsonRoot[ "triggerMode" ].asBool();
        m_singleSessionMode = m_config.jsonRoot[ "singleSessionMode" ].asBool();
        m_skipFrames = m_config.jsonRoot[ "skipFrames" ].asUInt();

        for( const auto & v : m_config.jsonRoot[ "wbGains" ] )
            m_wbGains.emplace_back( v.asDouble() );

        for( const auto & v : m_config.jsonRoot[ "ccm" ] )
            m_ccm.emplace_back( v.asDouble() );

//        std::cout << "Record path: " << m_recordPath << std::endl;
        m_fpsTime = uint64_t( 1e9 / m_fps );
        m_streamSize = { uint32_t( m_frameWidth ), uint32_t( m_frameHeight ) };

    }

    ~Camera();

    bool startCapture();
    bool stopCapture();    
    bool setSensorsParams( const SensorParams & sensorParams );
    SensorParams getSensorParams( const Argus::UniqueObj< EGLStream::Frame > & frame );
    bool capture( const std::string & recordPath, const int32_t number );
    bool pause( bool pause );
    bool capturing();
    void captureExecute();
    void abortCapture();



private:
    bool configureSensor( Argus::IRequest * m_iRequest );

    Config m_config;

    bool m_doCapture{};
    size_t m_framesCounter{};
    EGLDisplay m_eglDisplay;
    Argus::UniqueObj< Argus::CameraProvider > m_cameraProvider{};
    Argus::SensorMode * m_sensorMode{};
    Argus::ISensorMode * m_iSensorMode{};

    std::vector< Argus::IEGLOutputStream * > m_iStreams;
    std::vector< EGLStream::IFrameConsumer * > m_iFrameConsumers;
    std::vector< Argus::CameraDevice * > m_cameraDevices;
    Argus::UniqueObj< Argus::CaptureSession > m_captureSession;
    Argus::ICaptureSession * m_iCaptureSession;

    std::vector< Argus::UniqueObj< Argus::CaptureSession > > m_captureSessions;
    std::vector< Argus::ICaptureSession * > m_iCaptureSessions;

    std::vector< Argus::UniqueObj< Argus::OutputStream > > m_streams;
    std::vector< Argus::UniqueObj< EGLStream::FrameConsumer > > m_consumers;
    Argus::IRequest * m_iRequest;
    Argus::UniqueObj< Argus::Request > m_request;

    std::vector< Argus::IRequest * > m_iRequests;
    std::vector< Argus::UniqueObj< Argus::Request > > m_requests;

    Argus::ISourceSettings * m_iSourceSettings;
    Argus::IAutoControlSettings * m_iAutoControlSettings;
    Argus::IEventProvider * m_iEventProvider;
    Argus::UniqueObj< Argus::EventQueue > m_queue;
    Argus::IEventQueue * m_iQueue;
    std::vector< Argus::EventType > m_eventTypes;

    std::vector< Argus::IEventProvider * > m_iEventProviders;
    std::vector< Argus::UniqueObj< Argus::EventQueue > > m_queues;
    std::vector< Argus::IEventQueue * > m_iQueues;


    bool m_debug{};  
    Argus::Size2D< uint32_t > m_streamSize{};
    std::string m_recordPath{};
    size_t m_frameWidth{};
    size_t m_frameHeight{};
    size_t m_frameScale{};
    uint64_t m_fpsTime{};
    float m_fps{};
    float m_analogGain{};
    float m_digitalGain{};
    uint64_t m_exposureTime{};
    uint32_t m_camerasNum{};
    uint32_t m_scanShiftNumber{};
    uint32_t m_rawFramesCounter{};
    int32_t m_expoCompensation{};
    int32_t m_captureCropYLeft{};
    int32_t m_captureCropYRight{};
    std::vector< double > m_wbGains;
    std::vector< float > m_ccm;
    bool m_awbAuto{};
    bool m_expoAuto{};
    bool m_useCCM{};
    uint32_t m_captureEveryFrameN{};
    int32_t m_framesNumber{};
    uint64_t m_skipFrames{};
    bool m_triggerMode{};
    bool m_singleSessionMode{};

    std::thread m_threadExecute;
    uint64_t m_offsetNs{};
    bool m_abortCapture{};

};

} // namespace hc