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

   obt/ddparse.c for the Openbox window manager
   Copyright (c) 2009        Dana Jansens

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   See the COPYING file for a copy of the GNU General Public License.
*/

#include "obt/ddparse.h"
#include "obt/link.h"
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_STDIO_H
#include <stdio.h>
#endif

typedef struct _ObtDDParse ObtDDParse;

/* Parses the value and adds it to the group's key_hash, with the given
   key
   Return TRUE if it is added to the hash table, and FALSE if not.
*/
typedef gboolean (*ObtDDParseValueFunc)(gchar *key, const gchar *val,
                                        ObtDDParse *parse, gboolean *error);


enum {
    DE_TYPE             = 1 << 0,
    DE_TYPE_APPLICATION = 1 << 1,
    DE_TYPE_LINK        = 1 << 2,
    DE_NAME             = 1 << 3,
    DE_EXEC             = 1 << 4,
    DE_URL              = 1 << 5
};

struct _ObtDDParse {
    gchar *filename;
    gulong lineno;
    gulong flags;
    ObtDDParseGroup *group;
    /* the key is a group name, the value is a ObtDDParseGroup */
    GHashTable *group_hash;
};

struct _ObtDDParseGroup {
    gchar *name;
    gboolean seen;
    ObtDDParseValueFunc value_func;
    /* the key is a string (a key inside the group in the .desktop).
       the value is an ObtDDParseValue */
    GHashTable *key_hash;
};

/* Displays a warning message including the file name and line number, and
   sets the boolean @error to true if it points to a non-NULL address.
*/
static void parse_error(const gchar *m, const ObtDDParse *const parse,
                        gboolean *error)
{
    if (!parse->filename)
        g_warning("%s at line %lu of input", m, parse->lineno);
    else
        g_warning("%s at line %lu of file %s",
                  m, parse->lineno, parse->filename);
    if (error) *error = TRUE;
}

static void parse_value_free(ObtDDParseValue *v)
{
    switch (v->type) {
    case OBT_DDPARSE_EXEC:
    case OBT_DDPARSE_STRING:
    case OBT_DDPARSE_LOCALESTRING:
        g_free(v->value.string); break;
    case OBT_DDPARSE_STRINGS:
    case OBT_DDPARSE_LOCALESTRINGS:
        g_strfreev(v->value.strings.a);
        v->value.strings.n = 0;
        break;
    case OBT_DDPARSE_BOOLEAN:
    case OBT_DDPARSE_NUMERIC:
    case OBT_DDPARSE_ENUM_TYPE:
    case OBT_DDPARSE_ENVIRONMENTS:
        break;
    default:
        g_assert_not_reached();
    }
    g_slice_free(ObtDDParseValue, v);
}

static ObtDDParseGroup* parse_group_new(gchar *name, ObtDDParseValueFunc f)
{
    ObtDDParseGroup *g = g_slice_new(ObtDDParseGroup);
    g->name = name;
    g->value_func = f;
    g->seen = FALSE;
    g->key_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
                                        g_free,
                                        (GDestroyNotify)parse_value_free);
    return g;
}

static void parse_group_free(ObtDDParseGroup *g)
{
    g_free(g->name);
    g_hash_table_destroy(g->key_hash);
    g_slice_free(ObtDDParseGroup, g);
}

/*! Reads an input string, strips out invalid stuff, and parses
    backslash-stuff.
 */
