/*!
 * COPYRIGHT (C) 2010-2020 Emeric Grange - All Rights Reserved
 *
 * This file is part of MiniTraces.
 *
 * MiniTraces is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * MiniTraces is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with MiniTraces.  If not, see <http://www.gnu.org/licenses/>.
 *
 * \file      minitraces.cpp
 * \author    Emeric Grange <emeric.grange@gmail.com>
 * \date      2018
 * \version   0.53
 */

// MiniTraces header
#include "minitraces.h"

// C standard libraries
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#if defined(_WIN16) || defined(_WIN32) || defined(_WIN64)
#define MINITRACES_EOL "\n\r"
#else // linux, macOS, and everyone else...
#define MINITRACES_EOL "\n"
#endif

/* ************************************************************************** */
/* ************************************************************************** */

#if MINITRACES_TIMESTAMPS

#include <time.h>

#ifdef defined(__APPLE__) || defined(__MACH__)
#include <mach/clock.h>
#include <mach/mach.h>
#endif

/*!
 * \brief Print trace tick with millisecond precision.
 *
 * \note If CLOCK_MONOTONIC_RAW is not available on your system, you can fallback
 * to CLOCK_MONOTONIC or even CLOCK_REALTIME.
 */
static void print_trace_tick(void)
{
    long long int time = 0;

#if defined(__APPLE__) || defined(__MACH__) // OS X does not have clock_gettime > use clock_get_time

    clock_serv_t cclock;
    mach_timespec_t mts;
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    if (clock_get_time(cclock, &mts));
    {
        time = (mts.tv_sec * 1000) + (mts.tv_nsec / 1000000);
    }
    mach_port_deallocate(mach_task_self(), cclock);

#else

    struct timespec ts;
    if (clock_gettime(CLOCK_REALTIME, &ts) == 0)
    {
        time = (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);
    }

#endif

    printf("[%lld]", time);
}

/*!
 * \brief Print trace time with hh:mm:ss format, with second precision.
 */
static void print_trace_time(void)
{
    time_t t = time(NULL);
    struct tm result;
    struct tm *tm_info = localtime_r(&t, &result);

    if (tm_info != NULL)
    {
        char buffer[12];
        strftime(buffer, 12, "%H:%M:%S", tm_info);
        printf("[%s]", buffer);
    }
    else
    {
        printf("[0]");
    }
}

#endif // MINITRACES_TIMESTAMPS

/* ************************************************************************** */

/*!
 * \brief This function displays trace level enabled for a particular module.
 */
static void print_trace_levels(const unsigned level)
{
    printf("%s%s%s%s%s%s", (level & TRACE_LEVEL_ERR)  ? "ERR":"",
                           (level & TRACE_LEVEL_WARN) ? " | WARN":"",
                           (level & TRACE_LEVEL_INFO) ? " | INFO":"",
                           (level & TRACE_LEVEL_1)    ? " | LVL 1":"",
                           (level & TRACE_LEVEL_2)    ? " | LVL 2":"",
                           (level & TRACE_LEVEL_3)    ? " | LVL 3":"");
    printf("\n");
}

/* ************************************************************************** */

/*!
 * Gives out a 1 letter description of the trace level.
 */
static const char *get_trace_level_string(unsigned level)
{
    const char *string = "U";

    switch (level)
    {
        case TRACE_LEVEL_ERR:   string = BLD_RED    "E" CLR_RESET; break;
        case TRACE_LEVEL_WARN:  string = BLD_YELLOW "W" CLR_RESET; break;
        case TRACE_LEVEL_INFO:  string = BLD_GREEN  "I" CLR_RESET; break;
        case TRACE_LEVEL_1:     string = BLD_WHITE  "1" CLR_RESET; break;
        case TRACE_LEVEL_2:     string = BLD_WHITE  "2" CLR_RESET; break;
        case TRACE_LEVEL_3:     string = BLD_WHITE  "3" CLR_RESET; break;

        default: break;
    }

    return string;
}

/* ************************************************************************** */

//! Count all of the user-defined trace modules
static const unsigned int trace_module_count = sizeof(trace_modules_table) / sizeof(TraceModule_t);

/* ************************************************************************** */
/* ************************************************************************** */

void MiniTraces_info(void)
{
    printf(PID BLD_GREEN "\nMiniTraces_infos()" CLR_RESET " version 0.4\n");

    printf(PID "\n* TRACE LEVELS ENABLED:\n");
    TRACE_ERROR(MAIN, "ERROR traces enabled");
    TRACE_WARNING(MAIN, "WARNING traces enabled");
    TRACE_INFO(MAIN, "INFO traces enabled");
    TRACE_1(MAIN, "LVL 1 traces enabled");
    TRACE_2(MAIN, "LVL 2 traces enabled");
    TRACE_3(MAIN, "LVL 3 traces enabled");

    printf(PID "\n* TRACE MODULES CONFIGURATION:\n");
    for (unsigned i = 0; i < trace_module_count; i++)
    {
        printf(PID "[%02x][%5s] Trace Mask 0x%X: ", i,
               trace_modules_table[i].module_name,
               trace_modules_table[i].module_output_mask);

        print_trace_levels(trace_modules_table[i].module_output_mask);
    }
}

/* ************************************************************************** */

void MiniTraces_print(const char *file, const int line, const char *func,
                      const unsigned level, const unsigned module, const char *payload, ...)
{
#if MINITRACES_LEVEL > 0
    if (module > trace_module_count)
    {
        printf("[TRACE][%s] module[%d] unknown\n", __FUNCTION__, (int)module);
        return;
    }
#endif

    if ((trace_modules_table[module].module_output_mask & level) == level)
    {
        // Trace program identifier
        ////////////////////////////////////////////////////////////////////////

        printf("%s", PID);

        // Trace header
        ////////////////////////////////////////////////////////////////////////

        // Print the trace timestamp
#if MINITRACES_TIMESTAMPS == 1
        print_trace_tick();
#elif MINITRACES_TIMESTAMPS == 2
        print_trace_time();
#endif

        // Print trace module_name, 5 chars, left padded
        const char *level_string = get_trace_level_string(level);
        printf("[%s][%5s]", level_string, trace_modules_table[module].module_name);

#if MINITRACES_FUNC_INFO
        // Print the function where the trace came from
        printf(BLD_WHITE "[%s]" CLR_RESET, func);
#endif

#if MINITRACES_FILE_INFO
        // Print the line of code that triggered the trace output
        const char *tmp = strrchr(file, '/');
        printf("{%s:%d}", tmp ? ++tmp : file, line);
#endif

        // Trace body
        ////////////////////////////////////////////////////////////////////////

        // Customizable header / body separator
        printf(" ");

        va_list args;
        va_start(args, payload);
        vprintf(payload, args);
        va_end(args);

        // End of the line
        printf(MINITRACES_EOL);

#if MINITRACES_FORCED_SYNC
        // Force terminal synchronisazion (very slow!)
        fflush(stdout);
#endif
    }
}

/* ************************************************************************** */

void MiniTraces_flush()
{
    // Force terminal synchronisazion (very slow!)
    fflush(stdout);
}

/* ************************************************************************** */