/* Multi-language support.
 *
 * IRC Services is copyright (c) 1996-2009 Andrew Church.
 *     E-mail: <achurch@achurch.org>
 * Parts written by Andrew Kempe and others.
 * This program is free but copyrighted software; see the file GPL.txt for
 * details.
 */

#define LANGSTR_ARRAY  /* define langstrs[] in langstrs.h, via language.h */

#include "services.h"
#include "language.h"

/* Needed for NickGroupInfo structure definition (used by getstring() and
 * strftime_lang()) */
#include "modules/nickserv/nickserv.h"

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

/* Indexes of available languages (exported), terminated by -1: */
int langlist[NUM_LANGS+1];

/* List and count of available strings: */
static char **langstrs;
int num_strings;

/* The list of lists of messages. */
static char **langtexts[NUM_LANGS];
/* Pointers to the original data, in case external files are loaded later. */
static char **origtexts[NUM_LANGS];

/* Order in which languages should be displayed: (alphabetical in English) */
static int langorder[] = {
    LANG_EN_US,         /* English (US) */
    LANG_NL,            /* Dutch */
    LANG_FR,            /* French */
    LANG_DE,            /* German */
    LANG_HU,            /* Hungarian */
/*    LANG_IT,*/        /* Italian */
    LANG_JA_EUC,        /* Japanese (EUC encoding) */
    LANG_JA_SJIS,       /* Japanese (SJIS encoding) */
/*    LANG_PT,*/        /* Portugese */
    LANG_RU,            /* Russian */
    LANG_ES,            /* Spanish */
    LANG_TR,            /* Turkish */
};

/* Filenames for language files: */
static struct {
    int num;
    const char *filename;
} filenames[] = {
    { LANG_EN_US,       "en_us" },
    { LANG_NL,          "nl" },
    { LANG_FR,          "fr" },
    { LANG_DE,          "de" },
    { LANG_HU,          "hu" },
    { LANG_IT,          "it" },
    { LANG_JA_EUC,      "ja_euc" },
    { LANG_JA_SJIS,     "ja_sjis" },
    { LANG_PT,          "pt" },
    { LANG_RU,          "ru" },
    { LANG_ES,          "es" },
    { LANG_TR,          "tr" },
    { -1, NULL }
};

/* Mapping of language strings (to allow on-the-fly replacement of strings) */
static int *langmap;

/* Array indicating which languages were actually loaded (needed since NULL
 * langtexts[] pointers are redirected to DEF_LANGUAGE) */
static int is_loaded[NUM_LANGS];

/* Index of the first extra (non-base) string */
#define FIRST_EXTRA_STRING      (NUM_BASE_STRINGS)
/* Is the given string index a base string index? */
#define IS_BASE_STRING(n)       ((n) < FIRST_EXTRA_STRING)

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

/* Helper functions. */

static inline int read_int32(int32 *ptr, FILE *f)
{
    int a = fgetc(f);
    int b = fgetc(f);
    int c = fgetc(f);
    int d = fgetc(f);
    if (a == EOF || b == EOF || c == EOF || d == EOF)
        return -1;
    *ptr = a<<24 | b<<16 | c<<8 | d;
    return 0;
}

static inline int read_uint32(uint32 *ptr, FILE *f)
{
    return read_int32((int32 *)ptr, f);
}

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

/* Load a language file, storing the data in origtexts[index]. */

