/*
 * xcam_log.cpp - xcam log
 *
 *  Copyright (c) 2014-2015 Intel Corporation
 *  Copyright (c) 2019, Fuzhou Rockchip Electronics Co., Ltd
 *
 * 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 <base/xcam_log.h>
#include <base/xcam_defs.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/time.h>
#ifdef ANDROID_OS
#include <cutils/properties.h>
#ifdef ALOGV
#undef ALOGV
#define ALOGV(...) ((void)ALOG(LOG_VERBOSE, LOG_TAG, __VA_ARGS__))
#endif
#endif

static char log_file_name[XCAM_MAX_STR_SIZE] = {0};
/* use a 64 bits value to represent all modules bug level, and the
 * module bit maps is as follow:
 *
 * bit:      11-4          3-0
 * meaning: [sub modules] [level]
 *
 * bit:      21        20       19      18       17     16     15        14     13       12
 * meaning: [ADEBAYER][AGIC]   [ALSC]   [ANR]  [ATMO] [ADPCC]  [ABLC]    [AF]   [AWB]   [AEC]
 *
 * bit:      31        30       29      28       27     26     25        24     23       22
 * meaning: [ASHARP]  [AIE]    [ACP]    [AR2Y] [ALDCH][A3DLUT] [ADEHAZE] [AWDR] [AGAMMA][ACCM]
 *
 * bit:     [63-39]          40     39      38       37     36     35        34     33       32
 * meaning:  [U]              [AMERGE]  [ADEGAMMA ]   [CAMHW]  [ANALYZER][XCORE][ASD]  [AFEC] [ACGC]  [AORB]
 *
 * [U] means unused now.
 * [level]: use 4 bits to define log levels.
 *     each module log has following ascending levels:
 *          0: error
 *          1: warning
 *          2: info
 *          3: debug
 *          4: verbose
 *          5: low1
 *          6-7: unused, now the same as debug
 * [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.
 * [modules]: AEC, AWB, AF ...
 *
 * set debug level example:
 * eg. set module af log level to debug, and enable all sub modules of af:
 *    Android:
 *      setprop persist.vendor.rkisp.log 0x4ff4
 *    Linux:
 *      export persist_camera_engine_log=0x4ff4
 *    And if only want enable the sub module 1 log of af:
 *    Android:
 *      setprop persist.vendor.rkisp.log 0x4014
 *    Linux:
 *      export persist_camera_engine_log=0x4014
 */
static unsigned long long g_cam_engine_log_level = 0xff0;

#if 0
typedef struct xcore_cam_log_module_info_s {
    const char* module_name;
    int log_level;
    int sub_modules;
} xcore_cam_log_module_info_t;
#endif

