/*
 *  Copyright (c) 2019 Rockchip Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * 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 _CAM_HW_ISP20_H_
#define _CAM_HW_ISP20_H_

#include <linux/rk-video-format.h>
#include "CamHwBase.h"
#include "Isp20Params.h"
#include "SensorHw.h"
#include "LensHw.h"
#include "Isp20StatsBuffer.h"
#include "Stream.h"
#include "RawStreamCapUnit.h"
#include "RawStreamProcUnit.h"
#include "SPStreamProcUnit.h"
#include "PdafStreamProcUnit.h"
#ifdef ISP_HW_V20
#include "TnrStreamProcUnit.h"
#include "NrStreamProcUnit.h"
#include "FecParamStream.h"
#endif
#include "thumbnails.h"
#include "CifScaleStream.h"

#include <unordered_map>

struct media_device;

/*
 * [sub modules]: use bits 4-11 to define the sub modules of each module, the
 *     specific meaning of each bit is decided by the module itself. These bits
 *     is designed to implement the sub module's log switch.

 *  ----------------------------
 * |    sub modules    |  bits  |
 *  ----------------------------
 * |  ISP20HW_SUBM     |  0x01  |
 *  ----------------------------
 * |  ISP20PARAM_SUBM  |  0x02  |
 *  ----------------------------
 * |  SENSOR_SUBM      |  0x04  |
 *  ----------------------------
 * |  FL_SUBM          |  0x08  |
 *  ----------------------------
 * |  LENS_SUBM        |  0x10  |
 *  ----------------------------
 * |  CAPTURERAW_SUBM  |  0x80  |
 *  ----------------------------
 */