static void load_lang(int index, const char *filename)
{
    char buf[256];
    FILE *f;
    uint32 num, size, i;
    char *data = NULL;

    log_debug(1, "Loading language %d from file `languages/%s'",
              index, filename);
    snprintf(buf, sizeof(buf), "languages/%s", filename);
    if (!(f = fopen(buf, "r"))) {
        log_perror("Failed to load language %d (%s)", index, filename);
        return;
    } else if (read_uint32(&num, f) < 0) {
        log("Failed to read number of strings for language %d (%s)",
            index, filename);
        return;
    } else if (read_uint32(&size, f) < 0) {
        log("Failed to read data size for language %d (%s)",
            index, filename);
        return;
    } else if (num != NUM_BASE_STRINGS) {
        log("Warning: Bad number of strings (%d, wanted %d) "
            "for language %d (%s)", num, NUM_BASE_STRINGS, index, filename);
    }
    origtexts[index] = scalloc(sizeof(char *), NUM_BASE_STRINGS+1);
    if (num > NUM_BASE_STRINGS)
        num = NUM_BASE_STRINGS;
    origtexts[index][0] = data = smalloc(size+4);
    *((uint32 *)data) = size;
    data += 4;
    if (fread(data, size, 1, f) != 1) {
        log("Failed to read language data for language %d (%s)",
            index, filename);
        goto fail;
    }
    for (i = 0; i < num; i++) {
        int32 pos;
        if (read_int32(&pos, f) < 0) {
            log("Failed to read entry %d in language %d (%s) TOC",
                i, index, filename);
            goto fail;
        }
        if (pos == -1) {
            origtexts[index][i+1] = NULL;
        } else {
            origtexts[index][i+1] = data + pos;
        }
    }
    fclose(f);
    is_loaded[index] = 1;
    return;

  fail:
    free(data);
    free(origtexts[index]);
    origtexts[index] = NULL;
    return;
}

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

/* Initialize list of lists. */

int lang_init(void)
{
    int i, j, n = 0;

    /* Set up the string list */
    langstrs = malloc(sizeof(char *) * NUM_BASE_STRINGS);
    if (!langstrs) {
        log_perror("malloc(langstrs)");
        return 0;
    }
    memcpy(langstrs, base_langstrs, sizeof(char *) * NUM_BASE_STRINGS);
    num_strings = NUM_BASE_STRINGS;

    /* Set up the string remap list */
    langmap = smalloc(sizeof(int) * num_strings);
    for (i = 0; i < num_strings; i++)
        langmap[i] = i;

    /* Load language files */
    memset(is_loaded, 0, sizeof(is_loaded));
    for (i = 0; i < lenof(langorder); i++) {
        for (j = 0; filenames[j].num >= 0; j++) {
            if (filenames[j].num == langorder[i])
                break;
        }
        if (filenames[j].num >= 0) {
            load_lang(langorder[i], filenames[j].filename);
        } else {
            log("BUG: lang_init(): no filename entry for language %d!",
                langorder[i]);
        }
    }

    /* Make sure the default language has all strings available */
    if (!origtexts[DEF_LANGUAGE]) {
        log("Unable to load default language");
        return 0;
    }
    for (i = 0; i < num_strings; i++) {
        if (!origtexts[DEF_LANGUAGE][i+1]) {
            if (is_loaded[LANG_EN_US] && origtexts[LANG_EN_US][i+1]) {
                uint32 oldsize = *((uint32 *)origtexts[DEF_LANGUAGE][0]);
                uint32 newsize = strlen(origtexts[LANG_EN_US][i+1]) + 1;
                origtexts[DEF_LANGUAGE][0] =
                    realloc(origtexts[DEF_LANGUAGE][0], oldsize + newsize + 4);
                if (!origtexts[DEF_LANGUAGE][0]) {
                    log("Out of memory while loading languages");
                    return 0;
                }
                *((uint32 *)origtexts[DEF_LANGUAGE][0]) = oldsize + newsize;
                origtexts[DEF_LANGUAGE][i+1] =
                    origtexts[DEF_LANGUAGE][0] + 4 + oldsize;
                strcpy(origtexts[DEF_LANGUAGE][i+1],
                       origtexts[LANG_EN_US][i+1]);
            } else {
                log("String %s missing from default language", langstrs[i]);
                return 0;
            }
        }
    }

    /* Set up the list of available languages in langlist[] */
    for (i = 0; i < lenof(langorder); i++) {
        if (is_loaded[langorder[i]])
            langlist[n++] = langorder[i];
    }
    while (n < lenof(langlist))
        langlist[n++] = -1;

    /* Initialize the active string tables in langtexts[] */
    reset_ext_lang();

    return 1;
}

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