static gchar* parse_value_string(const gchar *in,
                                 gboolean locale,
                                 gboolean semicolonterminate,
                                 gulong *len,
                                 const ObtDDParse *const parse,
                                 gboolean *error)
{
    gint bytes;
    gboolean backslash;
    gchar *out, *o;
    const gchar *end, *i;

    /* find the end/size of the string */
    backslash = FALSE;
    for (end = in; *end; ++end) {
        if (semicolonterminate) {
            if (backslash) backslash = FALSE;
            else if (*end == '\\') backslash = TRUE;
            else if (*end == ';') break;
        }
    }
    bytes = end - in;

    g_return_val_if_fail(in != NULL, NULL);

    if (locale && !g_utf8_validate(in, bytes, &end)) {
        parse_error("Invalid bytes in localestring", parse, error);
        bytes = end - in;
    }

    out = g_new(char, bytes + 1);
    if (len) *len = 0;
    i = in; o = out;
    backslash = FALSE;
    while (i < end) {
        const gchar *next;

        /* find the next character in the string */
        if (!locale) next = i+1;
        else if (!(next = g_utf8_find_next_char(i, end))) next = end;

        if (backslash) {
            switch(*i) {
            case 's': *o++ = ' '; break;
            case 'n': *o++ = '\n'; break;
            case 't': *o++ = '\t'; break;
            case 'r': *o++ = '\r'; break;
            case ';': *o++ = ';'; break;
            case '\\': *o++ = '\\'; break;
            default:
                parse_error((locale ?
                             "Invalid escape sequence in localestring" :
                             "Invalid escape sequence in string"),
                            parse, error);
            }
            backslash = FALSE;
        }
        else if (*i == '\\')
            backslash = TRUE;
        else if ((guchar)*i >= 127 || (guchar)*i < 32) {
            /* avoid ascii control characters */
            parse_error("Found control character in string", parse, error);
            break;
        }
        else {
            const gulong s = next-i;
            memcpy(o, i, s);
            o += s;
            if (len) *len += s;
        }
        i = next;
    }
    *o = '\0';
    return out;
}


/*! Reads a list of input strings, strips out invalid stuff, and parses
    backslash-stuff.
 */
static gchar** parse_value_strings(const gchar *in,
                                   gboolean locale,
                                   gulong *nstrings,
                                   const ObtDDParse *const parse,
                                   gboolean *error)
{
    gchar **out;
    const gchar *i;

    out = g_new(gchar*, 1);
    out[0] = NULL;
    *nstrings = 0;

    i = in;
    while (TRUE) {
        gchar *a;
        gulong len;

        a = parse_value_string(i, locale, TRUE, &len, parse, error);
        i += len;

        if (len) {
            (*nstrings)++;
            out = g_renew(gchar*, out, *nstrings+1);
            out[*nstrings-1] = a;
            out[*nstrings] = NULL;
        }

        if (!*i) break; /* no more strings */
        ++i;
    }
    return out;
}

static guint parse_value_environments(const gchar *in,
                                      const ObtDDParse *const parse,
                                      gboolean *error)
{
    const gchar *s;
    guint mask = 0;

    s = in;
    while (*s) {
        switch (*(s++)) {
        case 'G':
            if (strcmp(s, "NOME") == 0) {
                mask |= OBT_LINK_ENV_GNOME;
                s += 4;
            }
            break;
        case 'K':
            if (strcmp(s, "DE") == 0) {
                mask |= OBT_LINK_ENV_KDE;
                s += 2;
            }
            break;
        case 'L':
            if (strcmp(s, "XDE") == 0) {
                mask |= OBT_LINK_ENV_LXDE;
                s += 3;
            }
            break;
        case 'R':
            if (strcmp(s, "OX") == 0) {
                mask |= OBT_LINK_ENV_ROX;
                s += 2;
            }
            break;
        case 'X':
            if (strcmp(s, "FCE") == 0) {
                mask |= OBT_LINK_ENV_XFCE;
                s += 3;
            }
            break;
        case 'O':
            switch (*(s++)) {
            case 'l':
                if (strcmp(s, "d") == 0) {
                    mask |= OBT_LINK_ENV_OLD;
                    s += 1;
                }
                break;
            case 'P':
                if (strcmp(s, "ENBOX") == 0) {
                    mask |= OBT_LINK_ENV_OPENBOX;
                    s += 5;
                }
                break;
            }
        }
        /* find the next string, or the end of the sequence */
        while (*s && *s != ';') ++s;
    }
    return mask;
}

static gboolean parse_value_boolean(const gchar *in,
                                    const ObtDDParse *const parse,
                                    gboolean *error)
{
    if (strcmp(in, "true") == 0)
        return TRUE;
    else if (strcmp(in, "false") != 0)
        parse_error("Invalid boolean value", parse, error);
    return FALSE;
}

