#include <stdio.h>

#include <stdlib.h>

#include <sys/select.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>

#include <fcntl.h>

#include "dictre.h"

enum

{

    SIZESTEP=1000

};

extern struct Def defs[];

extern int ndefs;

extern int dont_touch[];

extern int ndont_touch;

static void more_memory(void **ptr, int size)

{

    void *new;

    new = realloc(*ptr, size);

    *ptr = new;

}

static

char * manage_filter(const char *def, int deflen, int writeto, int readfrom,

        int *outlen)

{

    int maxfd;

    int defptr;

    int outptr;

    char *out;

    int outsize;

    int outrest;

    int res;

    out = 0;

    outsize = SIZESTEP;

    outptr = 0;

    more_memory((void **) &out, outsize);

    outrest = SIZESTEP;

    /* We need unblocking write for select() */

    res = fcntl(writeto, F_SETFL, O_NONBLOCK);

    if (res == -1)

    {

        perror("Error setting nonblock to writeto");

        exit(-1);

    }

    maxfd = writeto;

    if (readfrom > maxfd)

        maxfd = readfrom;

    defptr = 0;

    do

    {

        fd_set writeset, readset;

        FD_ZERO(&writeset);

        FD_ZERO(&readset);

        if (defptr < deflen)

            FD_SET(writeto, &writeset);

        FD_SET(readfrom, &readset);

        select(maxfd+1, &readset, &writeset, 0, 0);

        if (FD_ISSET(readfrom, &readset))

        {

            int res;

            res = read(readfrom, out + outptr, outrest);

            if (res == 0)

            {

                close(readfrom);

                break;

            }

            outrest -= res;

            outptr += res;

            if (outrest == 0)

            {

                outrest = SIZESTEP;

                outsize += SIZESTEP;

                more_memory((void **) &out, outsize);

            }

        }

        if (FD_ISSET(writeto, &writeset))

        {

            int res;

            res = write(writeto, def+defptr, deflen - defptr);

            defptr += res;

            if (defptr >= deflen)

                close(writeto);

        }

    } while(1);

    /*

    {

        int i;

        printf("In : ");

        for(i=0; i < deflen; ++i)

            putchar(def[i]);

        printf("\nOut: ");

        for(i=0; i < outptr; ++i)

            putchar(out[i]);

        putchar('\n');

    }

    */

    if (defptr < deflen)

    {

        fprintf(stderr, "Error in filter! not all written.\n");

        exit(-1);

    }

    /* Give away memory don't needed */

    more_memory((void **) &out, outptr);

    *outlen = outptr;

    return out;

}

static char * filter(char *def, int deflen, const char *filter_par, int *outlen)

{

    int write_pipe[2];

    int read_pipe[2];

    int pid;

    int res;

    int status;

    char *out;

    pipe(write_pipe);

    pipe(read_pipe);

    pid = fork();

    switch(pid)

    {

        case 0:  /* child */

            close(0);

            dup(write_pipe[0]);

            close(write_pipe[0]);

            close(write_pipe[1]);

            close(1);

            dup(read_pipe[1]);

            close(read_pipe[1]);

            close(read_pipe[0]);

            execl(filter_par, filter_par, 0);

            perror("execlp");

            exit(-1);

            break;

        case -1:

            perror("fork");

            exit(-1);

            break;

        default:  /* parent */

            close(write_pipe[0]);

            close(read_pipe[1]);

            break;

    }

    /* parent */

    out = manage_filter(def, deflen, write_pipe[1], read_pipe[0], outlen);

    res = wait(&status);

    if (res != pid || WEXITSTATUS(status) != 0)

    {

        fprintf(stderr, "Error filtering: pid=%i status=%i",

                pid, WEXITSTATUS(status));

        exit(-1);

    }

    return out;

}

static int in_dont_touch(int n)

{

    int i;

    for(i =0; i < ndont_touch; ++i)

    {

        if (n == dont_touch[i])

        {

            return 1;

        }

    }

    return 0;

}

void filter_all(const char *filter_par)

{

    int i;

    static int dispndefs = 0;

    static int filtereddefs = 0;

    for(i=0; i < ndefs; ++i)

    {

        char *newdef;

        int newdeflen;

        if (!in_dont_touch(i))

        {

            if (defs[i].length > 0)

            {

                newdef = filter(defs[i].d, defs[i].length,

                        filter_par, &newdeflen);

                defs[i].length = newdeflen;

                free(defs[i].d);

                defs[i].d = newdef;

            }

            filtereddefs++; /* Not really all filtered. All but the 00-database* */

            dispndefs++;

            if (dispndefs >= 1000)

            {

                dispndefs = 0;

                printf("Filtered: %i/%i (%f%%)\n", filtereddefs, ndefs,

                        (float) filtereddefs / (float) ndefs * 100.);

            }

        }

    }

}