/* notmuch - Not much of an email program, (just index and search)
 *
 * Copyright © 2012 Carl Worth
 *
 * 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 3 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see http://www.gnu.org/licenses/ .
 *
 * Author: Carl Worth <cworth@cworth.org>
 */

#include <stdbool.h>
#include <stdio.h>
#include <talloc.h>
#include "sprinter.h"

struct sprinter_sexp {
    struct sprinter vtable;
    FILE *stream;
    /* Top of the state stack, or NULL if the printer is not currently
     * inside any aggregate types. */
    struct sexp_state *state;

    /* A flag to signify that a separator should be inserted in the
     * output as soon as possible.
     */
    notmuch_bool_t insert_separator;
};

struct sexp_state {
    struct sexp_state *parent;

    /* True if nothing has been printed in this aggregate yet.
     * Suppresses the space before a value. */
    notmuch_bool_t first;

    /* True if the state is a map state.
     * Used to add a space between key/value pairs. */
    notmuch_bool_t in_map;

    /* The character that closes the current aggregate. */
    char close;
};

/* Helper function to set up the stream to print a value.  If this
 * value follows another value, prints a space. */
static struct sprinter_sexp *
sexp_begin_value (struct sprinter *sp)
{
    struct sprinter_sexp *sps = (struct sprinter_sexp *) sp;

    if (sps->state) {
	if (! sps->state->first) {
	    if (sps->insert_separator) {
		fputc ('\n', sps->stream);
		sps->insert_separator = FALSE;
	    } else {
		if (! sps->state->in_map)
		    fputc (' ', sps->stream);
	    }
	} else {
	    sps->state->first = FALSE;
	}
    }
    return sps;
}

/* Helper function to begin an aggregate type.  Prints the open
 * character and pushes a new state frame. */
static void
sexp_begin_aggregate (struct sprinter *sp, char open, char close)
{
    struct sprinter_sexp *sps = sexp_begin_value (sp);
    struct sexp_state *state = talloc (sps, struct sexp_state);
    fputc (open, sps->stream);
    state->parent = sps->state;
    state->first = TRUE;
    state->in_map = FALSE;
    state->close = close;
    sps->state = state;
}

static void
sexp_begin_map (struct sprinter *sp)
{
    struct sprinter_sexp *sps = (struct sprinter_sexp *) sp;
    sexp_begin_aggregate (sp, '(', ')');
    sps->state->in_map = TRUE;
}

static void
sexp_begin_list (struct sprinter *sp)
{
    sexp_begin_aggregate (sp, '(', ')');
}

static void
sexp_end (struct sprinter *sp)
{
    struct sprinter_sexp *sps = (struct sprinter_sexp *) sp;
    struct sexp_state *state = sps->state;

    if (sps->state->in_map)
	fputc (')', sps->stream);
    fputc (sps->state->close, sps->stream);
    sps->state = state->parent;
    talloc_free (state);
    if (sps->state == NULL)
	fputc ('\n', sps->stream);
}

static void
sexp_string_len_internal (struct sprinter *sp, const char *val, size_t len, notmuch_bool_t quote)
{
    static const char *const escapes[] = {
	['\"'] = "\\\"", ['\\'] = "\\\\", ['\b'] = "\\b",
	['\f'] = "\\f",  ['\n'] = "\\n",  ['\t'] = "\\t"
    };
    struct sprinter_sexp *sps = sexp_begin_value (sp);

    if(quote)
	fputc ('"', sps->stream);
    for (; len; ++val, --len) {
	unsigned char ch = *val;
	if (ch < ARRAY_SIZE (escapes) && escapes[ch])
	    fputs (escapes[ch], sps->stream);
	else if (ch >= 32)
	    fputc (ch, sps->stream);
	else
	    fprintf (sps->stream, "\\u%04x", ch);
    }
    if(quote)
	fputc ('"', sps->stream);
}

static void
sexp_string_len (struct sprinter *sp, const char *val, size_t len)
{
    sexp_string_len_internal (sp, val, len, TRUE); /* print quoted */
}

static void
sexp_symbol_len (struct sprinter *sp, const char *val, size_t len)
{
    sexp_string_len_internal (sp, val, len, FALSE); /* print unquoted */
}

static void
sexp_string (struct sprinter *sp, const char *val)
{
    if (val == NULL)
	val = "";
    sexp_string_len (sp, val, strlen (val));
}

static void
sexp_symbol (struct sprinter *sp, const char *val)
{
    if (val == NULL)
	val = "";
    sexp_symbol_len (sp, val, strlen (val));
}

static void
sexp_integer (struct sprinter *sp, int val)
{
    struct sprinter_sexp *sps = sexp_begin_value (sp);

    fprintf (sps->stream, "%d", val);
}

static void
sexp_boolean (struct sprinter *sp, notmuch_bool_t val)
{
    struct sprinter_sexp *sps = sexp_begin_value (sp);

    fputs (val ? "t" : "nil", sps->stream);
}

static void
sexp_null (struct sprinter *sp)
{
    struct sprinter_sexp *sps = sexp_begin_value (sp);

    fputs ("nil", sps->stream);
}

static void
sexp_map_key (struct sprinter *sp, const char *key)
{
    struct sprinter_sexp *sps = (struct sprinter_sexp *) sp;

    if (sps->state->in_map && ! sps->state->first)
	fputs (") ", sps->stream);
    fputc ('(', sps->stream);
    sexp_symbol (sp, key);
    fputc (' ', sps->stream);
}

static void
sexp_set_prefix (unused (struct sprinter *sp), unused (const char *name))
{
}

static void
sexp_separator (struct sprinter *sp)
{
    struct sprinter_sexp *sps = (struct sprinter_sexp *) sp;

    sps->insert_separator = TRUE;
}

struct sprinter *
sprinter_sexp_create (const void *ctx, FILE *stream)
{
    static const struct sprinter_sexp template = {
	.vtable = {
	    .begin_map = sexp_begin_map,
	    .begin_list = sexp_begin_list,
	    .end = sexp_end,
	    .string = sexp_string,
	    .string_len = sexp_string_len,
	    .integer = sexp_integer,
	    .boolean = sexp_boolean,
	    .null = sexp_null,
	    .map_key = sexp_map_key,
	    .separator = sexp_separator,
	    .set_prefix = sexp_set_prefix,
	    .is_text_printer = FALSE,
	}
    };
    struct sprinter_sexp *res;

    res = talloc (ctx, struct sprinter_sexp);
    if (! res)
	return NULL;

    *res = template;
    res->stream = stream;
    return &res->vtable;
}