/* Clean up language data. */

void lang_cleanup(void)
{
    int i;

    for (i = 0; i < NUM_LANGS; i++) {
        if (langtexts[i]) {
            free(langtexts[i][0]);
            free(langtexts[i]);
            langtexts[i] = NULL;
        }
        if (origtexts[i]) {
            free(origtexts[i][0]);
            free(origtexts[i]);
            langtexts[i] = NULL;
        }
    }
    free(langmap);
    free(langstrs);
}

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

/* Load an external language file.  External language files are formatted
 * the same way as the standard language files, except that a language name
 * follows the string name; for example:
 *
 * UNKNOWN_COMMAND<lwsp+>en_us<lwsp*><nl>
 * <tab>The command %s is not recognized.<nl>
 *
 * where <lwsp> is "linear white space" (space or tab); <nl> is either LF
 * or CRLF; and <tab> is the tab character.  Empty lines and lines
 * beginning with '#' are ignored.  Note that any lines longer than
 * BUFSIZE-1 characters (including the trailing <nl>) will be truncated.
 *
 * Returns 0 on failure, nonzero on success.
 */

int load_ext_lang(const char *filename)
{
    FILE *f;
    char buf[BUFSIZE], *s;
    char **newtexts[NUM_LANGS];
    uint32 newsizes[NUM_LANGS];
    int i, curstr, curlang, line;
    int retval = 1, firstline = 1;

    memset(newtexts, 0, sizeof(newtexts));
    memset(newsizes, 0, sizeof(newsizes));
    f = fopen(filename, "r");
    if (!f) {
        log_perror("load_ext_lang(): Unable to open file %s", filename);
        return 0;
    }

    curstr = curlang = -1;
    line = 0;
    while (fgets(buf, sizeof(buf), f) && *buf) {
        line++;
        s = buf + strlen(buf) - 1;
        if (*s == '\r') {  /* in case we get half a CRLF */
            *s = fgetc(f);
            if (*s != '\n') {
                ungetc(*s, f);
                *s = '\r';
            }
        }
        if (*s == '\n') {
            *s = 0;
            if (s > buf && s[-1] == '\r')
                s[-1] = 0;
        } else {
            char buf2[BUFSIZE];
            log("load_ext_lang(): %s:%d: Line too long (maximum %d"
                " characters)", filename, line, sizeof(buf)-2);
            retval = 0;
            while (fgets(buf2, sizeof(buf2), f)
                   && *buf2 && buf2[strlen(buf2)-1] != '\n')
                ;
        }
        if (*buf == '#')
            continue;
        if (*buf != '\t') {
            curstr = curlang = -1;
            s = strtok(buf, " \t\r\n");
            if (!s)
                continue;  /* empty line */
            if ((curstr = lookup_string(s)) < 0) {
                log("load_ext_lang: %s:%d: Unknown string ID `%s'",
                    filename, line, s);
                retval = 0;
            } else {
                s = strtok(NULL, " \t\r\n");
                if (!s) {
                    log("load_ext_lang: %s:%d: Missing language ID\n",
                        filename, line);
                    retval = 0;
                    curstr = -1;
                } else if ((curlang = lookup_language(s)) < 0) {
                    log("load_ext_lang: %s:%d: Unknown language ID `%s'",
                        filename, line, s);
                    retval = 0;
                    curstr = -1;
                } else if (!is_loaded[curlang]) {
                    log("load_ext_lang: %s:%d: Language `%s' is not"
                        " available", filename, line, s);
                    retval = 0;
                    curstr = -1;
                }
            }
            if (curstr >= 0 && curlang >= 0) {
                /* Valid string/language ID--set up storage space if not
                 * yet done */
                if (!newtexts[curlang]) {
                    newtexts[curlang] = calloc(num_strings+1, sizeof(char *));
                    if (!newtexts[curlang]) {
                        log_perror("load_ext_lang: %s:%d", filename, line);
                        goto fail;
                    }
                    newsizes[curlang] = 0;
                }
                /* Point to location of string in data buffer; we add 1
                 * to the offset to differentiate the value from 0 (not
                 * present) */
                newtexts[curlang][curstr+1] = (char *)newsizes[curlang] + 1;
                /* Set first-line flag (signals whether to insert a
                 * newline) */
                firstline = 1;
            }
        } else {  /* line begins with tab -> text line */
            if (curstr >= 0 && curlang >= 0) {
                int oldsize = newsizes[curlang];
                if (!firstline)
                    oldsize--;  // overwrite the trailing \0 with a newline
                newsizes[curlang] += strlen(buf+1)+1;  // skip initial tab
                newtexts[curlang][0] =
                    realloc(newtexts[curlang][0], newsizes[curlang]);
                sprintf(newtexts[curlang][0]+oldsize, "%s%s",
                        firstline ? "" : "\n", buf+1);
                firstline = 0;
            }
        }
    }  /* for each line */
    fclose(f);

    if (retval) {
        /* Success, install new strings.  First set up new string arrays in
         * newtexts[], then, when all succeeds (i.e. no ENOMEM), move the
         * new data to langtexts[]. */
        for (curlang = 0; curlang < NUM_LANGS; curlang++) {
            char *newbuf;
            uint32 oldlen, newlen;
            if (!newtexts[curlang])
                continue;
            oldlen = *((uint32 *)langtexts[curlang][0]);
            newlen = newsizes[curlang];
            newbuf = malloc(4 + oldlen + newlen);
            if (!newbuf) {
                log_perror("load_ext_lang: %s:%d", filename, line);
                goto fail;
            }
            *((uint32 *)newbuf) = oldlen + newlen;
            memcpy(newbuf+4, langtexts[curlang][0]+4, oldlen);
            memcpy(newbuf+4+oldlen, newtexts[curlang][0], newlen);
            free(newtexts[curlang][0]);
            newtexts[curlang][0] = newbuf;
            for (i = 0; i < num_strings; i++) {
                if (newtexts[curlang][i+1]) {
                    int ofs = (int)newtexts[curlang][i+1] - 1;
                    newtexts[curlang][i+1] = newbuf+4 + oldlen + ofs;
                } else if (langtexts[curlang][i+1]) {
                    int ofs = langtexts[curlang][i+1]
                              - langtexts[curlang][0];
                    newtexts[curlang][i+1] = newbuf + ofs;
                } else {
                    newtexts[curlang][i+1] = NULL;
                }
            }
        }  /* for each language */
        /* All okay, actually install the data */
        for (curlang = 0; curlang < NUM_LANGS; curlang++) {
            if (!newtexts[curlang])
                continue;
            free(langtexts[curlang][0]);
            free(langtexts[curlang]);
            langtexts[curlang] = newtexts[curlang];
        }
    }  /* if (retval) */

    return retval;

  fail:
    for (curlang = 0; curlang < NUM_LANGS; curlang++) {
        if (newtexts[curlang]) {
            free(newtexts[curlang][0]);
            free(newtexts[curlang]);
        }
    }
    fclose(f);
    return 0;
}

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

