/*  OSSP rc - Run-command processor
**  Copyright (c) 2002 Ralf S. Engelschall
**  Copyright (c) 2002 Cable & Wireless Deutschland GmbH
**  Copyright (c) 2002 The OSSP Project <http://www.ossp.org/>
**
**  This file is part of OSSP rc, a portable Run-command processor
**  which can be found at http://www.ossp.org/pkg/lib/rc/
**
**  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.
**
**  rc_config.c: Run-command processor ISO C source file
*/

#include <stdlib.h>
#include <string.h>

#include "rc.h"
#include "rc_config.h"
#include "rc_const.h"               /* String constants                     */

static int m_nLocks = 0;            /* Server locks, not thread-safe FIXME  */


/***************************************
* configInfo(void)                     *
* Print the configuration information  *
***************************************/
rc_return_t configInfo(void)
{
    ex_t Except;
    int i = 0;
    char **pszTemp = NULL;  /* For holding the section string vector        */

    try {
        fprintf(stderr, "Run command file: %s\n", configGetrcfile());

        pszTemp = (char **)configGetsecs();
        fprintf(stderr, "Sections:");
        for (i = 0; pszTemp[i]; i++)
            fprintf(stderr, " %s", pszTemp[i]);
        fputc('\n', stderr);

        /* FIXME Not threadsafe, wrap with crit section */
        for (i = 0; i < RC_NUMOPTS; i++) {
            if (configGetval(i) == NULL); /* NOP */
            else if (!(strcmp(configGetval(i), "1")))
                fprintf(stderr, "Option %s is on.\n", configGetname(i));
            else
                fprintf(stderr, "Option %s is %s.\n", configGetname(i),\
                    configGetval(i));
        }
    }

    catch(Except) {
        rethrow;
    }

    return(RC_THROW(RC_OK));
}

/***************************************
* configNew(void)                      *
* Construct a configuration            *
***************************************/
rc_return_t configNew(void)
{
    ex_t Except;

    if (m_nLocks == 0) {                    /* If we don't have one yet */
        try {                               /* then construct a new one */
            clioptNew();                    /* Member cliopt instance   */
        }
        catch(Except) {
            rethrow;
        }
    }
    m_nLocks++;                             /* FIXME not threadsafe     */

    return(RC_THROW(RC_OK));
}

/***************************************
* configGetXXX(rc_opt_t)               *
* Configuration accessors              *
***************************************/
const char *configGetval(rc_opt_t Optname)
{
    ex_t Except;
    char *szTemp = NULL;

    if (m_nLocks) {                         /* Make sure config exists      */
        try {
            if ((szTemp = (char *)clioptGetval(Optname)))
                return((const char *)szTemp);
/*            else if (szTemp = envoptGetval(Optname))
                return((const char *)szTemp);
            else if (szTemp = cnfoptGetval(Optname))
                return((const char *)szTemp);*/
            else
                return(NULL);               /* Special case when not found  */
        }
        catch(Except) {
            rethrow;
        }
    }
    else {
        RC_THROW(RC_ERR_USE);
    }
    return(NULL);   /* Not reached  */
}

const char *configGetname(rc_opt_t Optname)
{
    static char *s_szOptnametab[] = { /* NULL is for alignment */
        NULL,        RC_USE_NAME, RC_DBG_NAME, RC_VER_NAME,
        RC_EVL_NAME, RC_HLP_NAME, RC_INF_NAME, RC_LBL_NAME,
        RC_PRN_NAME, RC_SIL_NAME, RC_RAW_NAME, RC_VRB_NAME,
        RC_EXC_NAME, RC_LOC_NAME, RC_CNF_NAME, RC_FNC_NAME,
        RC_QRY_NAME, RC_TMP_NAME, RC_OWN_NAME, RC_GRP_NAME,
        RC_MSK_NAME, RC_ASS_NAME, RC_DEF_NAME, RC_REF_NAME,
        RC_PRM_NAME, RC_TRM_NAME, RC_NCF_NAME, RC_CMN_NAME,
        RC_DFL_NAME, RC_ERR_NAME
    };

    if (m_nLocks) { /* Make sure config exists  */
        return((const char *)s_szOptnametab[Optname]);
    }
    else {
        RC_THROW(RC_ERR_USE);
    }
    return(NULL);   /* Not reached  */
}

const char *configGetrcfile(void)
{
    ex_t Except;

    if (m_nLocks) {                     /* Make sure config exists   */
        try {
            /* Because (1) only one rc file can be specified and     */
            /*         (2) it must be specified on the command line, */
            /* we don't bother checking the environment or conf file */
            /* contrary to the behaviour of Getval earlier           */
            return(clioptGetrcfile());
        }
        catch(Except) {
            rethrow;
        }
    }
    else {
        RC_THROW(RC_ERR_USE);
    }

    return(NULL);   /* Not reached  */
}

const char **configGetsecs(void)
{
    ex_t Except;

    if (m_nLocks) {                             /* Make sure config exists   */
        try {                                   /* FIXME Might need to check */
            return(clioptGetsecs());            /* FIXME env, conf, configs  */
        }
        catch(Except) {
            rethrow;
        }
    }
    else {
        RC_THROW(RC_ERR_USE);
    }

    return(NULL);   /* Not reached  */
}

/************************************************
* configLoad(int, const char **)                *
* Load a configuration                          *
************************************************/
rc_return_t configLoad(int nTotal, const char *szArgvec[])
{
    ex_t Except;

    try {       /* Parse option groups in order of priority          */
        clioptParseopts(nTotal, szArgvec);  /* Command line options  */
        clioptParseargs();                  /* Command line args */
/*        envoptParse(m_nLocks->pOpt);*/    /* Environment options   */
/*        cnfoptParse(m_nLocks->pOpt);*/    /* Configfile options    */
    }
    catch(Except) {
        rethrow;
    }

    return(RC_THROW(RC_OK));
}

/************************************************
* configVerify(void)                            *
* Verify config options help, usage, or version *
************************************************/
rc_return_t configVerify(void)
{
    ex_t Except;
    short bStop = FALSE;

    try { /* Basic checks of version, usage, and help options */
        if (configGetval(RC_USE_VAL)) {
            clioptPrintusage();
            bStop = TRUE;
        }
        else if (configGetval(RC_HLP_VAL)) {
            clioptPrintusage(); /* FIXME Replace with real help FIXME */
            bStop = TRUE;
        }
        else if (configGetval(RC_VER_VAL)) {
            fprintf(stdout, "OSSP rc %s\n", RC_VERSION);
            bStop = TRUE;
        }
        else if (configGetval(RC_INF_VAL)) {
            configInfo();
            bStop = TRUE;
        }
    }
    catch(Except) {
        rethrow;
    }

    if (bStop)                          /* Did user request a non-operation?  */
        return(RC_THROW(RC_ERR_TRM));   /* Yes, so terminate after handling.  */
    else
        return(RC_THROW(RC_OK));        /* No, we should continue processing. */
}

/***************************************
* configDelete(void)                   *
* Destruct a configuration             *
***************************************/
rc_return_t configDelete(void)
{
    ex_t Except;

    if (--m_nLocks == 0) {          /* If m_nLocks is 0, deallocate */
        try {                       /* FIXME, not thread-safe       */
            clioptDelete();
        }
        catch(Except) {
            rethrow;
        }
    }
    else
        return(RC_THROW(RC_ERR_USE));

    return(RC_THROW(RC_OK));
}