// Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2021 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// https://opensource.org/licenses/BSD-3-Clause
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#ifndef NDKCAMERA_H
#define NDKCAMERA_H

#include <camera/NdkCameraDevice.h>
#include <camera/NdkCameraManager.h>
#include <camera/NdkCameraMetadata.h>
#include <media/NdkImageReader.h>

#include <opencv2/core/core.hpp>
#include "Camera2Helper.h"
#include <mutex>
#include <set>

/**
 * Range of Camera Exposure Time:
 *     Camera's capability range have a very long range which may be disturbing
 *     on camera. For this sample purpose, clamp to a range showing visible
 *     video on preview: 100000ns ~ 250000000ns
 */
static const uint64_t kMinExposureTime = static_cast<uint64_t>(1000000);
static const uint64_t kMaxExposureTime = static_cast<uint64_t>(250000000);

#define WAIT_AE_LOCKED			1
#define WAIT_AWB_LOCKED			2
#define WAIT_AF_LOCKED			4

#define EXPECTED_CAPTURE_IDX        0
#define EXPECTED_CAPTURE_IDX        1

class CameraManager
{
public:
    CameraManager()
    {
        camera_manager = NULL;
    }

    void Create()
    {
        camera_manager = ACameraManager_create();
    }

    operator ACameraManager* ()
    {
        return camera_manager;
    }
    ~CameraManager()
    {
        if (camera_manager != NULL)
        {
            ACameraManager_delete(camera_manager);
            camera_manager = NULL;
        }
    }

private:
    ACameraManager* camera_manager;
};

class NdkCamera
{
public:

    struct CAMERA_PARAMS {
        unsigned int sceneMode : 5;
        unsigned int autoFocus : 1;
        unsigned int autoExposure : 1;
        unsigned int orientation:3;
        unsigned int zoom : 1;
        unsigned int wait3ALocked : 3;
        unsigned int reserved : 18;
        int64_t exposureTime;
        unsigned int sensitivity;
        int compensation;
        float zoomRatio;
        uint8_t requestTemplate;
        uint8_t awbMode;
        unsigned short focusTimeout;  // milli-seconds 65535
    };

    struct CAPTURE_RESULT
    {
        uint8_t autoFocus;
        uint8_t autoExposure;
        uint8_t afState;
        uint8_t aeState;
        uint8_t awbState;
        int64_t exposureTime;
        float FocusDistance;
        int32_t sensitivity;
        int32_t compensation;
        uint8_t sceneMode;
        uint8_t awbMode;
        float zoomRatio;
        uint8_t avgY;
        uint64_t duration;
        int64_t frameDuration;

        uint8_t awbLockSetted : 1;
        uint8_t aeLockSetted : 1;
        uint8_t afLockSetted : 1;
    };

    NdkCamera(int32_t width, int32_t height, const CAMERA_PARAMS& params);
    virtual ~NdkCamera();

    // facing 0=front 1=back
    int open(const std::string& cameraId);
    void close();

    int selfTest(const std::string& cameraId, int32_t& maxResolutionX, int32_t& maxResolutionY);

    void onAvailabilityCallback(const char* cameraId);
    void onUnavailabilityCallback(const char* cameraId);
    virtual void onImageAvailable(AImageReader* reader);
    virtual int32_t getOutputFormat() const;
    virtual bool on_image(cv::Mat& rgb);
    virtual void on_error(const std::string& msg);
    virtual void on_image(const unsigned char* nv21, int nv21_width, int nv21_height);
    virtual void onDisconnected(ACameraDevice* device);

    void onCaptureProgressed(ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result);
    void onCaptureCompleted(ACameraCaptureSession* session, ACaptureRequest* request, const ACameraMetadata* result);
    void onCaptureFailed(ACameraCaptureSession* session, ACaptureRequest* request, ACameraCaptureFailure* failure);
    void onSessionReady(ACameraCaptureSession *session);

    const CAPTURE_RESULT& getCaptureResult() const
    {
        return mFinalResult;
    }

    bool IsCameraAvailable(const std::string& cameraId);

protected:
    std::mutex m_locker;
    std::set<std::string> m_availableCameras;

protected:
    CAMERA_PARAMS m_params;
    int camera_facing;
    int camera_orientation;
    bool m_firstFrame;
    int32_t mWidth;
    int32_t mHeight;
    std::string mCameraId;

    int64_t maxFrameDuration;
    bool sceneModeSupported;
    bool afSupported;
    uint8_t awbMode;
    bool aeLockAvailable;
    bool awbLockAvailable;

    uint64_t numberOfPrecaptures;
    unsigned long long m_precaptureStartTime;
    bool lightDetected;

    // int64_t exposureTime_;
    RangeValue<int64_t> exposureRange;
    // int32_t sensitivity_;
    RangeValue<int32_t> sensitivityRange;
    RangeValue<int32_t> aeCompensationRange;
    ACameraMetadata_rational aeCompensationStep;
    int32_t activeArraySize[2];
    int32_t maxRegions[3];

    unsigned int m_imagesCaptured;

    CAPTURE_RESULT mResult;
    CAPTURE_RESULT mFinalResult;
    unsigned long long m_startTime;

protected:

    ACameraManager_AvailabilityCallbacks camera_manager_cb;

    CameraManager camera_manager;
    ACameraDevice* camera_device;
    AImageReader* image_reader;
    ANativeWindow* image_reader_surface;
    ACameraOutputTarget* image_reader_target;
    ACaptureRequest* capture_request;
    ACaptureSessionOutputContainer* capture_session_output_container;
    ACaptureSessionOutput* capture_session_output;
    ACameraCaptureSession* capture_session;

    int captureSequenceId;
};

#endif // NDKCAMERA_H