/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*  Monkey HTTP Server
 *  ==================
 *  Copyright 2001-2017 Eduardo Silva <eduardo@monkey.io>
 *
 *  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 <stdio.h>
#include <stdlib.h>
#include <time.h>

#include <mk_core/mk_pthread.h>
#include <mk_core/mk_unistd.h>

#include <monkey/mk_core.h>
#include <monkey/mk_config.h>
#include <monkey/mk_clock.h>
#include <monkey/mk_utils.h>
#include <monkey/mk_tls.h>

#ifdef _WIN32
static struct tm* localtime_r(const time_t* timep, struct tm* result)
{
    localtime_s(result, timep);

    return result;
}

static struct tm* gmtime_r(const time_t* timep, struct tm* result)
{
    gmtime_s(result, timep);

    return result;
}
#endif


/*
 * The mk_ptr_ts have two buffers for avoid in half-way access from
 * another thread while a buffer is being modified. The function below returns
 * one of two buffers to work with.
 */
static inline char *_next_buffer(mk_ptr_t *pointer, char **buffers)
{
    if (pointer->data == buffers[0]) {
        return buffers[1];
    }
    else {
        return buffers[0];
    }
}

static void mk_clock_log_set_time(time_t utime, struct mk_server *server)
{
    char *time_string;
    struct tm result;

    time_string = _next_buffer(&server->clock_context->log_current_time, server->clock_context->log_time_buffers);
    server->clock_context->log_current_utime = utime;

    strftime(time_string, LOG_TIME_BUFFER_SIZE, "[%d/%b/%G %T %z]",
             localtime_r(&utime, &result));

    server->clock_context->log_current_time.data = time_string;
}

static void mk_clock_headers_preset(time_t utime, struct mk_server *server)
{
    int len1;
    int len2;
    struct tm *gmt_tm;
    struct tm result;
    char *buffer;

    buffer = _next_buffer(&server->clock_context->headers_preset,
                          server->clock_context->header_time_buffers);

    gmt_tm = gmtime_r(&utime, &result);

    len1 = snprintf(buffer,
                    HEADER_TIME_BUFFER_SIZE,
                    "%s",
                    server->server_signature_header);

    len2 = strftime(buffer + len1,
                    HEADER_PRESET_SIZE - len1,
                    MK_CLOCK_GMT_DATEFORMAT,
                    gmt_tm);

    server->clock_context->headers_preset.data = buffer;
    server->clock_context->headers_preset.len  = len1 + len2;
}

void *mk_clock_worker_init(void *data)
{
    time_t cur_time;
    struct mk_server *server = data;

    mk_utils_worker_rename("monkey: clock");
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

    server->clock_context->mk_clock_tid = pthread_self();

    while (1) {
        cur_time = time(NULL);

        if(cur_time != ((time_t)-1)) {
            mk_clock_log_set_time(cur_time, server);
            mk_clock_headers_preset(cur_time, server);
        }
        sleep(1);
    }

    return NULL;
}

void mk_clock_exit(struct mk_server *server)
{
    pthread_cancel(server->clock_context->mk_clock_tid);
    pthread_join(server->clock_context->mk_clock_tid, NULL);

    mk_mem_free(server->clock_context->header_time_buffers[0]);
    mk_mem_free(server->clock_context->header_time_buffers[1]);
    mk_mem_free(server->clock_context->log_time_buffers[0]);
    mk_mem_free(server->clock_context->log_time_buffers[1]);

    mk_mem_free(server->clock_context);
}

/* This function must be called before any threads are created */
void mk_clock_sequential_init(struct mk_server *server)
{
    server->clock_context = mk_mem_alloc_z(sizeof(struct mk_clock_context));

    if (server->clock_context == NULL) {
        return;
    }

    /* Time when monkey was started */
    server->clock_context->monkey_init_time = time(NULL);

    server->clock_context->log_current_time.len = LOG_TIME_BUFFER_SIZE - 2;
    server->clock_context->headers_preset.len = HEADER_PRESET_SIZE - 1;

    server->clock_context->header_time_buffers[0] = mk_mem_alloc_z(HEADER_PRESET_SIZE);
    server->clock_context->header_time_buffers[1] = mk_mem_alloc_z(HEADER_PRESET_SIZE);

    server->clock_context->log_time_buffers[0] = mk_mem_alloc_z(LOG_TIME_BUFFER_SIZE);
    server->clock_context->log_time_buffers[1] = mk_mem_alloc_z(LOG_TIME_BUFFER_SIZE);

    /* Set the time once */
    time_t cur_time = time(NULL);

    if (cur_time != ((time_t)-1)) {
        mk_clock_log_set_time(cur_time, server);
        mk_clock_headers_preset(cur_time, server);
    }
}