// Module:  Log4CPLUS

// File:    timehelper.cxx

// Created: 4/2003

// Author:  Tad E. Smith

//

//

// Copyright 2003-2017 Tad E. Smith

//

// 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 <log4cplus/helpers/timehelper.h>

#include <log4cplus/helpers/loglog.h>

#include <log4cplus/streams.h>

#include <log4cplus/helpers/stringhelper.h>

#include <log4cplus/internal/internal.h>

#include <algorithm>

#include <vector>

#include <iomanip>

#include <cassert>

#include <cerrno>

#if defined (UNICODE)

#include <cwchar>

#endif

#if defined (LOG4CPLUS_HAVE_SYS_TYPES_H)

#include <sys/types.h>

#endif

#if defined(LOG4CPLUS_HAVE_SYS_TIME_H)

#include <sys/time.h>

#endif

#if defined (LOG4CPLUS_HAVE_SYS_TIMEB_H)

#include <sys/timeb.h>

#endif

#if defined(LOG4CPLUS_HAVE_GMTIME_R) && !defined(LOG4CPLUS_SINGLE_THREADED)

#define LOG4CPLUS_NEED_GMTIME_R

#endif

#if defined(LOG4CPLUS_HAVE_LOCALTIME_R) && !defined(LOG4CPLUS_SINGLE_THREADED)

#define LOG4CPLUS_NEED_LOCALTIME_R

#endif

#include <log4cplus/config/windowsh-inc.h>