static gfloat parse_value_numeric(const gchar *in,
                                  const ObtDDParse *const parse,
                                  gboolean *error)
{
    gfloat out = 0;
    if (sscanf(in, "%f", &out) == 0)
        parse_error("Invalid numeric value", parse, error);
    return out;
}

static gboolean parse_file_line(FILE *f, gchar **buf,
                                gulong *size, gulong *read,
                                ObtDDParse *parse, gboolean *error)
{
    const gulong BUFMUL = 80;
    size_t ret;
    gulong i, null;

    if (*size == 0) {
        g_assert(*read == 0);
        *size = BUFMUL;
        *buf = g_new(char, *size);
    }

    /* remove everything up to a null zero already in the buffer and shift
       the rest to the front */
    null = *size;
    for (i = 0; i < *read; ++i) {
        if (null < *size)
            (*buf)[i-null-1] = (*buf)[i];
        else if ((*buf)[i] == '\0')
            null = i;
    }
    if (null < *size)
        *read -= null + 1;

    /* is there already a newline in the buffer? */
    for (i = 0; i < *read; ++i)
        if ((*buf)[i] == '\n') {
            /* turn it into a null zero and done */
            (*buf)[i] = '\0';
            return TRUE;
        }

    /* we need to read some more to find a newline */
    while (TRUE) {
        gulong eol;
        gchar *newread;

        newread = *buf + *read;
        ret = fread(newread, sizeof(char), *size-*read, f);
        if (ret < *size - *read && !feof(f)) {
            parse_error("Error reading", parse, error);
            return FALSE;
        }
        *read += ret;

        /* strip out null zeros in the input and look for an endofline */
        null = 0;
        eol = *size;
        for (i = newread-*buf; i < *read; ++i) {
            if (null > 0)
                (*buf)[i] = (*buf)[i+null];
            if ((*buf)[i] == '\0') {
                ++null;
                --(*read);
                --i; /* try again */
            }
            else if ((*buf)[i] == '\n' && eol == *size) {
                eol = i;
                /* turn it into a null zero */
                (*buf)[i] = '\0';
            }
        }

        if (eol != *size)
            /* found an endofline, done */
            break;
        else if (feof(f) && *read < *size) {
            /* found the endoffile, done (if there is space) */
            if (*read > 0) {
                /* stick a null zero on if there is test on the last line */
                (*buf)[(*read)++] = '\0';
            }
            break;
        }
        else {
            /* read more */
            size += BUFMUL;
            *buf = g_renew(char, *buf, *size);
        }
    }
    return *read > 0;
}

static void parse_group(const gchar *buf, gulong len,
                        ObtDDParse *parse, gboolean *error)
{
    ObtDDParseGroup *g;
    gchar *group;
    gulong i;

    /* get the group name */
    group = g_strndup(buf+1, len-2);
    for (i = 0; i < len-2; ++i)
        if ((guchar)group[i] < 32 || (guchar)group[i] >= 127) {
            /* valid ASCII only */
            parse_error("Invalid character found", parse, NULL);
            group[i] = '\0'; /* stopping before this character */
            break;
        }

    /* make sure it's a new group */
    g = g_hash_table_lookup(parse->group_hash, group);
    if (g && g->seen) {
        parse_error("Duplicate group found", parse, error);
        g_free(group);
        return;
    }
    /* if it's the first group, make sure it's named Desktop Entry */
    else if (!parse->group && strcmp(group, "Desktop Entry") != 0)
    {
        parse_error("Incorrect group found, "
                    "expected [Desktop Entry]",
                    parse, error);
        g_free(group);
        return;
    }
    else {
        if (!g) {
            g = parse_group_new(group, NULL);
            g_hash_table_insert(parse->group_hash, g->name, g);
        }
        else
            g_free(group);

        g->seen = TRUE;
        parse->group = g;
        g_print("Found group %s\n", g->name);
    }
}

