/*
 * Copyright (C) 2019-2020 Intel 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.
 */

#define LOG_TAG "IPC_INTEL_CMC"

#include "modules/sandboxing/IPCIntelCmc.h"

#include "iutils/CameraLog.h"
#include "iutils/Utils.h"

namespace icamera {
IPCIntelCmc::IPCIntelCmc() {
    LOGIPC("@%s", __func__);
}

IPCIntelCmc::~IPCIntelCmc() {
    LOGIPC("@%s", __func__);
}

bool IPCIntelCmc::clientFlattenInit(const ia_binary_data& aiqb, const ia_binary_data* nvmData,
                                    cmc_init_params* params) {
    LOGIPC("@%s, aiqb: data:%p, size:%d, nvmData %p, params:%p", __func__, aiqb.data, aiqb.size,
           nvmData, params);

    CheckError(!params, false, "@%s, params is nullptr", __func__);
    CheckError(!aiqb.data, false, "@%s, aiqb.data is nullptr", __func__);
    CheckError(aiqb.size == 0, false, "@%s, aiqb.size is 0", __func__);
    CheckError(aiqb.size > sizeof(params->input.data), false, "@%s, aiqb:%d is too big", __func__,
               aiqb.size);

    ia_binary_data_mod* input = &params->input;
    char* ptr = input->data;

    MEMCPY_S(ptr, sizeof(input->data), aiqb.data, aiqb.size);
    params->aiqb_size = aiqb.size;

    params->nvm_size = 0;
    ptr += aiqb.size;
    if (nvmData) {
        MEMCPY_S(ptr, sizeof(input->data) - aiqb.size, nvmData->data, nvmData->size);
        params->nvm_size = nvmData->size;
    }

    return true;
}

bool IPCIntelCmc::clientUnflattenInit(const cmc_init_params& params, ia_cmc_t** cmc,
                                      uintptr_t* cmcRemoteHandle) {
    LOGIPC("@%s, cmc:%p", __func__, cmc);
    CheckError(!cmc, false, "@%s, cmc is nullptr", __func__);

    int ret = unflattenCmcData(const_cast<ia_cmc_data*>(&params.results));
    CheckError(ret == false, false, "%s, unflattenCmcData fails", __func__);

    *cmc = const_cast<ia_cmc_t*>(&params.results.base);
    *cmcRemoteHandle = params.results.cmcRemoteHandle;

    return true;
}

bool IPCIntelCmc::serverUnflattenInit(const cmc_init_params& params, ia_binary_data* aiqb,
                                     ia_binary_data* nvmData) {
    LOGIPC("@%s, aiqb:%p, nvmData:%p", __func__, aiqb, nvmData);
    CheckError(aiqb == nullptr, false, "@%s, aiqb is nullptr", __func__);
    CheckError(nvmData == nullptr, false, "@%s, nvmData is nullptr", __func__);

    ia_binary_data_mod* input = const_cast<ia_binary_data_mod*>(&params.input);
    aiqb->data = input->data;
    aiqb->size = params.aiqb_size;

    if (params.nvm_size > 0) {
        nvmData->data = input->data + aiqb->size;
        nvmData->size = params.nvm_size;
    }

    return true;
}

bool IPCIntelCmc::serverFlattenInit(const ia_cmc_t& cmc, cmc_init_params* params) {
    LOGIPC("@%s, params:%p", __func__, params);
    CheckError(!params, false, "@%s, params is nullptr", __func__);

    int ret = flattenCmcData(&cmc, &params->results);
    CheckError(ret == false, false, "%s flattenCmcData fails", __func__);

    return true;
}

bool IPCIntelCmc::flattenCmcData(const ia_cmc_t* cmc, ia_cmc_data* results) {
    CheckError(!cmc || !results, false, "%s, cmc or results is nullptr", __func__);

    results->base = *cmc;
    results->cmcRemoteHandle = reinterpret_cast<uintptr_t>(cmc);

    ia_cmc_t* base = &results->base;
    if (base->cmc_general_data) {
        results->cmc_general_data = *base->cmc_general_data;
    }

    cmc_parsed_black_level_t* baseBL = &base->cmc_parsed_black_level;
    cmc_parsed_black_level_data* retBL = &results->cmc_parsed_black_level;
    if (baseBL->cmc_black_level) {
        retBL->cmc_black_level = *baseBL->cmc_black_level;
    }
    if (baseBL->cmc_black_level_luts) {
        retBL->cmc_black_level_luts = *baseBL->cmc_black_level_luts;
    }

    if (base->cmc_saturation_level) {
        results->cmc_saturation_level = *base->cmc_saturation_level;
    }

    if (base->cmc_sensitivity) {
        results->cmc_sensitivity = *base->cmc_sensitivity;
    }

    cmc_parsed_lens_shading_t* baseLS = &base->cmc_parsed_lens_shading;
    cmc_parsed_lens_shading_data* retLS = &results->cmc_parsed_lens_shading;
    if (baseLS->cmc_lens_shading) {
        retLS->cmc_lens_shading = *baseLS->cmc_lens_shading;
    }
    if (baseLS->cmc_lsc_grids) {
        retLS->cmc_lsc_grids = *baseLS->cmc_lsc_grids;
    }
    if (baseLS->lsc_grids) {
        retLS->lsc_grids = *baseLS->lsc_grids;
    }
    if (baseLS->cmc_lsc_rg_bg_ratios) {
        retLS->cmc_lsc_rg_bg_ratios = *baseLS->cmc_lsc_rg_bg_ratios;
    }

    cmc_parsed_optics_t* baseOptics = &base->cmc_parsed_optics;
    cmc_parsed_optics_data* retOptics = &results->cmc_parsed_optics;
    if (baseOptics->cmc_optomechanics) {
        retOptics->cmc_optomechanics = *baseOptics->cmc_optomechanics;
    }
    if (baseOptics->lut_apertures) {
        retOptics->lut_apertures = *baseOptics->lut_apertures;
    }

    cmc_parsed_color_matrices_t* baseCM = &base->cmc_parsed_color_matrices;
    cmc_parsed_color_matrices_data* retCM = &results->cmc_parsed_color_matrices;
    if (baseCM->cmc_color_matrices) {
        retCM->cmc_color_matrices = *baseCM->cmc_color_matrices;
    }
    if (baseCM->cmc_color_matrix) {
        // fix asan issue:base->cmc_parsed_color_matrices.cmc_color_matrix is not 4 aligned
        // use memcpy instead of *
        MEMCPY_S(&retCM->cmc_color_matrix, sizeof(retCM->cmc_color_matrix),
                 baseCM->cmc_color_matrix, sizeof(cmc_color_matrix_t));
    }
    if (baseCM->ccm_estimate_method) {
        retCM->ccm_estimate_method = *baseCM->ccm_estimate_method;
    }

    cmc_parsed_analog_gain_conversion_t* baseAGC = &base->cmc_parsed_analog_gain_conversion;
    cmc_parsed_analog_gain_conversion_data* retAGC = &results->cmc_parsed_analog_gain_conversion;
    if (baseAGC->cmc_analog_gain_conversion) {
        retAGC->cmc_analog_gain_conversion = *baseAGC->cmc_analog_gain_conversion;

        CheckError(baseAGC->cmc_analog_gain_conversion->num_segments > MAX_NUM_SEGMENTS, false,
                   "@%s, num_segments:%d is too big", __func__,
                   baseAGC->cmc_analog_gain_conversion->num_segments);
        CheckError(baseAGC->cmc_analog_gain_conversion->num_pairs > MAX_NUM_ANALOG_PAIRS, false,
                   "@%s, num_pairs:%d is too big", __func__,
                   baseAGC->cmc_analog_gain_conversion->num_pairs);

        if (baseAGC->cmc_analog_gain_segments) {
            MEMCPY_S(retAGC->cmc_analog_gain_segments, sizeof(retAGC->cmc_analog_gain_segments),
                     baseAGC->cmc_analog_gain_segments,
                     (sizeof(*baseAGC->cmc_analog_gain_segments) *
                      baseAGC->cmc_analog_gain_conversion->num_segments));
        }
        if (baseAGC->cmc_analog_gain_pairs) {
            MEMCPY_S(retAGC->cmc_analog_gain_pairs, sizeof(retAGC->cmc_analog_gain_pairs),
                     baseAGC->cmc_analog_gain_pairs,
                     (sizeof(*baseAGC->cmc_analog_gain_pairs) *
                      baseAGC->cmc_analog_gain_conversion->num_pairs));
        }
    }

    return true;
}

bool IPCIntelCmc::unflattenCmcData(ia_cmc_data* results) {
    LOGIPC("@%s", __func__);
    CheckError(!results, false, "%s, results is nullptr", __func__);

    ia_cmc_t* base = &results->base;

    if (base->cmc_general_data) {
        base->cmc_general_data = &results->cmc_general_data;
    }

    cmc_parsed_black_level_t* baseBL = &base->cmc_parsed_black_level;
    cmc_parsed_black_level_data* retBL = &results->cmc_parsed_black_level;
    if (baseBL->cmc_black_level) {
        baseBL->cmc_black_level = &retBL->cmc_black_level;
    }
    if (baseBL->cmc_black_level_luts) {
        baseBL->cmc_black_level_luts = &retBL->cmc_black_level_luts;
    }

    if (base->cmc_saturation_level) {
        base->cmc_saturation_level = &results->cmc_saturation_level;
    }

    if (base->cmc_sensitivity) {
        base->cmc_sensitivity = &results->cmc_sensitivity;
    }

    cmc_parsed_lens_shading_t* baseLS = &base->cmc_parsed_lens_shading;
    cmc_parsed_lens_shading_data* retLS = &results->cmc_parsed_lens_shading;
    if (baseLS->cmc_lens_shading) {
        baseLS->cmc_lens_shading = &retLS->cmc_lens_shading;
    }
    if (baseLS->cmc_lsc_grids) {
        baseLS->cmc_lsc_grids = &retLS->cmc_lsc_grids;
    }
    if (baseLS->lsc_grids) {
        baseLS->lsc_grids = &retLS->lsc_grids;
    }
    if (baseLS->cmc_lsc_rg_bg_ratios) {
        baseLS->cmc_lsc_rg_bg_ratios = &retLS->cmc_lsc_rg_bg_ratios;
    }

    cmc_parsed_optics_t* baseOptics = &base->cmc_parsed_optics;
    cmc_parsed_optics_data* retOptics = &results->cmc_parsed_optics;
    if (baseOptics->cmc_optomechanics) {
        baseOptics->cmc_optomechanics = &retOptics->cmc_optomechanics;
    }
    if (baseOptics->lut_apertures) {
        baseOptics->lut_apertures = &retOptics->lut_apertures;
    }

    cmc_parsed_color_matrices_t* baseCM = &base->cmc_parsed_color_matrices;
    cmc_parsed_color_matrices_data* retCM = &results->cmc_parsed_color_matrices;
    if (baseCM->cmc_color_matrices) {
        baseCM->cmc_color_matrices = &retCM->cmc_color_matrices;
    }
    if (baseCM->cmc_color_matrix) {
        baseCM->cmc_color_matrix = &retCM->cmc_color_matrix;
    }
    if (baseCM->ccm_estimate_method) {
        baseCM->ccm_estimate_method = &retCM->ccm_estimate_method;
    }

    cmc_parsed_analog_gain_conversion_t* baseAGC = &base->cmc_parsed_analog_gain_conversion;
    cmc_parsed_analog_gain_conversion_data* retAGC = &results->cmc_parsed_analog_gain_conversion;
    if (baseAGC->cmc_analog_gain_conversion) {
        baseAGC->cmc_analog_gain_conversion = &retAGC->cmc_analog_gain_conversion;

        if (baseAGC->cmc_analog_gain_segments) {
            baseAGC->cmc_analog_gain_segments = retAGC->cmc_analog_gain_segments;
        }
        if (baseAGC->cmc_analog_gain_pairs) {
            baseAGC->cmc_analog_gain_pairs = retAGC->cmc_analog_gain_pairs;
        }
    }

    return true;
}
} /* namespace icamera */