namespace RkCam {

class IspParamsSplitter;

#define ISP20HW_SUBM (0x1)

#define MAX_PARAMS_QUEUE_SIZE           5
#define ISP_PARAMS_EFFECT_DELAY_CNT     2
#define CAM_INDEX_FOR_1608              8

#define DISABLE_PARAMS_POLL_THREAD
// FIXME: share 1608 data ptr(aiq/rawdata)
typedef struct sensor_info_share_s {
    RawStreamProcUnit*          raw_proc_unit[CAM_INDEX_FOR_1608];  // bind rx by camId
    SmartPtr<RawStreamCapUnit>  raw_cap_unit;                       // save 1st tx obj addr
    char                        reference_name[64];                 // save vicap name(for 1608)
    rk_aiq_cif_info_t*          reference_mipi_cif;                 // vicap inf (for 1608)
    // us: union_stream
    int                         us_open_cnt;                        // for hwi open(1608)
    int                         us_prepare_cnt;                     // for rawCap buffer manage(1608).
    int                         us_stream_cnt;                      // mark cnt. on: ++, off: --
    int                         us_stop_cnt;                        // last sensor stop
    // tracking opened sensor num
    int                         en_sns_num;                         // Record the number of open sensors
    int                         first_en[CAM_INDEX_FOR_1608];       // set/get fmt for 1608 sensor
} sensor_info_share_t;

class CamHwIsp20
    : public CamHwBase, virtual public Isp20Params, public V4l2Device
    , public isp_drv_share_mem_ops_t {
public:
    friend class RawStreamProcUnit;
    explicit CamHwIsp20();
    virtual ~CamHwIsp20();

    // from ICamHw
    virtual XCamReturn init(const char* sns_ent_name) override;
    virtual XCamReturn deInit() override;
    virtual XCamReturn prepare(uint32_t width, uint32_t height, int mode, int t_delay, int g_delay) override;
    virtual XCamReturn start() override;
    virtual XCamReturn stop() override;
    virtual XCamReturn pause() override;
    virtual XCamReturn resume() override;
    virtual XCamReturn swWorkingModeDyn(int mode) override;
    virtual XCamReturn getSensorModeData(const char* sns_ent_name,
                                         rk_aiq_exposure_sensor_descriptor& sns_des) override;
    virtual void setCalib(const CamCalibDbV2Context_t* calibv2) override;
    virtual XCamReturn applyAnalyzerResult(SmartPtr<SharedItemBase> base, bool sync) override;
    virtual XCamReturn applyAnalyzerResult(cam3aResultList& list) override;
    XCamReturn setModuleCtl(rk_aiq_module_id_t moduleId, bool en) override;
    XCamReturn getModuleCtl(rk_aiq_module_id_t moduleId, bool& en) override;
    XCamReturn notify_capture_raw() override;
    XCamReturn capture_raw_ctl(capture_raw_t type, int count = 0, const char* capture_dir = nullptr, char* output_dir = nullptr) override;
    XCamReturn getSensorCrop(rk_aiq_rect_t& rect) override;
    XCamReturn setSensorCrop(rk_aiq_rect_t& rect) override;
    XCamReturn setSensorFlip(bool mirror, bool flip, int skip_frm_cnt) override;
    XCamReturn getSensorFlip(bool& mirror, bool& flip) override;
    void setMulCamConc(bool cc);
    XCamReturn getZoomPosition(int& position) override;
    XCamReturn getIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType);
    XCamReturn getLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) override;
    XCamReturn setLensVcmCfg(rk_aiq_lens_vcmcfg& lens_cfg) override;
    XCamReturn setLensVcmCfg(struct rkmodule_inf& mod_info);
    XCamReturn FocusCorrection() override;
    XCamReturn ZoomCorrection() override;
    XCamReturn setAngleZ(float angleZ) override;
    virtual void getShareMemOps(isp_drv_share_mem_ops_t** mem_ops) override;
    uint64_t getIspModuleEnState()  override;

    static rk_aiq_static_info_t* getStaticCamHwInfo(const char* sns_ent_name, uint16_t index = 0);
    static rk_aiq_static_info_t* getStaticCamHwInfoByPhyId(const char* sns_ent_name, uint16_t index = 0);
    static XCamReturn clearStaticCamHwInfo();
    static XCamReturn initCamHwInfos();
    static XCamReturn selectIqFile(const char* sns_ent_name, char* iqfile_name);
    static const char* getBindedSnsEntNmByVd(const char* vd);

    // from PollCallback
    virtual XCamReturn poll_event_ready (uint32_t sequence, int type) override;
    virtual XCamReturn poll_event_failed (int64_t timestamp, const char *msg) override;
    XCamReturn rawReproc_genIspParams (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo, int mode) override;
    XCamReturn rawReProc_prepare (uint32_t sequence, rk_aiq_frame_info_t *offline_finfo) override;
    //fake sensor
    static const char* rawReproc_preInit(const char* isp_driver, const char* offline_sns_ent_name);
    XCamReturn rawReproc_deInit (const char* fakeSensor);

    XCamReturn getEffectiveIspParams(rkisp_effect_params_v20& ispParams, uint32_t frame_id) override;
    void setHdrGlobalTmoMode(uint32_t frame_id, bool mode);
    XCamReturn setSharpFbcRotation(rk_aiq_rotation_t rot) {
        _sharp_fbc_rotation = rot;
        return XCAM_RETURN_NO_ERROR;
    }
    XCamReturn notify_sof(SmartPtr<VideoBuffer>& buf);
    SmartPtr<ispHwEvt_t> make_ispHwEvt (uint32_t sequence, int type, int64_t timestamp);
    int get_workingg_mode() {
        return _hdr_mode;
    }
    //should be called after prepare
    XCamReturn get_stream_format(rkaiq_stream_type_t type, struct v4l2_format &format);
    XCamReturn get_sp_resolution(int &width, int &height, int &aligned_w, int &aligned_h) override;
    XCamReturn showOtpPdafData(struct rkmodule_pdaf_inf *otp_pdaf);
    XCamReturn showOtpAfData(struct rkmodule_af_inf *otp_af);
#if RKAIQ_HAVE_PDAF
    bool get_pdaf_support() override;