/* Clear all data loaded from external language files or set with
 * setstring(), restoring to the default data sets.  Strings added with
 * addstring() are retained but reset to empty.
 */

void reset_ext_lang(void)
{
    int i, j;

    for (i = 0; i < NUM_LANGS; i++) {
        if (is_loaded[i]) {
            uint32 datasize = *((uint32 *)origtexts[i][0]);
            if (langtexts[i]) {
                free(langtexts[i][0]);
                free(langtexts[i]);
            }
            langtexts[i] = smalloc(sizeof(char *) * (num_strings+1));
            langtexts[i][0] = smalloc(datasize+4);
            memcpy(langtexts[i][0], origtexts[i][0], datasize+4);
            for (j = 0; j < num_strings; j++) {
                if (IS_BASE_STRING(j)) {
                    if (origtexts[i][j+1]) {
                        langtexts[i][j+1] = origtexts[i][j+1]
                                          - origtexts[i][0]
                                          + langtexts[i][0];
                    } else {
                        langtexts[i][j+1] = NULL;
                    }
                } else if (i == DEF_LANGUAGE) {
                    langtexts[i][j+1] = langtexts[i][0] + datasize - 1;
                } else {
                    langtexts[i][j+1] = NULL;
                }
            }
        }
    }
}

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

/* Return the language number for the given language name.  If the language
 * is not found, returns -1.
 */

