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

    }

}