/*
 * Copyright (C) 2019 The Android Open Source Project
 *
 * 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 EXYNOS_DISPLAY_MODULE_H
#define EXYNOS_DISPLAY_MODULE_H

#include <gs101/displaycolor/displaycolor_gs101.h>

#include "ExynosDeviceModule.h"
#include "ExynosDisplay.h"
#include "ExynosLayer.h"
#include "ExynosPrimaryDisplay.h"

constexpr char kAtcJsonRaw[] =
        "{\"version\":\"0.0\",\"modes\":[{\"name\":\"normal\",\"lux_map\":[0,5000,10000,"
        "50000,70000],\"ambient_light_map\":[0,0,12,32,63],\"strength_map\":[0,0,128,128,200],"
        "\"st_up_step\":2, \"st_down_step\":2,"
        "\"sub_setting\":{\"local_tone_gain\":128,\"noise_suppression_gain\":128,\"dither\":0,"
        "\"plain_weight_1\":10,\"plain_weight_2\":14,\"color_transform_mode\":2,\"preprocessing_"
        "enable\":1,\"upgrade_on\":0,\"TDR_max\":900,\"TDR_min\":256,\"backlight\":255,\"dimming_"
        "step\":4,\"scale_mode\":1,\"threshold_1\":1,\"threshold_2\":1,\"threshold_3\":1,\"gain_"
        "limit\":511,\"lt_calc_ab_shift\":1}}]}";

constexpr char kAtcProfilePath[] = "vendor/etc/atc_profile.json";
constexpr char kAtcProfileVersionStr[] = "version";
constexpr char kAtcProfileModesStr[] = "modes";
constexpr char kAtcProfileModeNameStr[] = "name";
constexpr char kAtcProfileLuxMapStr[] = "lux_map";
constexpr char kAtcProfileAlMapStr[] = "ambient_light_map";
constexpr char kAtcProfileStMapStr[] = "strength_map";
constexpr char kAtcProfileSubSettingStr[] = "sub_setting";
constexpr char kAtcProfileStUpStepStr[] = "st_up_step";
constexpr char kAtcProfileStDownStepStr[] = "st_down_step";
constexpr uint32_t kAtcStStep = 2;

constexpr char kAtcModeNormalStr[] = "normal";
constexpr char kAtcModeHbmStr[] = "hbm";
constexpr char kAtcModePowerSaveStr[] = "power_save";

#define ATC_AMBIENT_LIGHT_FILE_NAME "/sys/class/dqe/atc/ambient_light"
#define ATC_ST_FILE_NAME "/sys/class/dqe/atc/st"
#define ATC_ENABLE_FILE_NAME "/sys/class/dqe/atc/en"
#define ATC_LT_FILE_NAME "/sys/class/dqe/atc/lt"
#define ATC_NS_FILE_NAME "/sys/class/dqe/atc/ns"
#define ATC_DITHER_FILE_NAME "/sys/class/dqe/atc/dither"
#define ATC_PL_W1_FILE_NAME "/sys/class/dqe/atc/pl_w1"
#define ATC_PL_W2_FILE_NAME "/sys/class/dqe/atc/pl_w2"
#define ATC_CTMODE_FILE_NAME "/sys/class/dqe/atc/ctmode"
#define ATC_PP_EN_FILE_NAME "/sys/class/dqe/atc/pp_en"
#define ATC_UPGRADE_ON_FILE_NAME "/sys/class/dqe/atc/upgrade_on"
#define ATC_TDR_MAX_FILE_NAME "/sys/class/dqe/atc/tdr_max"
#define ATC_TDR_MIN_FILE_NAME "/sys/class/dqe/atc/tdr_min"
#define ATC_BACKLIGHT_FILE_NAME "/sys/class/dqe/atc/back_light"
#define ATC_DSTEP_FILE_NAME "/sys/class/dqe/atc/dstep"
#define ATC_SCALE_MODE_FILE_NAME "/sys/class/dqe/atc/scale_mode"
#define ATC_THRESHOLD_1_FILE_NAME "/sys/class/dqe/atc/threshold_1"
#define ATC_THRESHOLD_2_FILE_NAME "/sys/class/dqe/atc/threshold_2"
#define ATC_THRESHOLD_3_FILE_NAME "/sys/class/dqe/atc/threshold_3"
#define ATC_GAIN_LIMIT_FILE_NAME "/sys/class/dqe/atc/gain_limit"
#define ATC_LT_CALC_AB_SHIFT_FILE_NAME "/sys/class/dqe/atc/lt_calc_ab_shift"

const std::unordered_map<std::string, std::string> kAtcSubSetting =
        {{"local_tone_gain", ATC_LT_FILE_NAME},
         {"noise_suppression_gain", ATC_NS_FILE_NAME},
         {"dither", ATC_DITHER_FILE_NAME},
         {"plain_weight_1", ATC_PL_W1_FILE_NAME},
         {"plain_weight_2", ATC_PL_W2_FILE_NAME},
         {"color_transform_mode", ATC_CTMODE_FILE_NAME},
         {"preprocessing_enable", ATC_PP_EN_FILE_NAME},
         {"upgrade_on", ATC_UPGRADE_ON_FILE_NAME},
         {"TDR_max", ATC_TDR_MAX_FILE_NAME},
         {"TDR_min", ATC_TDR_MIN_FILE_NAME},
         {"backlight", ATC_BACKLIGHT_FILE_NAME},
         {"dimming_step", ATC_DSTEP_FILE_NAME},
         {"scale_mode", ATC_SCALE_MODE_FILE_NAME},
         {"threshold_1", ATC_THRESHOLD_1_FILE_NAME},
         {"threshold_2", ATC_THRESHOLD_2_FILE_NAME},
         {"threshold_3", ATC_THRESHOLD_3_FILE_NAME},
         {"gain_limit", ATC_GAIN_LIMIT_FILE_NAME},
         {"lt_calc_ab_shift", ATC_LT_CALC_AB_SHIFT_FILE_NAME}};

namespace gs101 {

using namespace displaycolor;

class ExynosPrimaryDisplayModule : public ExynosPrimaryDisplay {
    public:
        ExynosPrimaryDisplayModule(uint32_t index, ExynosDevice *device);
        ~ExynosPrimaryDisplayModule();
        void usePreDefinedWindow(bool use);
        virtual int32_t validateWinConfigData();
        void doPreProcessing();
        virtual int32_t getColorModes(
                uint32_t* outNumModes,
                int32_t* outModes);
        virtual int32_t setColorMode(int32_t mode);
        virtual int32_t getRenderIntents(int32_t mode, uint32_t* outNumIntents,
                int32_t* outIntents);
        virtual int32_t setColorModeWithRenderIntent(int32_t mode,
                int32_t intent);
        virtual int32_t setColorTransform(const float* matrix, int32_t hint);
        virtual int deliverWinConfigData();
        virtual int32_t updateColorConversionInfo();
        virtual int32_t updatePresentColorConversionInfo();
        virtual bool checkRrCompensationEnabled() {
            const DisplayType display = getDisplayTypeFromIndex(mIndex);
            IDisplayColorGS101* displayColorInterface = getDisplayColorInterface();
            return displayColorInterface->IsRrCompensationEnabled(display);
        }

        virtual bool isColorCalibratedByDevice();

        virtual int32_t getColorAdjustedDbv(uint32_t &dbv_adj);

        virtual void initLbe();
        virtual void setLbeState(LbeState state);
        virtual void setLbeAmbientLight(int value);
        virtual LbeState getLbeState();

        class DisplaySceneInfo {
            public:
                struct LayerMappingInfo {
                    bool operator==(const LayerMappingInfo &rhs) const {
                        return ((dppIdx == rhs.dppIdx) && (planeId == rhs.planeId));
                    }

                    // index in DisplayScene::layer_data
                    uint32_t dppIdx;
                    // assigned drm plane id in last color setting update
                    uint32_t planeId;
                };
                bool colorSettingChanged = false;
                bool displaySettingDelivered = false;
                DisplayScene displayScene;

                /*
                 * Index of LayerColorData in DisplayScene::layer_data
                 * and assigned plane id in last color setting update.
                 * for each layer, including client composition
                 * key: ExynosMPPSource*
                 * data: LayerMappingInfo
                 */
                std::map<ExynosMPPSource*, LayerMappingInfo> layerDataMappingInfo;
                std::map<ExynosMPPSource*, LayerMappingInfo> prev_layerDataMappingInfo;

                void reset() {
                    colorSettingChanged = false;
                    prev_layerDataMappingInfo = layerDataMappingInfo;
                    layerDataMappingInfo.clear();
                };

                template <typename T, typename M>
                void updateInfoSingleVal(T &dst, M &src) {
                    if (src != dst) {
                        colorSettingChanged = true;
                        dst = src;
                    }
                };

                template <typename T, typename M>
                void updateInfoVectorVal(std::vector<T> &dst, M *src, uint32_t size) {
                    if ((dst.size() != size) ||
                        !std::equal(dst.begin(), dst.end(), src)) {
                        colorSettingChanged = true;
                        dst.resize(size);
                        for (uint32_t i = 0; i < size; i++) {
                            dst[i] = src[i];
                        }
                    }
                };

                void setColorMode(hwc::ColorMode mode) {
                    updateInfoSingleVal(displayScene.color_mode, mode);
                };

                void setRenderIntent(hwc::RenderIntent intent) {
                    updateInfoSingleVal(displayScene.render_intent, intent);
                };

                void setColorTransform(const float* matrix) {
                    for (uint32_t i = 0; i < displayScene.matrix.size(); i++) {
                        if (displayScene.matrix[i] != matrix[i]) {
                            colorSettingChanged = true;
                            displayScene.matrix[i] = matrix[i];
                        }
                    }
                }

                LayerColorData& getLayerColorDataInstance(uint32_t index);
                int32_t setLayerDataMappingInfo(ExynosMPPSource* layer, uint32_t index);
                void setLayerDataspace(LayerColorData& layerColorData,
                        hwc::Dataspace dataspace);
                void disableLayerHdrStaticMetadata(LayerColorData& layerColorData);
                void setLayerHdrStaticMetadata(LayerColorData& layerColorData,
                        const ExynosHdrStaticInfo& exynosHdrStaticInfo);
                void setLayerColorTransform(LayerColorData& layerColorData,
                        std::array<float, TRANSFORM_MAT_SIZE> &matrix);
                void disableLayerHdrDynamicMetadata(LayerColorData& layerColorData);
                void setLayerHdrDynamicMetadata(LayerColorData& layerColorData,
                        const ExynosHdrDynamicInfo& exynosHdrDynamicInfo);
                int32_t setLayerColorData(LayerColorData& layerData,
                        ExynosLayer* layer, float dimSdrRatio);
                int32_t setClientCompositionColorData(
                    const ExynosCompositionInfo& clientCompositionInfo,
                    LayerColorData& layerData, float dimSdrRatio);
                bool needDisplayColorSetting();
                void printDisplayScene();
                void printLayerColorData(const LayerColorData& layerData);
        };

        bool hasDisplayColor() {
            IDisplayColorGS101* displayColorInterface = getDisplayColorInterface();
            return displayColorInterface != nullptr;
        }

        /* Call getDppForLayer() only if hasDppForLayer() is true */
        bool hasDppForLayer(ExynosMPPSource* layer);
        const IDisplayColorGS101::IDpp& getDppForLayer(ExynosMPPSource* layer);
        int32_t getDppIndexForLayer(ExynosMPPSource* layer);
        /* Check if layer's assigned plane id has changed, save the new planeId.
         * call only if hasDppForLayer is true */
        bool checkAndSaveLayerPlaneId(ExynosMPPSource* layer, uint32_t planeId) {
            auto &info = mDisplaySceneInfo.layerDataMappingInfo[layer];
            bool change = info.planeId != planeId;
            info.planeId = planeId;
            return change;
        }

        size_t getNumOfDpp() {
            const DisplayType display = getDisplayTypeFromIndex(mIndex);
            IDisplayColorGS101* displayColorInterface = getDisplayColorInterface();
            return displayColorInterface->GetPipelineData(display)->Dpp().size();
        };

        const IDisplayColorGS101::IDqe& getDqe()
        {
            const DisplayType display = getDisplayTypeFromIndex(mIndex);
            IDisplayColorGS101* displayColorInterface = getDisplayColorInterface();
            return displayColorInterface->GetPipelineData(display)->Dqe();
        };

    private:
        int32_t setLayersColorData();
        DisplaySceneInfo mDisplaySceneInfo;

        struct atc_lux_map {
            uint32_t lux;
            uint32_t al;
            uint32_t st;
        };

        struct atc_mode {
            std::vector<atc_lux_map> lux_map;
            std::unordered_map<std::string, int32_t> sub_setting;
            uint32_t st_up_step;
            uint32_t st_down_step;
        };

        bool parseAtcProfile();
        int32_t setAtcMode(std::string mode_name);
        uint32_t getAtcLuxMapIndex(std::vector<atc_lux_map>, uint32_t lux);
        int32_t setAtcAmbientLight(uint32_t ambient_light);
        int32_t setAtcStrength(uint32_t strenght);
        int32_t setAtcStDimming(uint32_t target);
        int32_t setAtcEnable(bool enable);
        void checkAtcAnimation();
        bool isInAtcAnimation() {
            if (mAtcStStepCount > 0)
                return true;
            else
                return false;
        };

        DisplayType getDisplayTypeFromIndex(uint32_t index) {
            return (index >= DisplayType::DISPLAY_MAX) ? DisplayType::DISPLAY_PRIMARY
                                                       : DisplayType(mIndex);
        };

        IDisplayColorGS101* getDisplayColorInterface() {
            ExynosDeviceModule* device = (ExynosDeviceModule*)mDevice;
            return device->getDisplayColorInterface();
        }

        bool isForceColorUpdate() const { return mForceColorUpdate; }
        void setForceColorUpdate(bool force) { mForceColorUpdate = force; }
        bool isDisplaySwitched(int32_t mode, int32_t prevMode);

        std::map<std::string, atc_mode> mAtcModeSetting;
        bool mAtcInit;
        LbeState mCurrentLbeState = LbeState::OFF;
        std::string mCurrentAtcModeName;
        uint32_t mCurrentLux = 0;
        uint32_t mAtcLuxMapIndex = 0;
        CtrlValue<uint32_t> mAtcAmbientLight;
        CtrlValue<uint32_t> mAtcStrength;
        CtrlValue<uint32_t> mAtcEnable;
        std::unordered_map<std::string, CtrlValue<int32_t>> mAtcSubSetting;
        uint32_t mAtcStStepCount = 0;
        uint32_t mAtcStTarget = 0;
        uint32_t mAtcStUpStep;
        uint32_t mAtcStDownStep;
        Mutex mAtcStMutex;
        bool mPendingAtcOff;
        bool mForceColorUpdate = false;

    protected:
        virtual int32_t setPowerMode(int32_t mode) override;
};

}  // namespace gs101

#endif