namespace log4cplus { namespace helpers {

const int ONE_SEC_IN_USEC = 1000000;

using std::mktime;

using std::gmtime;

using std::localtime;

#if defined (UNICODE)

using std::wcsftime;

#else

using std::strftime;

#endif

Time

from_struct_tm (tm * t)

{

    time_t time = helpers::mktime(t);

    if (LOG4CPLUS_LIKELY (time != -1))

        return from_time_t (time);

    else

    {

        int eno = errno;

        throw std::system_error (eno, std::system_category (),

            "from_struct_tm(): mktime() failed");

    }

}

void

gmTime (tm* t, Time const & the_time)

{

    time_t clock = to_time_t (the_time);

#if defined (LOG4CPLUS_HAVE_GMTIME_S) && defined (_MSC_VER)

    errno_t eno;

    if (LOG4CPLUS_UNLIKELY ((eno = gmtime_s (t, &clock)) != 0))

        throw std::system_error (eno, std::system_category (),

            "gmTime(): gmtime_s() failed");

#elif defined (LOG4CPLUS_HAVE_GMTIME_S) && defined (__BORLANDC__)

    gmtime_s (&clock, t);

#elif defined (LOG4CPLUS_NEED_GMTIME_R)

    gmtime_r (&clock, t);

#else

    tm* tmp = helpers::gmtime(&clock);

    *t = *tmp;

#endif

}

void

localTime (tm* t, Time const & the_time)

{

    time_t clock = to_time_t (the_time);

#ifdef LOG4CPLUS_NEED_LOCALTIME_R

    ::localtime_r(&clock, t);

#elif defined (LOG4CPLUS_HAVE_LOCALTIME_S)

    errno_t eno;

    if (LOG4CPLUS_UNLIKELY ((eno = localtime_s (t, &clock)) != 0))

        throw std::system_error (eno, std::system_category (),

            "localTime(): localtime_s() failed");

#else

    tm* tmp = helpers::localtime(&clock);

    *t = *tmp;

#endif

}

namespace

{

static log4cplus::tstring const padding_zeros[4] =

{

    { LOG4CPLUS_TEXT("000") },

    { LOG4CPLUS_TEXT("00") },

    { LOG4CPLUS_TEXT("0") },

    { }

};

static log4cplus::tstring const uc_q_padding_zeros[4] =

{

    { LOG4CPLUS_TEXT(".000") },

    { LOG4CPLUS_TEXT(".00") },

    { LOG4CPLUS_TEXT(".0") },

    { LOG4CPLUS_TEXT(".") }

};

static

void

build_q_value (log4cplus::tstring & q_str, long tv_usec)

{

    convertIntegerToString(q_str, tv_usec / 1000);

    std::size_t const len = q_str.length();

    if (len <= 2)

        q_str.insert (0, padding_zeros[q_str.length()]);

}

static

void

build_uc_q_value (log4cplus::tstring & uc_q_str, long tv_usec,

    log4cplus::tstring & tmp)

{

    build_q_value (uc_q_str, tv_usec);

    convertIntegerToString(tmp, tv_usec % 1000);

    std::size_t const usecs_len = tmp.length();

    tmp.insert (0, usecs_len <= 3

        ? uc_q_padding_zeros[usecs_len] : uc_q_padding_zeros[3]);

    uc_q_str.append (tmp);

}

} // namespace

log4cplus::tstring

getFormattedTime(const log4cplus::tstring& fmt_orig,

    Time const & the_time, bool use_gmtime)

{

    if (fmt_orig.empty () || fmt_orig[0] == 0)

        return log4cplus::tstring ();

    tm time;

    if (use_gmtime)

        gmTime (&time, the_time);

    else

        localTime (&time, the_time);

    enum State

    {

        TEXT,

        PERCENT_SIGN

    };

    internal::gft_scratch_pad & gft_sp = internal::get_gft_scratch_pad ();

    gft_sp.reset ();

    std::size_t const fmt_orig_size = gft_sp.fmt.size ();

    gft_sp.ret.reserve (fmt_orig_size + fmt_orig_size / 3);

    State state = TEXT;

    // Walk the format string and process all occurences of %q, %Q and %s.

    long const tv_usec = microseconds_part (the_time);

    time_t const tv_sec = to_time_t (the_time);

    for (auto fmt_ch : fmt_orig)

    {

        switch (state)

        {

        case TEXT:

        {

            if (fmt_ch == LOG4CPLUS_TEXT ('%'))

                state = PERCENT_SIGN;

            else

                gft_sp.ret.push_back (fmt_ch);

        }

        break;

        case PERCENT_SIGN:

        {

            switch (fmt_ch)

            {

            case LOG4CPLUS_TEXT ('q'):

            {

                if (! gft_sp.q_str_valid)

                {

                    build_q_value (gft_sp.q_str, tv_usec);

                    gft_sp.q_str_valid = true;

                }

                gft_sp.ret.append (gft_sp.q_str);

                state = TEXT;

            }

            break;

            case LOG4CPLUS_TEXT ('Q'):

            {

                if (! gft_sp.uc_q_str_valid)

                {

                    build_uc_q_value (gft_sp.uc_q_str, tv_usec, gft_sp.tmp);

                    gft_sp.uc_q_str_valid = true;

                }

                gft_sp.ret.append (gft_sp.uc_q_str);

                state = TEXT;

            }

            break;

            // Windows do not support %s format specifier

            // (seconds since epoch).

            case LOG4CPLUS_TEXT ('s'):

            {

                if (! gft_sp.s_str_valid)

                {

                    convertIntegerToString (gft_sp.s_str, tv_sec);

                    gft_sp.s_str_valid = true;

                }

                gft_sp.ret.append (gft_sp.s_str);

                state = TEXT;

            }

            break;

            default:

            {

                gft_sp.ret.push_back (LOG4CPLUS_TEXT ('%'));

                gft_sp.ret.push_back (fmt_ch);

                state = TEXT;

            }

            }

        }

        break;

        }

    }

    // Finally call strftime/wcsftime to format the rest of the string.

    gft_sp.fmt.swap (gft_sp.ret);

    std::size_t buffer_size = gft_sp.fmt.size () + 1;

    std::size_t len;

    // Limit how far can the buffer grow. This is necessary so that we

    // catch bad format string. Some implementations of strftime() signal

    // both too small buffer and invalid format string by returning 0

    // without changing errno.

    std::size_t const buffer_size_max

        = (std::max) (static_cast<std::size_t>(1024), buffer_size * 16);

    buffer_size = (std::max) (buffer_size, gft_sp.buffer.capacity());

    do

    {

        gft_sp.buffer.resize (buffer_size);

        errno = 0;

#ifdef UNICODE

        len = helpers::wcsftime(&gft_sp.buffer[0], buffer_size,

            gft_sp.fmt.c_str(), &time);

#else

        len = helpers::strftime(&gft_sp.buffer[0], buffer_size,

            gft_sp.fmt.c_str(), &time);

#endif

        if (len == 0)

        {

            int const eno = errno;

            buffer_size *= 2;

            if (buffer_size > buffer_size_max)

            {

                LogLog::getLogLog ()->error (

                    LOG4CPLUS_TEXT("Error in strftime(): ")

                    + convertIntegerToString (eno), true);

            }

        }

    }

    while (len == 0);

    return tstring (gft_sp.buffer.begin (), gft_sp.buffer.begin () + len);

}

} } // namespace log4cplus { namespace helpers {