int lookup_language(const char *name)
{
    int i;

    for (i = 0; filenames[i].num >= 0; i++) {
        if (stricmp(filenames[i].filename, name) == 0)
            return filenames[i].num;
    }
    return -1;
}

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

/* Return true if the given language is loaded, false otherwise. */

int have_language(int language)
{
    return language >= 0 && language < NUM_LANGS && is_loaded[language];
}

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

/* Return the index of the given string name.  If the name is not found,
 * returns -1.  Note that string names are case sensitive.
 */

int lookup_string(const char *name)
{
    int i;

    for (i = 0; i < num_strings; i++) {
        if (strcmp(langstrs[i], name) == 0)
            return i;
    }
    return -1;
}

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

/* Retrieve a message text using the language selected for the given
 * NickGroupInfo (if NickGroupInfo is NULL, use DEF_LANGUAGE).
 */

const char *getstring(const NickGroupInfo *ngi, int index)
{
    int language;
    const char *text;

    if (index < 0 || index >= num_strings) {
        log("getstring(): BUG: index (%d) out of range!", index);
        return NULL;
    }
    language = (ngi && ngi != NICKGROUPINFO_INVALID
                    && ngi->language != LANG_DEFAULT)
               ? ngi->language
               : DEF_LANGUAGE;
    text = langtexts[language][langmap[index]+1];
    if (!text)
        text = langtexts[DEF_LANGUAGE][langmap[index]+1];
    return text;
}

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

/* Retrieve a message text using the given language. */

const char *getstring_lang(int language, int index)
{
    const char *text;

    if (language < 0 || language >= NUM_LANGS) {
        log("getstring_lang(): BUG: language (%d) out of range!", language);
        language = DEF_LANGUAGE;
    } else if (index < 0 || index >= num_strings) {
        log("getstring_lang(): BUG: index (%d) out of range!", index);
        return NULL;
    }
    text = langtexts[language][langmap[index]+1];
    if (!text)
        text = langtexts[DEF_LANGUAGE][langmap[index]+1];
    return text;
}

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

/* Set the contents of the given string in the given language.  Returns
 * nonzero on success, zero on error (invalid parameters or language not
 * available).  The text is copied to a separate location, so does not need
 * to be saved by the caller.
 */

int setstring(int language, int index, const char *text)
{
    uint32 oldlen, newlen;
    char *oldtext, *newtext;
    int i;

    if (language < 0 || language >= NUM_LANGS) {
        log("setstring(): language (%d) out of range!", language);
        return 0;
    } else if (index < 0 || index >= num_strings) {
        log("setstring(): index (%d) out of range!", index);
        return 0;
    } else if (IS_BASE_STRING(index)) {
        log("setstring(): index (%d) is a base string and cannot be set",
            index);
        return 0;
    } else if (!text) {
        log("setstring(): text is NULL!");
        return 0;
    } else if (!is_loaded[language]) {
        log_debug(1, "setstring(): language %d not available", language);
        return 0;
    }
    oldtext = langtexts[language][0];
    oldlen = *((uint32 *)oldtext);
    newlen = oldlen + strlen(text) + 1;
    newtext = malloc(newlen + 4);
    if (!newtext) {
        log("setstring(): out of memory");
        return 0;
    }
    *((uint32 *)newtext) = newlen;
    memcpy(newtext+4, oldtext+4, oldlen);
    strcpy(newtext+4+oldlen, text);
    for (i = 0; i < num_strings; i++) {
        if (i == index) {
            langtexts[language][i+1] = newtext+4 + oldlen;
        } else {
            int ofs = langtexts[language][i+1] - oldtext;
            langtexts[language][i+1] = newtext + ofs;
        }
    }
    langtexts[language][0] = newtext;
    free(oldtext);
    return 1;
}

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

