// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "utils.h"

#include <getopt.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>

#include <algorithm>
#include <sstream>

#ifdef RKMEDIA_SUPPORT_MINILOG
    #include "minilogger/log.h"
#endif

enum
{
    LOG_LEVEL_INFO,
    LOG_LEVEL_DBG,
};

enum
{
    LOG_METHOD_MINILOG,
    LOG_METHOD_PRINT
};

static int rkmedia_log_method = LOG_METHOD_PRINT;
static int rkmedia_log_level = LOG_LEVEL_INFO;

_API void LOG_INIT()
{
    char* ptr = NULL;

    rkmedia_log_method = LOG_METHOD_PRINT;
#ifdef RKMEDIA_SUPPORT_MINILOG
    ptr = getenv("RKMEDIA_LOG_METHOD");
    if (ptr && strstr(ptr, "MINILOG")) {
        fprintf(stderr, "##RKMEDIA Method: MINILOG\n");
        __minilog_log_init("RKMEDIA", NULL, false, false, "RKMEDIA", "0.1");
        rkmedia_log_method = LOG_METHOD_MINILOG;
    } else {
        fprintf(stderr, "##RKMEDIA Method: PRINT\n");
        rkmedia_log_method = LOG_METHOD_PRINT;
    }
#endif //#ifdef RKMEDIA_SUPPORT_MINILOG

    ptr = getenv("RKMEDIA_LOG_LEVEL");
    if (ptr && strstr(ptr, "DBG")) {
        fprintf(stderr, "##RKMEDIA Log level: DBG\n");
        rkmedia_log_level = LOG_LEVEL_DBG;
    } else {
        fprintf(stderr, "##RKMEDIA Log level: INFO\n");
        rkmedia_log_level = LOG_LEVEL_INFO;
    }
}

static void LogPrintf(const char* prefix, const char* fmt, va_list vl)
{
    char line[1024];
    if (rkmedia_log_level >= LOG_LEVEL_DBG) {
#ifdef RKMEDIA_SUPPORT_MINILOG
        if (rkmedia_log_method == LOG_METHOD_PRINT) {
#endif
            fprintf(stderr, "%s", (char*)prefix);
            vsnprintf(line, sizeof(line), fmt, vl);
            fprintf(stderr, "%s", line);
#ifdef RKMEDIA_SUPPORT_MINILOG
        } else {
            // minilog_debug("%s", (char *)prefix);
            vsnprintf(line, sizeof(line), fmt, vl);
            minilog_debug("%s%s", (char*)prefix, line);
        }
#endif
    }
}

void LOGD(const char* format, ...)
{
    va_list vl;
    va_start(vl, format);
    LogPrintf("Debug - ", format, vl);
    va_end(vl);
}

void LOG(const char* format, ...)
{
    do {
        va_list vl;
        va_start(vl, format);
        char line[1024];
        vsnprintf(line, sizeof(line), format, vl);
#ifdef RKMEDIA_SUPPORT_MINILOG
        if (rkmedia_log_method == LOG_METHOD_PRINT)
#endif
            fprintf(stderr, "%s", line);
#ifdef RKMEDIA_SUPPORT_MINILOG
        else {
            minilog_info("%s", line);
        }
#endif
        va_end(vl);
    } while (0);
}

namespace easymedia
{

    bool parse_media_param_map(const char* param, std::map<std::string, std::string>& map)
    {
        if (!param) {
            return false;
        }

        std::string token;
        std::istringstream tokenStream(param);
        while (std::getline(tokenStream, token)) {
            std::string key, value;
            std::istringstream subTokenStream(token);
            if (std::getline(subTokenStream, key, '=')) {
                std::getline(subTokenStream, value);
            }
            map[key] = value;
        }

        return true;
    }

    bool parse_media_param_list(const char* param, std::list<std::string>& list, const char delim)
    {
        if (!param) {
            return false;
        }

        std::string token;
        std::istringstream tokenStream(param);
        while (std::getline(tokenStream, token, delim)) {
            list.push_back(token);
        }

        return true;
    }

    int parse_media_param_match(const char* param, std::map<std::string, std::string>& map,
                                std::list<std::pair<const std::string, std::string&>>& list)
    {
        if (!easymedia::parse_media_param_map(param, map)) {
            return 0;
        }
        int match_num = 0;
        for (auto& key : list) {
            const std::string& req_key = key.first;
            for (auto& entry : map) {
                const std::string& entry_key = entry.first;
                if (req_key == entry_key) {
                    key.second = entry.second;
                    match_num++;
                    break;
                }
            }
        }

        return match_num;
    }

    bool has_intersection(const char* str, const char* expect, std::list<std::string>* expect_list)
    {
        std::list<std::string> request;
        // LOG("request: %s; expect: %s\n", str, expect);

        if (!expect || (strlen(expect) == 0)) {
            return true;
        }

        if (!parse_media_param_list(str, request, ',')) {
            return false;
        }
        if (expect_list->empty() && !parse_media_param_list(expect, *expect_list)) {
            return false;
        }
        for (auto& req : request) {
            if (std::find(expect_list->begin(), expect_list->end(), req) != expect_list->end()) {
                return true;
            }
        }
        return false;
    }

    std::string get_media_value_by_key(const char* param, const char* key)
    {
        std::map<std::string, std::string> param_map;
        if (!parse_media_param_map(param, param_map)) {
            return std::string();
        }
        return param_map[key];
    }

    bool string_start_withs(std::string const& fullString, std::string const& starting)
    {
        if (fullString.length() >= starting.length()) {
            return (0 == fullString.find(starting));
        } else {
            return false;
        }
    }

    bool string_end_withs(std::string const& fullString, std::string const& ending)
    {
        if (fullString.length() >= ending.length()) {
            return (0 == fullString.compare(fullString.length() - ending.length(), ending.length(), ending));
        } else {
            return false;
        }
    }

#ifndef NDEBUG

    #include <fcntl.h>
    #include <unistd.h>

    bool DumpToFile(std::string path, const char* ptr, size_t len)
    {
        int fd = open(path.c_str(), O_CREAT | O_WRONLY | O_FSYNC);
        if (fd < 0) {
            LOG("Fail to open %s\n", path.c_str());
            return false;
        }
        LOGD("dump to %s, size %d\n", path.c_str(), (int)len);
        write(fd, ptr, len);
        close(fd);
        return true;
    }

#endif // #ifndef NDEBUG

} // namespace easymedia