#endif
    virtual XCamReturn setIspStreamMode(rk_isp_stream_mode_t mode) override {
        if (mode == RK_ISP_STREAM_MODE_ONLNIE) {
            mNoReadBack = true;
        } else if (mode == RK_ISP_STREAM_MODE_OFFLNIE) {
            mNoReadBack = false;
        } else {
            return XCAM_RETURN_ERROR_FAILED;
        }
        return XCAM_RETURN_NO_ERROR;
    }
    virtual rk_isp_stream_mode_t getIspStreamMode() override {
        if (true == mNoReadBack)
            return RK_ISP_STREAM_MODE_ONLNIE;
        else
            return RK_ISP_STREAM_MODE_OFFLNIE;
    }
    void notify_isp_stream_status(bool on);
    bool getParamsForEffMap(uint32_t frameId);
    XCamReturn reset_hardware() override;

    // FIXME: Set struct to static.
    static sensor_info_share_t rk1608_share_inf;

    virtual void setUserSensorFormat(uint16_t width, uint16_t height, uint16_t code) override {
        userSensorWidth = width;
        userSensorHeight = height;
        userSensorFmtCode = code;
    }

    // cif scale flag
    XCamReturn setCifSclStartFlag(int ratio, bool mode);

private:
    using V4l2Device::start;

#if defined(ISP_HW_V20)
    XCamReturn handlePpReslut(SmartPtr<cam3aResult> &result);
    XCamReturn setPpConfig(SmartPtr<cam3aResult> &result);
#endif
    XCamReturn setExposureParams(SmartPtr<RkAiqExpParamsProxy>& expPar);
    XCamReturn setIrisParams(SmartPtr<RkAiqIrisParamsProxy>& irisPar, CalibDb_IrisTypeV2_t irisType);
    XCamReturn setHdrProcessCount(rk_aiq_luma_params_t luma_params) override;
    XCamReturn setFocusParams(SmartPtr<RkAiqFocusParamsProxy>& focus_params);
    XCamReturn setCpslParams(SmartPtr<RkAiqCpslParamsProxy>& cpsl_params);
    XCamReturn setupHdrLink(int mode, int isp_index, bool enable);
    static void findAttachedSubdevs(struct media_device *device, uint32_t count, rk_sensor_full_info_t *s_info);
    XCamReturn setExpDelayInfo(int mode);
    void analyzePpInitEns(SmartPtr<cam3aResult> &result);
    XCamReturn get_sensor_pdafinfo(rk_sensor_full_info_t *sensor_info, rk_sensor_pdaf_info_t *pdaf_info);
protected:
    XCAM_DEAD_COPY(CamHwIsp20);
    virtual XCamReturn setIspConfig(cam3aResultList* result_list = NULL);
    virtual void updateEffParams(void* params, void* ori_params = NULL) { return; }
    virtual bool processTb(void* params) { return false; }
    virtual XCamReturn poll_buffer_ready (SmartPtr<VideoBuffer> &buf) override;
    enum cam_hw_state_e {
        CAM_HW_STATE_INVALID,
        CAM_HW_STATE_INITED,
        CAM_HW_STATE_PREPARED,
        CAM_HW_STATE_STARTED,
        CAM_HW_STATE_PAUSED,
        CAM_HW_STATE_STOPPED,
    };
    enum ircut_state_e {
        IRCUT_STATE_CLOSED, /* close ir-cut,meaning that infrared ray can be received */
        IRCUT_STATE_CLOSING,
        IRCUT_STATE_OPENING,
        IRCUT_STATE_OPENED, /* open ir-cut,meaning that only visible light can be received */
    };

    typedef struct calib_infos_s {
        struct {
            bool enable;
            bool motion_detect_en;
        } mfnr;

        struct {
            CalibDb_IrisTypeV2_t IrisType;
        } aec;

        struct {
            CalibDbV2_Af_VcmCfg_t vcmcfg;
            CalibDbV2_Af_LdgParam_t ldg_param;
            CalibDbV2_Af_HighLightParam_t highlight;
        } af;

        struct {
            CalibDb_DcgSetV2_t CISDcgSet;
            CalibDb_ExpUpdate_CombV2_t CISExpUpdate;
        } sensor;
    } calib_infos_t;
    calib_infos_t _cur_calib_infos;
    int _hdr_mode;
    Mutex _isp_params_cfg_mutex;
    int _state;
    volatile bool _is_exit;
    bool _linked_to_isp;
    bool _linked_to_1608;