/* Map string number `old' to number `new' and return the number of the
 * message that used to be stored there.  Returns -1 on error (invalid
 * parameter).
 */

int mapstring(int old, int new)
{
    int prev;

    if (old < 0 || old >= num_strings) {
        log("mapstring(): old string index (%d) is out of range!", old);
        return -1;
    } else if (new < 0 || new >= num_strings) {
        log("mapstring(): new string index (%d) is out of range!", new);
        return -1;
    }
    prev = langmap[old];
    langmap[old] = langmap[new];
    return prev;
}

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

/* Add a new string to the global list with the given (non-empty) name.
 * The string is initially empty in all languages.  If the string has
 * already been added, clears the string's text but does not add a new copy
 * of the string.  Returns the string index on success, -1 on failure
 * (invalid parameters or attempting to re-add a base string).
 */

int addstring(const char *name)
{
    int index, i;
    char **new_langstrs, **new_langtexts[NUM_LANGS];
    int *new_langmap;

    if (!name) {
        log("addstring(): BUG: name is NULL!");
        return -1;
    }
    if (!*name) {
        log("addstring(): name is the empty string!");
        return -1;
    }
    if ((index = lookup_string(name)) >= 0) {
        if (IS_BASE_STRING(index)) {
            log("addstring(): attempt to re-add base string `%s'!", name);
            return -1;
        } else {
            return index;
        }
    }
    new_langstrs = malloc(sizeof(char *) * (num_strings+1));
    new_langmap = malloc(sizeof(int) * (num_strings+1));
    if (!new_langstrs || !new_langmap) {
        log("addstring(): Out of memory!");
        free(new_langmap);
        free(new_langstrs);
        return -1;
    }
    memcpy(new_langstrs, langstrs, sizeof(char *) * num_strings);
    memcpy(new_langmap, langmap, sizeof(int) * num_strings);
    new_langstrs[num_strings] = strdup(name);
    if (!new_langstrs[num_strings]) {
        log("addstring(): Out of memory!");
        free(new_langmap);
        free(new_langstrs);
        return -1;
    }
    new_langmap[num_strings] = num_strings;
    for (i = 0; i < NUM_LANGS; i++) {
        if (!is_loaded[i])
            continue;
        new_langtexts[i] = malloc(sizeof(char *) * (num_strings+2));
        if (!new_langtexts[i]) {
            log("addstring(): Out of memory!");
            while (--i >= 0)
                free(new_langtexts[i]);
            free(new_langstrs[num_strings]);
            free(new_langmap);
            free(new_langstrs);
            return -1;
        }
        memcpy(new_langtexts[i], langtexts[i],
               sizeof(char *) * (num_strings+1));
        if (i == DEF_LANGUAGE) {
            /* Point at the \0 ending the last string in the text buffer */
            new_langtexts[i][num_strings+1] =
                new_langtexts[i][0]+4 + *((uint32 *)new_langtexts[i][0]) - 1;
        } else {
            new_langtexts[i][num_strings+1] = NULL;
        }
    }
    free(langstrs);
    langstrs = new_langstrs;
    free(langmap);
    langmap = new_langmap;
    for (i = 0; i < NUM_LANGS; i++) {
        if (is_loaded[i]) {
            free(langtexts[i]);
            langtexts[i] = new_langtexts[i];
        }
    }
    return num_strings++;
}

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

/* Format a string in a strftime()-like way, but heed the nick group's
 * language setting for month and day names and adjust the time for the
 * nick group's time zone setting.  The string stored in the buffer will
 * always be null-terminated, even if the actual string was longer than the
 * buffer size.  Also note that the format parameter is a message number
 * rather than a literal string, and the time parameter is a time_t, not a
 * struct tm *.
 * Assumption: No month or day name has a length (including trailing null)
 * greater than BUFSIZE or contains the '%' character.
 */