xcore_cam_log_module_info_t g_xcore_log_infos[XCORE_LOG_MODULE_MAX] = {
    { "AEC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AEC
    { "AWB", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AWB
    { "AF", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AF
    { "ABLC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ABLC
    { "ADPCC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ADPCC
    { "ATMO", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ATMO
    { "ANR", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ANR
    { "ALSC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ALSC
    { "AGIC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AGIC
    { "ADEBAYER", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ADEBAYER
    { "ACCM", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ACCM
    { "AGAMMA", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AGAMMA
    { "AWDR", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AWDR
    { "ADEHAZE", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ADEHAZE
    { "A3DLUT", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_A3DLUT
    { "ALDCH", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ALDCH
    { "AR2Y", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AR2Y
    { "ACP", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ACP
    { "AIE", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AIE
    { "ASHARP", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ASHARP
    { "AORB", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AORB
    { "AFEC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AFEC
    { "ACGC", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ACGC
    { "ASD", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ASD
    { "XCORE", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_XCORE
    { "ANALYZER", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ANALYZER
    { "CAMHW", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_CAMHW
    { "ADEGAMMA", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_ADEGAMMA
    { "AMERGE", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AMERGE
    { "AMD", XCORE_LOG_LEVEL_ERR, 0xff}, // XCORE_LOG_MODULE_AMMD
};

bool xcam_get_enviroment_value(const char* variable, unsigned long long* value)
{
    if (!variable || !value) {
        return false;

    }

    char* valueStr = getenv(variable);
    if (valueStr) {
        *value = strtoull(valueStr, nullptr, 16);

        return true;
    }
    return false;
}

void xcam_get_runtime_log_level() {
    const char* file_name = "/tmp/.rkaiq_log";

    if (!access(file_name, F_OK)) {
        FILE *fp = fopen(file_name, "r");
        char level[64] = {'\0'};

        if (!fp)
            return;

        fseek(fp, 0, SEEK_SET);
        if (fp && fread(level, 1, sizeof (level), fp) > 0) {
            for (int i = 0; i < XCORE_LOG_MODULE_MAX; i++) {
                g_xcore_log_infos[i].log_level = 0;
                g_xcore_log_infos[i].sub_modules = 0;
            }
            g_cam_engine_log_level = strtoull(level, nullptr, 16);
            unsigned long long module_mask = g_cam_engine_log_level >> 12;
            for (int i = 0; i < XCORE_LOG_MODULE_MAX; i++) {
                if (module_mask & (1 << i)) {
                    g_xcore_log_infos[i].log_level = g_cam_engine_log_level & 0xf;
                    g_xcore_log_infos[i].sub_modules = (g_cam_engine_log_level >> 4) & 0xff;
                }
            }
        }

        fclose (fp);
    }
}

int xcam_get_log_level() {
#ifdef ANDROID_OS
    char property_value[PROPERTY_VALUE_MAX] = {0};

    property_get("persist.vendor.rkisp.log", property_value, "0");
    g_cam_engine_log_level = strtoull(property_value, nullptr, 16);

#else
    xcam_get_enviroment_value("persist_camera_engine_log",
                              &g_cam_engine_log_level);
#endif
    unsigned long long module_mask = g_cam_engine_log_level >> 12;

    for (int i = 0; i < XCORE_LOG_MODULE_MAX; i++) {
        if (module_mask & (1 << i)) {
            g_xcore_log_infos[i].log_level = g_cam_engine_log_level & 0xf;
            g_xcore_log_infos[i].sub_modules = (g_cam_engine_log_level >> 4) & 0xff;
        }
    }

    return 0;
}

char* timeString() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    struct tm * timeinfo = localtime(&tv.tv_sec);
    static char timeStr[64];
    sprintf(timeStr, "%.2d:%.2d:%.2d.%.6ld", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, tv.tv_usec);
    return timeStr;
}

void xcam_print_log (int module, int sub_modules, int level, const char* format, ...) {
    char buffer[XCAM_MAX_STR_SIZE] = {0};
    va_list va_list;
    va_start (va_list, format);
    vsnprintf (buffer, XCAM_MAX_STR_SIZE, format, va_list);
    va_end (va_list);

    if (strlen (log_file_name) > 0) {
        FILE* p_file = fopen (log_file_name, "ab+");
        if (NULL != p_file) {
            fwrite (buffer, sizeof (buffer[0]), strlen (buffer), p_file);
            fclose (p_file);
        } else {
            printf("error! can't open log file !\n");
        }
        return ;
    }
#ifdef ANDROID_OS
    switch(level) {
    case XCORE_LOG_LEVEL_ERR:
        ALOGE("[%s]:%s", g_xcore_log_infos[module].module_name, buffer);
        break;
    case XCORE_LOG_LEVEL_WARNING:
        ALOGW("[%s]:%s", g_xcore_log_infos[module].module_name, buffer);
        break;
    case XCORE_LOG_LEVEL_INFO:
        ALOGI("[%s]:%s", g_xcore_log_infos[module].module_name, buffer);
        break;
    case XCORE_LOG_LEVEL_VERBOSE:
        ALOGV("[%s]:%s", g_xcore_log_infos[module].module_name, buffer);
        break;
    case XCORE_LOG_LEVEL_DEBUG:
    default:
        ALOGD("[%s]:%s", g_xcore_log_infos[module].module_name, buffer);
        break;
    }
#else
    printf ("[%s][%s]:%s", timeString(), g_xcore_log_infos[module].module_name, buffer);
#endif
}

void xcam_set_log (const char* file_name) {
    if (NULL != file_name) {
        memset (log_file_name, 0, XCAM_MAX_STR_SIZE);
        strncpy (log_file_name, file_name, XCAM_MAX_STR_SIZE);
    }
}
void xcam_get_awb_log_level(unsigned char *log_level, unsigned char *sub_modules)
{
    //xcam_get_log_level();
    *log_level = g_xcore_log_infos[XCORE_LOG_MODULE_AWB].log_level;
    *sub_modules = g_xcore_log_infos[XCORE_LOG_MODULE_AWB].sub_modules;
}