#if defined(ISP_HW_V20)
    struct rkispp_params_cfg _full_active_ispp_params;
    uint32_t _ispp_module_init_ens;
    SmartPtr<V4l2SubDevice> _ispp_sd;
#endif
    SmartPtr<V4l2SubDevice> _cif_csi2_sd;
    char sns_name[32];
public:
    static std::unordered_map<std::string, SmartPtr<rk_aiq_static_info_t>> mCamHwInfos;
    static rk_aiq_isp_hw_info_t mIspHwInfos;
    static rk_aiq_cif_hw_info_t mCifHwInfos;
    static std::unordered_map<std::string, SmartPtr<rk_sensor_full_info_t>> mSensorHwInfos;
    static std::unordered_map<std::string, std::string> mFakeCameraName;
protected:
    static bool mIsMultiIspMode;
    static uint16_t mMultiIspExtendedPixel;
    // TODO: Sync 1608 sensor start streaming
    static XCam::Mutex  _sync_1608_mutex;
    static bool         _sync_1608_done;
#if defined(ISP_HW_V20)
    void gen_full_ispp_params(const struct rkispp_params_cfg* update_params,
                              struct rkispp_params_cfg* full_params);
#endif
#if 0
    void dump_isp_config(struct isp2x_isp_params_cfg* isp_params,
                         SmartPtr<RkAiqIspParamsProxy> aiq_results,
                         SmartPtr<RkAiqIspParamsProxy> aiq_other_results);
    void dumpRawnrFixValue(struct isp2x_rawnr_cfg * pRawnrCfg );
    void dumpTnrFixValue(struct rkispp_tnr_config  * pTnrCfg);
    void dumpUvnrFixValue(struct rkispp_nr_config  * pNrCfg);
    void dumpYnrFixValue(struct rkispp_nr_config  * pNrCfg);
    void dumpSharpFixValue(struct rkispp_sharp_config  * pSharpCfg);
#endif
    XCamReturn setIrcutParams(bool on);
    XCamReturn setIsppSharpFbcRot(struct rkispp_sharp_config* shp_cfg);
    XCamReturn setupPipelineFmt();
    XCamReturn setupPipelineFmtIsp(struct v4l2_subdev_selection& sns_sd_sel,
                                   struct v4l2_subdev_format& sns_sd_fmt,
                                   __u32 sns_v4l_pix_fmt);
    XCamReturn setupPipelineFmtCif(struct v4l2_subdev_selection& sns_sd_sel,
                                   struct v4l2_subdev_format& sns_sd_fmt,
                                   __u32 sns_v4l_pix_fmt);
    XCamReturn setupHdrLink_vidcap(int hdr_mode, int cif_index, bool enable);
#if defined(ISP_HW_V20)
    XCamReturn init_pp(rk_sensor_full_info_t *s_info);
#endif
    virtual bool isOnlineByWorkingMode();
    enum mipi_stream_idx {
        MIPI_STREAM_IDX_0   = 1,
        MIPI_STREAM_IDX_1   = 2,
        MIPI_STREAM_IDX_2   = 4,
        MIPI_STREAM_IDX_ALL = 7,
    };
    XCamReturn hdr_mipi_start_mode(int mode);
    XCamReturn hdr_mipi_stop();
    XCamReturn hdr_mipi_prepare_mode(int mode);
    static void allocMemResource(uint8_t id, void *ops_ctx, void *config, void **mem_ctx);
    static void releaseMemResource(uint8_t id, void *mem_ctx);
    static void* getFreeItem(uint8_t id, void *mem_ctx);
    uint64_t _isp_module_ens{0};
    bool mNoReadBack;
    rk_aiq_rotation_t _sharp_fbc_rotation;

    rk_aiq_ldch_share_mem_info_t ldch_mem_info_array[2 * ISP2X_MESH_BUF_NUM];
    rk_aiq_fec_share_mem_info_t fec_mem_info_array[FEC_MESH_BUF_NUM];
    rk_aiq_cac_share_mem_info_t cac_mem_info_array[2 * ISP3X_MESH_BUF_NUM];
    rk_aiq_dbg_share_mem_info_t dbg_mem_info_array[2 * RKISP_INFO2DDR_BUF_MAX];
    typedef struct drv_share_mem_ctx_s {
        void* ops_ctx;
        void* mem_info;
        rk_aiq_drv_share_mem_type_t type;
    } drv_share_mem_ctx_t;
    drv_share_mem_ctx_t _ldch_drv_mem_ctx;
    drv_share_mem_ctx_t _fec_drv_mem_ctx;
    drv_share_mem_ctx_t _cac_drv_mem_ctx;
    drv_share_mem_ctx_t _dbg_drv_mem_ctx;
    Mutex _mem_mutex;
    rk_aiq_rect_t _crop_rect;
    uint32_t _ds_width;
    uint32_t _ds_heigth;
    uint32_t _ds_width_align;
    uint32_t _ds_heigth_align;
    uint32_t _exp_delay;
    rk_aiq_lens_descriptor _lens_des;
    //ispp