static void parse_key_value(const gchar *buf, gulong len,
                            ObtDDParse *parse, gboolean *error)
{
    gulong i, keyend, valstart, eq;
    char *key;

    /* find the end of the key */
    for (i = 0; i < len; ++i)
        if (!(((guchar)buf[i] >= 'A' && (guchar)buf[i] <= 'Z') ||
              ((guchar)buf[i] >= 'a' && (guchar)buf[i] <= 'z') ||
              ((guchar)buf[i] >= '0' && (guchar)buf[i] <= '9') ||
              ((guchar)buf[i] == '-'))) {
            /* not part of the key */
            break;
        }
    keyend = i;

    if (keyend < 1) {
        parse_error("Empty key", parse, error);
        return;
    }
    /* find the = character */
    for (i = keyend; i < len; ++i) {
        if (buf[i] == '=') {
            eq = i;
            break;
        }
        else if (buf[i] != ' ') {
            parse_error("Invalid character in key name", parse, error);
            return ;
        }
    }
    if (i == len) {
        parse_error("Key without value found", parse, error);
        return;
    }
    /* find the start of the value */
    for (i = eq+1; i < len; ++i)
        if (buf[i] != ' ') {
            valstart = i;
            break;
        }
    if (i == len) {
        parse_error("Empty value found", parse, error);
        return;
    }

    key = g_strndup(buf, keyend);
    if (g_hash_table_lookup(parse->group->key_hash, key)) {
        parse_error("Duplicate key found", parse, error);
        g_free(key);
        return;
    }
    g_print("Found key/value %s=%s.\n", key, buf+valstart);
    if (parse->group->value_func)
        if (!parse->group->value_func(key, buf+valstart, parse, error)) {
            parse_error("Unknown key", parse, error);
            g_free(key);
        }
}

static gboolean parse_file(FILE *f, ObtDDParse *parse)
{
    gchar *buf = NULL;
    gulong bytes = 0, read = 0;
    gboolean error = FALSE;

    while (!error && parse_file_line(f, &buf, &bytes, &read, parse, &error)) {
        gulong len = strlen(buf);
        if (buf[0] == '#' || buf[0] == '\0')
            ; /* ignore comment lines */
        else if (buf[0] == '[' && buf[len-1] == ']')
            parse_group(buf, len, parse, &error);
        else if (!parse->group)
            /* just ignore keys outside of groups */
            parse_error("Key found before group", parse, NULL);
        else
            /* ignore errors in key-value pairs and continue */
            parse_key_value(buf, len, parse, NULL);
        ++parse->lineno;
    }

    if (buf) g_free(buf);
    return !error;
}

