#include <stdio.h>

#include "dictre.h"

enum
{
    MAX=500000
};

struct Word words[MAX];
int nwords;
struct Def defs[MAX];
int ndefs;
int dont_touch[20];
int ndont_touch;

void init_load()
{
    ndefs = 0;
    nwords = 0;
    ndont_touch = 0;
}

static void new_word(struct Word *from)
{
    memcpy(&words[nwords], from, sizeof(*from));
    nwords++;
}

static void new_dont_touch(int n)
{
    dont_touch[ndont_touch++] = n;
}

static int new_def(char *def, int offset, int length)
{
    defs[ndefs].d = def;
    defs[ndefs].offset = offset;
    defs[ndefs].length = length;
    return ndefs++;
}

static int search_def(int offset, int length)
{
    int i;

    for(i=0; i < ndefs; ++i)
    {
        if (defs[i].offset == offset &&
                defs[i].length == length)
            return i;
    }
    return -1;
}

static void print_word(struct Word *w)
{
    printf("%s\t%i\n", w->w, w->def);
}

void load_dictionary(FILE *index, FILE *fdefs)
{
    struct Word w;
    int last_offset = 0;
    int def_avoided = 0;
    int numword = 0;;
    static int dispnwords = 0;

    do {
        int offset, length;
        char *defstr;
        w.w = get_word(index);
        /*numword++;
        printf("words: %i\n", numword);*/
        if (w.w == 0)
            break;
        /*printf("Word: %s\n", w.w);*/
        offset = get_int(index);
        length = get_int(index);
        if (offset > last_offset)
        {
            w.def = -1;
            last_offset = offset;
        }
        else
            w.def = search_def(offset, length);
        if (w.def == -1) 
        {
            /* New definition */
            int newindex, repindex;
            defstr = get_def(fdefs, offset, length);
            newindex = new_def(defstr, offset, length);
            /*
            printf("Length %i (%s): %i\n", newindex, w.w, length);
            */
            
            /* Store it in the hash for repeated defs */
            repindex = def_repeated(&defs[newindex]);
            if (repindex != -1) 
            {
                def_avoided += 1;
                /*
                printf("Repeated def avoided %i (for def %i)"
                        " (%s)\n%i %s\n%i %s\n",
                        def_avoided, repindex, w.w,
                        length, defstr,
                        defs[repindex].length, defs[repindex].d);
                        */
                remove_def(newindex);
                newindex = repindex;
            } else
                new_hashdef(&defs[newindex], newindex);

            /* Store the final index */
            w.def = newindex;
        }
        /* sizeof -1  instead of strlen() */
        if (strncmp(w.w, "00database", sizeof("00database") - 1) == 0)
                new_dont_touch(w.def);
        new_word(&w);

        /* stdout Display */
        dispnwords++;
        if (dispnwords >= 1000)
        {
            dispnwords = 0;
            printf("Loaded: %i Repeated definitions avoided: %i\n", nwords,
                    def_avoided);
        }

    } while(1);
}

void print_words()
{
    int i;

    for(i=0; i < nwords; ++i)
        print_word(&words[i]);
}