#if defined(ISP_HW_V20)
    SmartPtr<FecParamStream>    mFecParamStream;
    SmartPtr<NrStreamProcUnit>  mNrStreamProcUnit;
    SmartPtr<TnrStreamProcUnit> mTnrStreamProcUnit;
#endif
    //isp
    SmartPtr<RKStream>          mLumaStream;
    SmartPtr<RKStatsStream>     mIspStatsStream;
    SmartPtr<RKStream>          mIspParamStream;
    SmartPtr<RKSofEventStream>  mIspSofStream;
#if defined(RKAIQ_ENABLE_SPSTREAM)
    SmartPtr<SPStreamProcUnit> mSpStreamUnit;
#endif
    SmartPtr<RkStreamEventPollThread> mIspStremEvtTh;

    SmartPtr<RawStreamCapUnit> mRawCapUnit;
    SmartPtr<RawStreamProcUnit> mRawProcUnit;

    SmartPtr<CifSclStream> mCifScaleStream;

    SmartPtr<PdafStreamProcUnit> mPdafStreamUnit;

    SmartPtr<cam3aResult> get_3a_module_result (cam3aResultList &results, int32_t type);
    XCamReturn handleIsp3aReslut(SmartPtr<cam3aResult> &result);
    XCamReturn handleIsp3aReslut(cam3aResultList& list);
    virtual XCamReturn dispatchResult(SmartPtr<cam3aResult> cam3a_result);
    virtual XCamReturn dispatchResult(cam3aResultList& list);

    std::map<int, cam3aResultList> _camIsp3aResult;

    std::map<uint32_t, SmartPtr<RkAiqIspEffParamsProxy>> _effecting_ispparam_map;
    SmartPtr<RkAiqIspEffParamsPool> mEffectIspParamsPool;
#ifndef DISABLE_PARAMS_ASSEMBLER
    SmartPtr<IspParamsAssembler> mParamsAssembler;
#endif
    uint32_t mPpModuleInitEns;
    bool mVicapIspPhyLinkSupported; // if phsical link between vicap and isp, only isp3x support now
    SmartPtr<IspParamsSplitter> mParamsSplitter;
    enum ISP_STREAM_STATUS_E {
        ISP_STREAM_STATUS_INVALID,
        ISP_STREAM_STATUS_STREAM_ON,
        ISP_STREAM_STATUS_STREAM_OFF,
    };
    int _isp_stream_status;

    rk_sensor_pdaf_info_t mPdafInfo;

    Mutex     _stop_cond_mutex;

    // TODO: Sync(1608 sensor) sdk hwEvt cb
    XCam::Cond      _sync_done_cond;
    XCamReturn      waitLastSensorDone();
    XCamReturn pixFmt2Bpp(uint32_t pixFmt, int8_t& bpp);
    uint32_t _curIspParamsSeq;

    uint16_t userSensorWidth;
    uint16_t userSensorHeight;
    uint16_t userSensorFmtCode;

    bool _not_skip_first{true};
    struct isp32_rawawb_meas_cfg _first_awb_cfg{};
};

}
#endif