int strftime_lang(char *buf, int size, const NickGroupInfo *ngi,
                  int format, time_t time)
{
    int ngi_is_valid = (ngi && ngi != NICKGROUPINFO_INVALID);
    int language = (ngi_is_valid && ngi->language != LANG_DEFAULT)
                   ? ngi->language
                   : DEF_LANGUAGE;
    char tmpbuf[BUFSIZE], buf2[BUFSIZE];
    char *s;
    int i, ret;
    struct tm *tm;

    strbcpy(tmpbuf, getstring_lang(language,format));
    if (ngi_is_valid && ngi->timezone != TIMEZONE_DEFAULT) {
        time += ngi->timezone*60;
        tm = gmtime(&time);
        /* Remove "%Z" (timezone) specifiers */
        while ((s = strstr(tmpbuf, "%Z")) != NULL) {
            char *end = s+2;
            while (s > tmpbuf && s[-1] == ' ')
                s--;
            strmove(s, end);
        }
    } else {
        tm = localtime(&time);
    }
    if ((s = langtexts[language][STRFTIME_DAYS_SHORT+1]) != NULL) {
        for (i = 0; i < tm->tm_wday; i++)
            s += strcspn(s, "\n")+1;
        i = strcspn(s, "\n");
        strncpy(buf2, s, i);
        buf2[i] = 0;
        strnrepl(tmpbuf, sizeof(tmpbuf), "%a", buf2);
    }
    if ((s = langtexts[language][STRFTIME_DAYS_LONG+1]) != NULL) {
        for (i = 0; i < tm->tm_wday; i++)
            s += strcspn(s, "\n")+1;
        i = strcspn(s, "\n");
        strncpy(buf2, s, i);
        buf2[i] = 0;
        strnrepl(tmpbuf, sizeof(tmpbuf), "%A", buf2);
    }
    if ((s = langtexts[language][STRFTIME_MONTHS_SHORT+1]) != NULL) {
        for (i = 0; i < tm->tm_mon; i++)
            s += strcspn(s, "\n")+1;
        i = strcspn(s, "\n");
        strncpy(buf2, s, i);
        buf2[i] = 0;
        strnrepl(tmpbuf, sizeof(tmpbuf), "%b", buf2);
    }
    if ((s = langtexts[language][STRFTIME_MONTHS_LONG+1]) != NULL) {
        for (i = 0; i < tm->tm_mon; i++)
            s += strcspn(s, "\n")+1;
        i = strcspn(s, "\n");
        strncpy(buf2, s, i);
        buf2[i] = 0;
        strnrepl(tmpbuf, sizeof(tmpbuf), "%B", buf2);
    }
    ret = strftime(buf, size, tmpbuf, tm);
    if (ret >= size)  // buffer overflow, should be impossible
        return 0;
    return ret;
}

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

/* Generates a string describing the given length of time to one unit
 * (e.g. "3 days" or "10 hours"), or two units (e.g. "5 hours 25 minutes")
 * if the MT_DUALUNIT flag is specified.  The minimum resolution is one
 * minute, unless the MT_SECONDS flag is specified; the returned time is
 * rounded up if in the minimum unit, else rounded to the nearest integer.
 * The returned buffer is a static buffer which will be overwritten on the
 * next call to this routine.
 *
 * The MT_* flags (passed in the `flags' parameter) are defined in
 * language.h.
 */

