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

struct matching_counter {
    int open,close;
};

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);
}

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;
    }
}