/*
 * RkAiqSharedDataWrapper.h
 *
 *  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 _RK_AIQ_SHARED_DATA_MANAGER_H_
#define _RK_AIQ_SHARED_DATA_MANAGER_H_

#include <pthread.h>

#include <list>
#include <map>

#include "rk_aiq_algo_types_int.h"
#include "rk_aiq_pool.h"
#include "thumbnails.h"

namespace RkCam {

typedef SharedItemBase sharedData;
typedef std::list<SmartPtr<sharedData>> sharedDataList;
typedef std::map<int32_t, sharedDataList> sharedDataMap;

typedef struct RkAiqSofInfoWrapper_s : public SharedItemData {
    uint32_t sequence;
    SmartPtr<RkAiqExpParamsProxy> preExp;
    SmartPtr<RkAiqExpParamsProxy> curExp;
    int64_t sof;
} RkAiqSofInfoWrapper_t;

typedef SharedItemPool<class RkAiqIspStats>                 RkAiqIspStatsIntPool;
typedef SharedItemProxy<class RkAiqIspStats>                RkAiqIspStatsIntProxy;

typedef SharedItemPool<class RkAiqAecStats>                 RkAiqAecStatsPool;
typedef SharedItemProxy<class RkAiqAecStats>                RkAiqAecStatsProxy;

typedef SharedItemPool<class RkAiqAwbStats>                 RkAiqAwbStatsPool;
typedef SharedItemProxy<class RkAiqAwbStats>                RkAiqAwbStatsProxy;

typedef SharedItemPool<class RkAiqAtmoStats>                RkAiqAtmoStatsPool;
typedef SharedItemProxy<class RkAiqAtmoStats>               RkAiqAtmoStatsProxy;

typedef SharedItemPool<class RkAiqAdehazeStats>             RkAiqAdehazeStatsPool;
typedef SharedItemProxy<class RkAiqAdehazeStats>            RkAiqAdehazeStatsProxy;

typedef SharedItemPool<class RkAiqAfStats>                  RkAiqAfStatsPool;
typedef SharedItemProxy<class RkAiqAfStats>                 RkAiqAfStatsProxy;

typedef SharedItemPool<RkAiqSofInfoWrapper_t>               RkAiqSofInfoWrapperPool;
typedef SharedItemProxy<RkAiqSofInfoWrapper_t>              RkAiqSofInfoWrapperProxy;

typedef SharedItemPool<RkAiqOrbStats>                       RkAiqOrbStatsPool;
typedef SharedItemProxy<RkAiqOrbStats>                      RkAiqOrbStatsProxy;

typedef struct RkAiqThumbnailSrcWrapper_s : public SharedItemData {
    SmartPtr<rkaiq_image_source_t>     thumbnail;
} RkAiqThumbnailSrcWrapper_t;
typedef SharedItemPool<RkAiqThumbnailSrcWrapper_t>           RkAiqThumbnailSrcPool;
typedef SharedItemProxy<RkAiqThumbnailSrcWrapper_t>          RkAiqThumbnailSrcProxy;

typedef SharedItemPool<AecProcResult_t>                     RkAiqAeProcResultPool;
typedef SharedItemProxy<AecProcResult_t>                    RkAiqAeProcResultProxy;

class RkAiqSharedDataManager
{
public:
     RkAiqSharedDataManager() {
         rwlock = PTHREAD_RWLOCK_INITIALIZER;
         if (pthread_rwlock_init(&rwlock, nullptr))
             LOGE_ANALYZER("rwlock init failed!");
     };
     ~RkAiqSharedDataManager() {
         if (pthread_rwlock_destroy(&rwlock))
             LOGE_ANALYZER("rwlock destory failed!");
    };

    bool push (const SmartPtr<sharedData> &data) {
        pthread_rwlock_wrlock(&rwlock);
        sharedDataList &list = mSharedDataMap[data->getId()];
        list.push_back(data);
        pthread_rwlock_unlock(&rwlock);

        LOGD_ANALYZER("%s, sharedDatamap size %d, id(%d) push type: %d, list size: %d",
                      __FUNCTION__, mSharedDataMap.size(),
                      data->getId(), data->getType(), list.size());
        return true;
    };

    bool pop() {
        pthread_rwlock_wrlock(&rwlock);
        if (!mSharedDataMap.empty()) {
            auto list = mSharedDataMap.begin()->second;

            LOGD_ANALYZER("%s, sharedDatamap size %d, pop id(%d), list size: %d",
                    __FUNCTION__, mSharedDataMap.size(),
                    mSharedDataMap.begin()->first,
                    list.size());
            list.clear();
            mSharedDataMap.erase(mSharedDataMap.begin());
        }
        pthread_rwlock_unlock(&rwlock);

        return true;
    };

    bool find (int32_t id, RkAiqSharedDataType type, SmartPtr<sharedData> &data) {
        pthread_rwlock_rdlock(&rwlock);
        auto mapIt = mSharedDataMap.find(id);
        if (mapIt == mSharedDataMap.end()) {
            LOGE_ANALYZER("can't find id(%d) in mSharedDataMap");
            pthread_rwlock_unlock(&rwlock);
            return false;
        }

        auto list = mapIt->second;
        auto listIt = list.begin();
        for (; listIt != list.end(); ++listIt) {
            if (type == listIt->ptr()->getType()) {
                data = *listIt;
                break;
            }
        }

        if (listIt == list.end()) {
            LOGE_ANALYZER("can't find type(%d) data in list", type);
            pthread_rwlock_unlock(&rwlock);
            return false;
        }

        pthread_rwlock_unlock(&rwlock);

        return true;
    };

    uint32_t clear () {
        pthread_rwlock_wrlock(&rwlock);
        for (auto mapIt = mSharedDataMap.begin(); mapIt != mSharedDataMap.end();) {
            auto list = mapIt->second;
            list.clear();
            mSharedDataMap.erase(mapIt++);
        }
        pthread_rwlock_unlock(&rwlock);

        return true;
    };

    uint32_t get_size () {
        return mSharedDataMap.size();
    };

    bool get_exposure_params(int32_t id, RKAiqAecExpInfo_t **exp_param);
    bool get_ae_stats(int32_t id, rk_aiq_isp_aec_stats_t *aec_stats);
    bool get_awb_stats(int32_t id, rk_aiq_awb_stat_res_v200_t *awb_stats);
    bool get_af_stats(int32_t id, rk_aiq_isp_af_stats_t *af_stats);

protected:

private:
    sharedDataMap mSharedDataMap;
    pthread_rwlock_t rwlock;
};

template<class T>
struct AlgoRstShared: VideoBuffer {
    T   result;
    virtual uint8_t *map ();
    virtual bool unmap ();
    virtual int get_fd ();
};

template<class T>
uint8_t *AlgoRstShared<T>::map() {
   return (uint8_t *)(&result);
}

template<class T>
bool AlgoRstShared<T>::unmap() {
   return true;
}

template<class T>
int AlgoRstShared<T>::get_fd ()
{
    return -1;
}

using RkAiqAlgoPreResAeIntShared = AlgoRstShared<RkAiqAlgoPreResAeInt>;
using RkAiqAlgoProcResAeIntShared = AlgoRstShared<RkAiqAlgoProcResAeInt>;
using RkAiqAlgoProcResAwbIntShared = AlgoRstShared<RkAiqAlgoProcResAwbInt>;
using RkAiqAlgoProcResAfIntShared = AlgoRstShared<RkAiqAlgoProcResAfInt>;
using RkAiqAlgoProcResAmdIntShared = AlgoRstShared<RkAiqAlgoProcResAmdInt>;

};

#endif // _RK_AIQ_SHARED_DATA_MANAGER_H_