/*
 *  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.
 *
 */

#include "sample_comm.h"

static void sample_accm_usage()
{
    printf("Usage : \n");
    printf("  ImgProc API: \n");
    printf("\t 0) CCM:         Set CCM MANUAL Mode.\n");
    printf("\t 1) CCM:         Set CCM AUTO Mode.\n");
    printf("\t 2) CCM:         Get CCM Mode.\n");
    printf("\t 3) CCM:         Set CCM Manual Matrix.\n");
    printf("\t 4) CCM:         Get CCM Matrix.\n");
    printf("\t 5) CCM:         Get ACCM Sat-level.\n");
    printf("\t 6) CCM:         Get ACCM Matrix Name.\n");
    printf("  Module API: \n");
	printf("\t a) CCM:         Set Ccm Attr & Sync .\n");
    printf("\t b) CCM:         Set Ccm Attr & Async .\n");
    printf("\t c) CCM:         Set Mode Manual & Sync.\n");
    printf("\t d) CCM:         Set Mode Manual & Async.\n");
    printf("\t e) CCM:         Set Mode Auto & Sync.\n");
    printf("\t f) CCM:         Set Mode Auto & Async.\n");
    printf("\t g) CCM:         Set Manual attr & Sync.\n");
    printf("\t i) CCM:         Set Manual attr & Async.\n");
    printf("\t j) CCM:         Set Auto attr & Sync.\n");
    printf("\t k) CCM:         Set Auto attr & Async.\n");
    printf("\t l) CCM:         Query CCM Info.\n");
    printf("\n");
    printf("\t h) CCM:         help.\n");
    printf("\t q) CCM:         return to main sample screen.\n");

    printf("\n");
    printf("\t please press the key: ");

    return;
}

void sample_print_accm_info(const void *arg)
{
    printf ("enter CCM modult test!\n");
}

/*
******************************
*
* ImgProc level API Sample Func
*
******************************
*/

static int sample_set_ccm_manual(const rk_aiq_sys_ctx_t* ctx)
{
    opMode_t mode = OP_MANUAL;
    rk_aiq_uapi2_setCCMMode(ctx, mode);
    return 0;
}

static int sample_set_ccm_auto(const rk_aiq_sys_ctx_t* ctx)
{
    opMode_t mode = OP_AUTO;
    rk_aiq_uapi2_setCCMMode(ctx, mode);
    return 0;
}

static int sample_get_ccm_mode(const rk_aiq_sys_ctx_t* ctx)
{
    opMode_t mode;
    rk_aiq_uapi2_getCCMMode(ctx, &mode);
    if (mode == OP_MANUAL)
        printf("CCM Mode is: Manual \n");
    else if (mode == OP_AUTO)
        printf("CCM Mode is: AUTO\n");
    else
        printf("CCM Mode is: INVALID\n");
    return 0;
}

static int sample_set_ccm_manual_matrix(const rk_aiq_sys_ctx_t* ctx)
{
    opMode_t mode = OP_MANUAL;
    rk_aiq_ccm_matrix_t mccm;
    memset(&mccm, 0, sizeof(rk_aiq_ccm_matrix_t));
    mccm.ccMatrix[0] = 1.5;
    mccm.ccMatrix[1] = 0;
    mccm.ccMatrix[2] = -0.5;
    mccm.ccMatrix[3] = 0;
    mccm.ccMatrix[4] = 1;
    mccm.ccMatrix[5] = 0;
    mccm.ccMatrix[6] = 0;
    mccm.ccMatrix[7] = 0;
    mccm.ccMatrix[8] = 1;
    mccm.ccOffsets[0] = 1000;
    mccm.ccOffsets[1] = 0;
    mccm.ccOffsets[2] = 0;
    rk_aiq_uapi2_setMCcCoef(ctx, &mccm);
    return 0;
}

static int sample_get_ccm_manual_matrix(const rk_aiq_sys_ctx_t* ctx)
{
    rk_aiq_ccm_matrix_t mccm;
    memset(&mccm, 0, sizeof(rk_aiq_ccm_matrix_t));
    rk_aiq_uapi2_getMCcCoef(ctx, &mccm);
    printf("Get CCM Matrix: ");
    for (int j = 0; j < 9; j++)
        printf("%f ", mccm.ccMatrix[j]);
    printf("\n");
    printf("offs: %f, %f, %f \n", mccm.ccOffsets[0], mccm.ccOffsets[1], mccm.ccOffsets[2]);
    return 0;
}

static int sample_get_accm_sat(const rk_aiq_sys_ctx_t* ctx)
{
    float finalsat;
    rk_aiq_uapi2_getACcmSat(ctx, &finalsat);
    printf("Get ACCM Sat-level: %f\n", finalsat);
    return 0;
}