char *maketime(const NickGroupInfo *ngi, time_t time, int flags)
{
    static char buf[BUFSIZE];
    int unit;

    if (time < 1)  /* Enforce a minimum of one second */
        time = 1;

    if ((flags & MT_SECONDS) && time <= 59) {

        unit = (time==1 ? STR_SECOND : STR_SECONDS);
        snprintf(buf, sizeof(buf), "%ld%s", (long)time, getstring(ngi,unit));

    } else if (!(flags & MT_SECONDS) && time <= 59*60) {

        time = (time+59) / 60;
        unit = (time==1 ? STR_MINUTE : STR_MINUTES);
        snprintf(buf, sizeof(buf), "%ld%s", (long)time, getstring(ngi,unit));


    } else if (flags & MT_DUALUNIT) {

        time_t time2;
        int unit2;

        if (time <= 59*60+59) {  /* 59 minutes, 59 seconds */
            time2 = time % 60;
            unit2 = (time2==1 ? STR_SECOND : STR_SECONDS);
            time = time / 60;
            unit = (time==1 ? STR_MINUTE : STR_MINUTES);
        } else if (time <= (23*60+59)*60+30) {  /* 23 hours, 59.5 minutes */
            time = (time+30) / 60;
            time2 = time % 60;
            unit2 = (time2==1 ? STR_MINUTE : STR_MINUTES);
            time = time / 60;
            unit = (time==1 ? STR_HOUR : STR_HOURS);
        } else {
            time = (time+(30*60)) / (60*60);
            time2 = time % 24;
            unit2 = (time2==1 ? STR_HOUR : STR_HOURS);
            time = time / 24;
            unit = (time==1 ? STR_DAY : STR_DAYS);
        }
        if (time2)
            snprintf(buf, sizeof(buf), "%ld%s%s%ld%s", (long)time,
                     getstring(ngi,unit), getstring(ngi,STR_TIMESEP),
                     (long)time2, getstring(ngi,unit2));
        else
            snprintf(buf, sizeof(buf), "%ld%s", (long)time,
                     getstring(ngi,unit));

    } else {  /* single unit */

        if (time <= 59*60+30) {  /* 59 min 30 sec; MT_SECONDS known true */
            time = (time+30) / 60;
            unit = (time==1 ? STR_MINUTE : STR_MINUTES);
        } else if (time <= (23*60+30)*60) {  /* 23 hours, 30 minutes */
            time = (time+(30*60)) / (60*60);
            unit = (time==1 ? STR_HOUR : STR_HOURS);
        } else {
            time = (time+(12*60*60)) / (24*60*60);
            unit = (time==1 ? STR_DAY : STR_DAYS);
        }
        snprintf(buf, sizeof(buf), "%ld%s", (long)time, getstring(ngi,unit));

    }

    return buf;
}

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

/* Generates a description for the given expiration time in the form of
 * days, hours, minutes, seconds and/or a combination thereof.  May also
 * return "does not expire" or "already expired" messages if the expiration
 * time given is zero or earlier than the current time, respectively.
 * String is truncated if it would exceed `size' bytes (including trailing
 * null byte).
 */

void expires_in_lang(char *buf, int size, const NickGroupInfo *ngi,
                     time_t expires)
{
    time_t seconds = expires - time(NULL);

    if (expires == 0) {
        strscpy(buf, getstring(ngi,EXPIRES_NONE), size);
    } else if (seconds <= 0 && noexpire) {
        strscpy(buf, getstring(ngi,EXPIRES_NOW), size);
    } else {
        if (seconds <= 0) {
            /* Already expired--it will be cleared out by the next get() */
            seconds = 1;
        }
        snprintf(buf, size, getstring(ngi,EXPIRES_IN),
                 maketime(ngi,seconds,MT_DUALUNIT));
    }
}

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

/* Send a syntax-error message to the user. */

void syntax_error(const char *service, const User *u, const char *command,
                  int msgnum)
{
    char buf[BUFSIZE];
    snprintf(buf, sizeof(buf), getstring(u->ngi, msgnum), command);
    notice_lang(service, u, SYNTAX_ERROR, buf);
    notice_lang(service, u, MORE_INFO, service, command);
}

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

/*
 * Local variables:
 *   c-file-style: "stroustrup"
 *   c-file-offsets: ((case-label . *) (statement-case-intro . *))
 *   indent-tabs-mode: nil
 * End:
 *
 * vim: expandtab shiftwidth=4:
 */