/*
**  L2 - OSSP Logging Library
**  Copyright (c) 2001 The OSSP Project (http://www.ossp.org/)
**  Copyright (c) 2001 Cable & Wireless Deutschland (http://www.cw.com/de/)
**
**  This file is part of OSSP L2, a flexible logging library which
**  can be found at http://www.ossp.org/pkg/l2/.
**
**  Permission to use, copy, modify, and distribute this software for
**  any purpose with or without fee is hereby granted, provided that
**  the above copyright notice and this permission notice appear in all
**  copies.
**
**  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
**  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
**  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
**  IN NO EVENT SHALL THE AUTHORS AND COPYRIGHT HOLDERS AND THEIR
**  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
**  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
**  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
**  USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
**  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
**  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
**  OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
**  SUCH DAMAGE.
**
**  l2_env.c: environment object
*/

#include "l2_p.h"

/* create environment object */
l2_result_t l2_env_create(l2_env_t **envp)
{
    l2_env_t *env;
    int i;

    /* argument sanity check */
    if (envp == NULL)
        return L2_ERR_ARG;
    
    /* allocate environment structure */ 
    if ((env = (l2_env_t *)malloc(sizeof(l2_env_t))) == NULL)
        return L2_ERR_SYS;

    /* initialize environment structure */
    env->rvErrorInfo = L2_OK;
    env->szErrorInfo[0] = '\0';
    env->szError[0] = '\0';
    env->levelmask = L2_LEVEL_ALL;
    env->flushmask = L2_LEVEL_NONE;
    for (i = 0; i < L2_MAX_FORMATTERS; i++)
        env->formatters[i].cb = NULL;

    /* pass new object to caller */
    (*envp) = env;

    return L2_OK;
}


/* destroy environment object */
l2_result_t l2_env_destroy(l2_env_t *env)
{
    /* argument sanity check */
    if (env == NULL)
        return L2_ERR_ARG;

    /* free env structure */
    free(env);

    return L2_OK;
}

/* set environment level masks */
l2_result_t l2_env_levels(l2_env_t *env, unsigned int levelmask, unsigned int flushmask)
{
    /* argument sanity check */
    if (env == NULL)
        return L2_ERR_ARG;

    /* override global level mask */
    env->levelmask = levelmask;
    env->flushmask = flushmask;

    return L2_OK;
}

/* attach formatter to environment */
l2_result_t l2_env_formatter(l2_env_t *env, char id, l2_formatter_t cb, l2_context_t *ctx)
{
    int i;

    /* argument sanity check */
    if (env == NULL || id == '\0' || cb == NULL)
        return L2_ERR_ARG;

    /* find next free formatter position in formatter array */
    for (i = 0; i < L2_MAX_FORMATTERS && env->formatters[i].cb != NULL; i++)
        ;
    if (i == L2_MAX_FORMATTERS)
        return L2_ERR_MEM;

    /* attach formatter to env */
    env->formatters[i].id  = id;
    env->formatters[i].ctx = ctx;
    env->formatters[i].cb  = cb;

    return L2_OK;
}

/* remember additional error information */
l2_result_t l2_env_errorinfo(l2_env_t *env, l2_result_t rv, const char *fmt, ...)
{
    va_list ap;

    /* argument sanity check */
    if (env == NULL || rv == L2_OK || fmt == NULL)
        return L2_ERR_ARG;

    /* remember error information */
    va_start(ap, fmt);
    l2_util_vsprintf(env->szErrorInfo, sizeof(env->szErrorInfo), fmt, ap);
    env->rvErrorInfo = rv;
    va_end(ap);

    return L2_OK;
}

/* retrieve string description of error result code */
char *l2_env_strerror(l2_env_t *env, l2_result_t rv)
{
    char *sz;
    char *cpBuf;
    int nBuf;
    int n;

    /* argument sanity check */
    if (env == NULL)
        return NULL;

    /* start at begin of buffer */
    cpBuf = env->szError;
    nBuf  = sizeof(env->szError);

    /* translate result value into corresponding string */
    if      (rv == L2_OK)      sz = "everything ok";
    else if (rv == L2_ERR_ARG) sz = "invalid argument";
    else if (rv == L2_ERR_USE) sz = "invalid use";
    else if (rv == L2_ERR_MEM) sz = "no more memory available";
    else if (rv == L2_ERR_SYS) sz = "operating system error";
    else if (rv == L2_ERR_IO)  sz = "input/output error";
    else if (rv == L2_ERR_FMT) sz = "formatting error";
    else if (rv == L2_ERR_INT) sz = "internal error";
    else                       sz = "unknown error";
    n = l2_util_sprintf(cpBuf, nBuf, "%s", sz);
    cpBuf += n;
    nBuf  -= n;

    /* optionally annotate with error information */
    if (rv == env->rvErrorInfo && env->szErrorInfo[0] != '\0') {
        n = l2_util_sprintf(cpBuf, nBuf, "; %s", env->szErrorInfo);
        cpBuf += n;
        nBuf  -= n;
    }

    /* optionally annotate with operating system error information */
    if (rv == L2_ERR_SYS) {
        n = l2_util_sprintf(cpBuf, nBuf, "; %s (%d)", strerror(errno), errno);
        cpBuf += n;
        nBuf  -= n;
    }

    /* return pointer to internal buffer */
    return env->szError;
}