static int sample_get_accm_matrix_name(const rk_aiq_sys_ctx_t* ctx)
{
    char* ccmname[2];
    ccmname[0] = (char*)malloc(sizeof(char)*25);
    ccmname[1] = (char*)malloc(sizeof(char)*25);
    rk_aiq_uapi2_getACcmMatrixName(ctx, ccmname);
    printf("Get ACCM Matrix Name:  %s   %s \n\n", ccmname[0], ccmname[1]);
    return 0;
}

/*
******************************
*
* Module level API Sample Func
*
******************************
*/

static int sample_ccm_setCcmAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "setCcmAttr failed in getting accm attrib!");
    //modify
    attr.sync.sync_mode = sync;
    attr.mode = RK_AIQ_CCM_MODE_AUTO;
    if (attr.stAuto.color_saturation.level[0] == 100) {
        for (int i = 0; i < 4; i++)
            attr.stAuto.color_saturation.level[i] = 50;
    } else {
        for (int i = 0; i < 4; i++)
            attr.stAuto.color_saturation.level[i] = 100;
    }

    //set
    ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "set CCM Attr failed!");
    printf("set CCM Attr\n\n");

    return 0;
}

static int sample_ccm_getCcmAttr(const rk_aiq_sys_ctx_t* ctx)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "get Ccm Attr failed!");
    printf("get CCM Attr:\n\n");
    printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
    printf("\t enable = %s\n", (attr.byPass ? "false" : "true"));
    if (attr.mode == RK_AIQ_CCM_MODE_MANUAL){
        printf("\t mode = Manual\n");
        printf("\t matrix = [");
        for (int i = 0; i < 9; i++)
            printf("%f ", attr.stManual.ccMatrix[i]);
        printf("\n\t offset = [%f %f %f]\n", attr.stManual.ccOffsets[0],
                                attr.stManual.ccOffsets[1],
                                attr.stManual.ccOffsets[2]);
    } else if (attr.mode == RK_AIQ_CCM_MODE_AUTO){
        printf("\t mode = Auto\n");
        printf("\t color_saturation level = {%f %f %f %f}\n",
                        attr.stAuto.color_saturation.level[0],
                        attr.stAuto.color_saturation.level[1],
                        attr.stAuto.color_saturation.level[2],
                        attr.stAuto.color_saturation.level[3]);
    } else {
        printf("\t mode is invalid!");
    }
    return 0;
}

static int sample_ccm_setModeManual(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "setModeManual failed in getting accm attrib!");
    //modify
    attr.sync.sync_mode = sync;
    attr.mode = RK_AIQ_CCM_MODE_MANUAL;
    //set
    ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Manual failed!");
    printf("set CCM Mode Manual\n\n");

    return 0;
}

static int sample_ccm_setModeAuto(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "setModeAuto failed in getting accm attrib!");
    //modify
    attr.sync.sync_mode = sync;
    attr.mode = RK_AIQ_CCM_MODE_AUTO;
    //set
    ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Auto failed!");
    printf("set CCM Mode Auto\n\n");

    return 0;
}

static int sample_ccm_getMode(const rk_aiq_sys_ctx_t* ctx)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "get Ccm Mode failed!");
    printf("get CCM Mode:\n\n");
    printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
    if (attr.mode == RK_AIQ_CCM_MODE_MANUAL){
        printf("\t mode = Manual\n");
    } else if (attr.mode == RK_AIQ_CCM_MODE_AUTO){
        printf("\t mode = Auto\n");
    } else {
        printf("\t mode is invalid!");
    }
    return 0;
}

static int sample_ccm_setMCcm(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "setMCcm failed in getting accm attrib!");
    //modify
    attr.sync.sync_mode = sync;
    attr.mode = RK_AIQ_CCM_MODE_MANUAL;
    if (attr.stManual.ccOffsets[0] < 1000) {
        attr.stManual.ccOffsets[0] = 1000;
        attr.stManual.ccOffsets[1] = 0;
        attr.stManual.ccOffsets[2] = 0;
    } else {
        attr.stManual.ccOffsets[0] = 0;
        attr.stManual.ccOffsets[1] = 0;
        attr.stManual.ccOffsets[2] = 1000;
    }

    //set
    ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "set Manual attr failed!");
    printf("set Manual attr\n\n");

    return 0;
}

