#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include "bookloupe.h"
#include "counters.h"

struct matching_counter {
    int open,close;
};

GQuark counters_error_quark(void)
{
    static GQuark quark;
    if (!quark)
	quark=g_quark_from_static_string("counters_error");
    return quark;
}

static struct matching_counter *matching_counter_new(void)
{
    return g_slice_new0(struct matching_counter);
}

static void matching_counter_free(struct matching_counter *counter)
{
    g_slice_free(struct matching_counter,counter);
}

static gint compar_unichars(gconstpointer a,gconstpointer b,gpointer unused)
{
    /*
     * Unicode code points only go up to 0x10FFFF and thus this cannot overflow.
     */
    return GPOINTER_TO_INT(a)-GPOINTER_TO_INT(b);
}

/*
 * For matching characters, we maintain a count of the opens and closes.
 * In the simplest case, we are dealing with a matching pair such as [ and ]
 * where there is a 1:1 mapping between an instance of [ with an open and
 * between an instance of ] with a close. matching_ket() is
 * responsible for selecting an arbitary base character of a matching pair.
 */
static gpointer matching_key(gunichar ch)
{
    gunichar mirrored;
    if (g_unichar_get_mirror_char(ch,&mirrored))
	if (ch<mirrored)
	    return GINT_TO_POINTER((gint)ch);
	else
	    return GINT_TO_POINTER((gint)mirrored);
    else if (ch==CHAR_SQUOTE || ch==CHAR_OPEN_SQUOTE)
	return GINT_TO_POINTER((gint)CHAR_SQUOTE);
    else if (ch==CHAR_LS_QUOTE || ch==CHAR_RS_QUOTE)
	return GINT_TO_POINTER((gint)CHAR_LS_QUOTE);
    else if (ch==CHAR_LD_QUOTE || ch==CHAR_RD_QUOTE)
	return GINT_TO_POINTER((gint)CHAR_LD_QUOTE);
    else if (ch==CHAR_DQUOTE)
	return GINT_TO_POINTER((gint)ch);
    else if (ch<0x4000 || ch-0x4000>=NO_SPECIAL_COUNTERS)
	g_warning("Matching pair not found for U+%04" G_GINT32_MODIFIER "X",ch);
    return GINT_TO_POINTER((gint)ch);
}

gboolean innermost_quote_matches(struct counters *counters,gunichar ch)
{
    gpointer head;
    if (counters->open_quotes)
	head=counters->open_quotes->data;
    else
	head=NULL;
    return head==matching_key(ch);
}

gboolean count_quote(struct counters *counters,gunichar ch,QuoteClass klass,
  GError **err)
{
    gboolean retval=TRUE;
    gpointer head;
    if (counters->open_quotes)
	head=counters->open_quotes->data;
    else
	head=NULL;
    switch(klass)
    {
	case NEUTRAL_QUOTE:
	    if (head!=matching_key(ch))
		goto opening;
	    /* else fall through */
	case CLOSING_QUOTE:
	    if (head!=matching_key(ch))
	    {
		g_set_error(err,COUNTERS_ERROR,COUNTERS_ERROR_FAILED,
		  "Closing quotation mark with no matching open?");
		retval=FALSE;
	    }
	    else
		counters->open_quotes=g_slist_delete_link(counters->open_quotes,
		  counters->open_quotes);
	    break;
	case OPENING_QUOTE:
	    if (head==matching_key(ch))
	    {
		g_set_error(err,COUNTERS_ERROR,COUNTERS_ERROR_FAILED,
		  "Directly nested quotation marks of same type?");
		retval=FALSE;
	    }
opening:
	    head=matching_key(ch);
	    counters->open_quotes=g_slist_prepend(counters->open_quotes,head);
	    break;
    }
    return retval;
}

void increment_matching(struct counters *counters,gunichar ch,gboolean open)
{
    gpointer key,orig_key;
    struct matching_counter *value;
    if (!counters->matching)
	counters->matching=g_tree_new_full(compar_unichars,NULL,NULL,
	  (GDestroyNotify)matching_counter_free);
    key=matching_key(ch);
    if (!g_tree_lookup_extended(counters->matching,key,&orig_key,
      (gpointer *)&value))
    {
	value=matching_counter_new();
	g_tree_insert(counters->matching,key,value);
    }
    if (open)
	value->open++;
    else
	value->close++;
}

int matching_count(const struct counters *counters,gunichar ch,gboolean open)
{
    struct matching_counter *value;
    if (!counters->matching)
	return 0;
    value=g_tree_lookup(counters->matching,matching_key(ch));
    if (!value)
	return 0;
    return open?value->open:value->close;
}

/*
 * Return open count - closed count
 */
int matching_difference(const struct counters *counters,gunichar ch)
{
    struct matching_counter *value;
    if (!counters->matching)
	return 0;
    value=g_tree_lookup(counters->matching,matching_key(ch));
    if (!value)
	return 0;
    return value->open-value->close;
}

void counters_reset(struct counters *counters)
{
    if (counters->matching)
	g_tree_destroy(counters->matching);
    memset(counters,0,sizeof(*counters));
}

void counters_destroy(struct counters *counters)
{
    if (counters->matching)
    {
	g_tree_destroy(counters->matching);
	counters->matching=NULL;
    }
}