static gboolean parse_desktop_entry_value(gchar *key, const gchar *val,
                                          ObtDDParse *parse, gboolean *error)
{
    ObtDDParseValue v, *pv;

    switch (key[0]) {
    case 'C':
        switch (key[1]) {
        case 'a': /* Categories */
            if (strcmp(key+2, "tegories")) return FALSE;
            v.type = OBT_DDPARSE_STRINGS; break;
        case 'o': /* Comment */
            if (strcmp(key+2, "mment")) return FALSE;
            v.type = OBT_DDPARSE_LOCALESTRING; break;
        default:
            return FALSE;
        }
        break;
    case 'E': /* Exec */
        if (strcmp(key+1, "xec")) return FALSE;
        v.type = OBT_DDPARSE_EXEC; parse->flags |= DE_EXEC; break;
    case 'G': /* GenericName */
        if (strcmp(key+1, "enericName")) return FALSE;
        v.type = OBT_DDPARSE_LOCALESTRING; break;
    case 'I': /* Icon */
        if (strcmp(key+1, "con")) return FALSE;
        v.type = OBT_DDPARSE_LOCALESTRING; break;
    case 'H': /* Hidden */
        if (strcmp(key+1, "idden")) return FALSE;
        v.type = OBT_DDPARSE_BOOLEAN; break;
    case 'M': /* MimeType */
        if (strcmp(key+1, "imeType")) return FALSE;
        v.type = OBT_DDPARSE_STRINGS; break;
    case 'N':
        switch (key[1]) {
        case 'a': /* Name */
            if (strcmp(key+2, "me")) return FALSE;
            v.type = OBT_DDPARSE_LOCALESTRING; parse->flags |= DE_NAME; break;
        case 'o':
            switch (key[2]) {
            case 'D': /* NoDisplay */
                if (strcmp(key+3, "isplay")) return FALSE;
                v.type = OBT_DDPARSE_BOOLEAN; break;
            case 't': /* NotShowIn */
                if (strcmp(key+3, "ShowIn")) return FALSE;
                v.type = OBT_DDPARSE_STRINGS; break;
            default:
                return FALSE;
            }
            break;
        default:
            return FALSE;
        }
        break;
    case 'P': /* Path */
        if (strcmp(key+1, "ath")) return FALSE;
        v.type = OBT_DDPARSE_STRING; break;
    case 'S': /* Path */
        if (key[1] == 't' && key[2] == 'a' && key[3] == 'r' &&
            key[4] == 't' && key[5] == 'u' && key[6] == 'p')
            switch (key[7]) {
            case 'N': /* StartupNotify */
                if (strcmp(key+8, "otify")) return FALSE;
                v.type = OBT_DDPARSE_BOOLEAN; break;
            case 'W': /* StartupWMClass */
                if (strcmp(key+8, "MClass")) return FALSE;
                v.type = OBT_DDPARSE_STRING; break;
            default:
                return FALSE;
            }
        else
            return FALSE;
        break;
    case 'T':
        switch (key[1]) {
        case 'e': /* Terminal */
            if (strcmp(key+2, "rminal")) return FALSE;
            v.type = OBT_DDPARSE_BOOLEAN; break;
        case 'r': /* TryExec */
            if (strcmp(key+2, "yExec")) return FALSE;
            v.type = OBT_DDPARSE_STRING; break;
        case 'y': /* Type */
            if (strcmp(key+2, "pe")) return FALSE;
            v.type = OBT_DDPARSE_ENUM_TYPE; parse->flags |= DE_TYPE; break;
        default:
            return FALSE;
        }
        break;
    case 'U': /* URL */
        if (strcmp(key+1, "RL")) return FALSE;
        v.type = OBT_DDPARSE_STRING; parse->flags |= DE_URL; break;
    case 'V': /* MimeType */
        if (strcmp(key+1, "ersion")) return FALSE;
        v.type = OBT_DDPARSE_STRING; break;
    default:
        return FALSE;
    }

    /* parse the value */
    switch (v.type) {
    case OBT_DDPARSE_EXEC: {
        gchar *c, *m;
        gboolean percent;
        gboolean found;

        v.value.string = parse_value_string(val, FALSE, FALSE, NULL,
                                            parse, error);
        g_assert(v.value.string);

        /* an exec string can only contain one of the file/url-opening %'s */
        percent = found = FALSE;
        for (c = v.value.string; *c; ++c) {
            if (percent) {
                switch (*c) {
                case 'f':
                case 'F':
                case 'u':
                case 'U':
                    if (found) {
                        m = g_strdup_printf("Malformed Exec key, "
                                            "extraneous %%%c", *c);
                        parse_error(m, parse, error);
                        g_free(m);
                    }
                    found = TRUE;
                    break;
                case 'd':
                case 'D':
                case 'n':
                case 'N':
                case 'v':
                case 'm':
                    m = g_strdup_printf("Malformed Exec key, "
                                        "uses deprecated %%%c", *c);
                    parse_error(m, parse, NULL); /* just a warning */
                    g_free(m);
                    break;
                case 'i':
                case 'c':
                case 'k':
                case '%':
                    break;
                default:
                    m = g_strdup_printf("Malformed Exec key, "
                                        "uses unknown %%%c", *c);
                    parse_error(m, parse, NULL); /* just a warning */
                    g_free(m);
                }
                percent = FALSE;
            }
            else if (*c == '%') percent = TRUE;
        }
        break;
    }
    case OBT_DDPARSE_STRING:
        v.value.string = parse_value_string(val, FALSE, FALSE, NULL,
                                            parse, error);
        g_assert(v.value.string);
        break;
    case OBT_DDPARSE_LOCALESTRING:
        v.value.string = parse_value_string(val, TRUE, FALSE, NULL,
                                            parse, error);
        g_assert(v.value.string);
        break;
    case OBT_DDPARSE_STRINGS:
        v.value.strings.a = parse_value_strings(val, FALSE, &v.value.strings.n,
                                                parse, error);
        g_assert(v.value.strings.a);
        g_assert(v.value.strings.n);
        break;
    case OBT_DDPARSE_LOCALESTRINGS:
        v.value.strings.a = parse_value_strings(val, TRUE, &v.value.strings.n,
                                                parse, error);
        g_assert(v.value.strings.a);
        g_assert(v.value.strings.n);
        break;
    case OBT_DDPARSE_BOOLEAN:
        v.value.boolean = parse_value_boolean(val, parse, error);
        break;
    case OBT_DDPARSE_NUMERIC:
        v.value.numeric = parse_value_numeric(val, parse, error);
        break;
    case OBT_DDPARSE_ENUM_TYPE:
        if (val[0] == 'A' && strcmp(val+1, "pplication") == 0) {
            v.value.enumerable = OBT_LINK_TYPE_APPLICATION;
            parse->flags |= DE_TYPE_APPLICATION;
        }
        else if (val[0] == 'L' && strcmp(val+1, "ink") == 0) {
            v.value.enumerable = OBT_LINK_TYPE_URL;
            parse->flags |= DE_TYPE_LINK;
        }
        else if (val[0] == 'D' && strcmp(val+1, "irectory") == 0)
            v.value.enumerable = OBT_LINK_TYPE_DIRECTORY;
        else {
            parse_error("Unknown Type", parse, error);
            return FALSE;
        }
        break;
    case OBT_DDPARSE_ENVIRONMENTS:
        v.value.environments = parse_value_environments(val, parse, error);
        break;
    default:
        g_assert_not_reached();
    }

    pv = g_slice_new(ObtDDParseValue);
    *pv = v;
    g_hash_table_insert(parse->group->key_hash, key, pv);
    return TRUE;
}