static int sample_ccm_setACcm(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
{
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    rk_aiq_ccm_attrib_t attr;
    memset(&attr,0,sizeof(rk_aiq_ccm_attrib_t));
    //get
    ret = rk_aiq_user_api2_accm_GetAttrib(ctx, &attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "setACcm failed in getting accm attrib!");
    //modify
    attr.sync.sync_mode = sync;
    attr.mode = RK_AIQ_CCM_MODE_AUTO;
    if (attr.stAuto.color_saturation.level[0] == 100) {
        for (int i = 0; i < 4; i++)
            attr.stAuto.color_saturation.level[i] = 50;
    } else {
        for (int i = 0; i < 4; i++)
            attr.stAuto.color_saturation.level[i] = 100;
    }
    //set
    ret = rk_aiq_user_api2_accm_SetAttrib(ctx, attr);
    RKAIQ_SAMPLE_CHECK_RET(ret, "set Auto attr failed!");
    printf("set Auto attr\n\n");

    return 0;
}

static int sample_query_ccm_info(const rk_aiq_sys_ctx_t* ctx)
{
    rk_aiq_ccm_querry_info_t info;
    rk_aiq_user_api2_accm_QueryCcmInfo(ctx, &info);
        printf("Query CCM Info:\n\n");
    printf("\t enable: %s, \n", (info.ccm_en ? "true" : "false"));
    printf("\t matrix: ");
    for (int j = 0; j < 9; j++)
        printf("%f ", info.ccMatrix[j]);
    printf("\n");
    printf("\t offs: %f, %f, %f \n", info.ccOffsets[0], info.ccOffsets[1], info.ccOffsets[2]);
    printf("\t alp_y: ");
    for (int j = 0; j < 17; j++)
        printf("%f ", info.y_alpha_curve[j]);
    printf("\n");
    printf("\t low bound bit: %f \n", info.low_bound_pos_bit);
    printf("\t color inhibition level: %f, color saturation level: %f \n",
					info.color_inhibition_level, info.color_saturation_level);
    printf("\t finalSat: %f \n", info.finalSat);
    printf("\t ccmname1: %s, ccmname2: %s \n", info.ccmname1, info.ccmname2);
    return 0;
}

XCamReturn sample_accm_module(const void *arg)
{
    int key = -1;
    CLEAR();
    const demo_context_t *demo_ctx = (demo_context_t *)arg;
    const rk_aiq_sys_ctx_t* ctx;
    if (demo_ctx->camGroup){
        ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
    } else {
        ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
    }

    /*TODO: when rkaiq_3A_server & rkisp_demo run in two different shell, rk_aiq_sys_ctx_t would be null?*/
    if (ctx == NULL) {
        ERR ("%s, ctx is nullptr\n", __FUNCTION__);
        return XCAM_RETURN_ERROR_PARAM;
    }

    sample_accm_usage ();

    do {

        key = getchar ();
        while (key == '\n' || key == '\r')
            key = getchar();
        printf ("\n");

        switch (key)
        {
            case 'h':
                CLEAR();
                sample_accm_usage ();
                break;
            case '0':
                sample_set_ccm_manual(ctx);
                printf("Set CCM MANUAL Mode\n\n");
                break;
            case '1':
                sample_set_ccm_auto(ctx);
                printf("Set CCM AUTO Mode\n\n");
                break;
            case '2':
                sample_get_ccm_mode(ctx);
                break;
            case '3':
                sample_set_ccm_manual_matrix(ctx);
                printf("Set CCM Manual Matrix\n\n");
                break;
            case '4':
                sample_get_ccm_manual_matrix(ctx);
                break;
            case '5':
                sample_get_accm_sat(ctx);
                break;
            case '6':
                sample_get_accm_matrix_name(ctx);
                break;
            case 'a':
                sample_ccm_setCcmAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
                sample_ccm_getCcmAttr(ctx);
                break;
            case 'b':
                sample_ccm_setCcmAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
                sample_ccm_getCcmAttr(ctx);
                usleep(40*1000);
                sample_ccm_getCcmAttr(ctx);
                break;
            case 'c':
                sample_ccm_setModeManual(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
                sample_ccm_getMode(ctx);
                break;
            case 'd':
                sample_ccm_setModeManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
                sample_ccm_getMode(ctx);
                usleep(40*1000);
                sample_ccm_getMode(ctx);
                break;
            case 'e':
                sample_ccm_setModeAuto(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
                sample_ccm_getMode(ctx);
                break;
            case 'f':
                sample_ccm_setModeAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
                sample_ccm_getMode(ctx);
                usleep(40*1000);
                sample_ccm_getMode(ctx);
                break;
            case 'g':
                sample_ccm_setMCcm(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
                sample_ccm_getCcmAttr(ctx);
                break;
            case 'i':
                sample_ccm_setMCcm(ctx, RK_AIQ_UAPI_MODE_ASYNC);
                sample_ccm_getCcmAttr(ctx);
                usleep(40*1000);
                sample_ccm_getCcmAttr(ctx);
                break;
            case 'j':
                sample_ccm_setACcm(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
                sample_ccm_getCcmAttr(ctx);
                break;
            case 'k':
                sample_ccm_setACcm(ctx, RK_AIQ_UAPI_MODE_ASYNC);
                sample_ccm_getCcmAttr(ctx);
                usleep(40*1000);
                sample_ccm_getCcmAttr(ctx);
                break;
            case 'l':
                sample_query_ccm_info(ctx);
                break;
            default:
                break;
        }
    } while (key != 'q' && key != 'Q');

    return XCAM_RETURN_NO_ERROR;
}