GHashTable* obt_ddparse_file(const gchar *name, GSList *paths)
{
    ObtDDParse parse;
    ObtDDParseGroup *desktop_entry;
    GSList *it;
    FILE *f;
    gboolean success;

    parse.filename = NULL;
    parse.lineno = 0;
    parse.group = NULL;
    parse.group_hash = g_hash_table_new_full(g_str_hash,
                                             g_str_equal,
                                             NULL,
                                             (GDestroyNotify)parse_group_free);

    /* set up the groups (there's only one right now) */
    desktop_entry = parse_group_new(g_strdup("Desktop Entry"),
                                    parse_desktop_entry_value);
    g_hash_table_insert(parse.group_hash, desktop_entry->name, desktop_entry);

    success = FALSE;
    for (it = paths; it && !success; it = g_slist_next(it)) {
        gchar *path = g_strdup_printf("%s/%s", (char*)it->data, name);
        if ((f = fopen(path, "r"))) {
            parse.filename = path;
            parse.lineno = 1;
            parse.flags = 0;
            if ((success = parse_file(f, &parse))) {
                /* check that required keys exist */

                if (!(parse.flags & DE_TYPE)) {
                    g_warning("Missing Type key in %s", path);
                    success = FALSE;
                }
                if (!(parse.flags & DE_NAME)) {
                    g_warning("Missing Name key in %s", path);
                    success = FALSE;
                }
                if (parse.flags & DE_TYPE_APPLICATION &&
                    !(parse.flags & DE_EXEC))
                {
                    g_warning("Missing Exec key for Application in %s",
                              path);
                    success = FALSE;
                }
                else if (parse.flags & DE_TYPE_LINK && !(parse.flags & DE_URL))
                {
                    g_warning("Missing URL key for Link in %s", path);
                    success = FALSE;
                }
            }
            fclose(f);
        }
        g_free(path);
    }
    if (!success) {
        g_hash_table_destroy(parse.group_hash);
        parse.group_hash = NULL;
    }
    return parse.group_hash;
}

GHashTable* obt_ddparse_group_keys(ObtDDParseGroup *g)
{
    return g->key_hash;
}