/* Chrysalide - Outil d'analyse de fichiers binaires
 * pipe.c - gestion de combinaisons de transformateurs
 *
 * Copyright (C) 2023 Cyrille Bagard
 *
 *  This file is part of Chrysalide.
 *
 *  Chrysalide is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Chrysalide is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */


#include "pipe.h"


#include <assert.h>
#include <malloc.h>


#include "pipe-int.h"



/* ----------------------- RECHERCHE D'UN MOTIF DE TEXTE BRUT ----------------------- */


/* Initialise la classe des pipee de transformations d'octets. */
static void g_scan_modifier_pipe_class_init(GScanModifierPipeClass *);

/* Initialise une instance de pipee de transformations d'octets. */
static void g_scan_modifier_pipe_init(GScanModifierPipe *);

/* Supprime toutes les références externes. */
static void g_scan_modifier_pipe_dispose(GScanModifierPipe *);

/* Procède à la libération totale de la mémoire. */
static void g_scan_modifier_pipe_finalize(GScanModifierPipe *);



/* --------------------- IMPLEMENTATION DES FONCTIONS DE CLASSE --------------------- */


/* Fournit le nom d'appel d'un modificateur pour motif. */
static char *g_scan_modifier_pipe_get_name(const GScanModifierPipe *);

/* Transforme une séquence d'octets pour motif de recherche. */
static bool g_scan_modifier_pipe_transform(const GScanModifierPipe *, const sized_binary_t *, size_t, sized_binary_t **, size_t *);

/* Retrouve l'origine d'une correspondance à partir d'un indice. */
static char *g_scan_modifier_pipe_get_path(const GScanModifierPipe *, size_t *);



/* ---------------------------------------------------------------------------------- */
/*                         RECHERCHE D'UN MOTIF DE TEXTE BRUT                         */
/* ---------------------------------------------------------------------------------- */


/* Indique le type défini pour une série de transformations d'octets. */
G_DEFINE_TYPE(GScanModifierPipe, g_scan_modifier_pipe, G_TYPE_SCAN_TOKEN_MODIFIER);


/******************************************************************************
*                                                                             *
*  Paramètres  : klass = classe à initialiser.                                *
*                                                                             *
*  Description : Initialise la classe des pipee de transformations d'octets.  *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_modifier_pipe_class_init(GScanModifierPipeClass *klass)
{
    GObjectClass *object;                   /* Autre version de la classe  */
    GScanTokenModifierClass *modifier;      /* Version de classe parente   */

    object = G_OBJECT_CLASS(klass);

    object->dispose = (GObjectFinalizeFunc/* ! */)g_scan_modifier_pipe_dispose;
    object->finalize = (GObjectFinalizeFunc)g_scan_modifier_pipe_finalize;

    modifier = G_SCAN_TOKEN_MODIFIER_CLASS(klass);

    modifier->get_name = (get_scan_modifier_name_fc)g_scan_modifier_pipe_get_name;

    modifier->transform = (transform_scan_token_fc)g_scan_modifier_pipe_transform;
    modifier->get_path = (get_modifier_path)g_scan_modifier_pipe_get_path;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : pipe = instance à initialiser.                               *
*                                                                             *
*  Description : Initialise une instance de pipee de transformations d'octets.*
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_modifier_pipe_init(GScanModifierPipe *pipe)
{
    pipe->modifiers = NULL;
    pipe->count = 0;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : pipe = instance d'objet GLib à traiter.                      *
*                                                                             *
*  Description : Supprime toutes les références externes.                     *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_modifier_pipe_dispose(GScanModifierPipe *pipe)
{
    size_t i;                               /* Boucle de parcours          */

    for (i = 0; i < pipe->count; i++)
        g_clear_object(&pipe->modifiers[i]);

    G_OBJECT_CLASS(g_scan_modifier_pipe_parent_class)->dispose(G_OBJECT(pipe));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : pipe = instance d'objet GLib à traiter.                      *
*                                                                             *
*  Description : Procède à la libération totale de la mémoire.                *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static void g_scan_modifier_pipe_finalize(GScanModifierPipe *pipe)
{
    if (pipe->modifiers != NULL)
        free(pipe->modifiers);

    G_OBJECT_CLASS(g_scan_modifier_pipe_parent_class)->finalize(G_OBJECT(pipe));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : -                                                            *
*                                                                             *
*  Description : Construit une pipee de modificateurs d'octets.               *
*                                                                             *
*  Retour      : Mécanisme mis en place.                                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GScanTokenModifier *g_scan_modifier_pipe_new(void)
{
    GScanTokenModifier *result;                    /* Structure à retourner       */

    result = g_object_new(G_TYPE_SCAN_MODIFIER_PIPE, NULL);

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : pipe     = pipee de modificateurs à étendre.                 *
*                modifier = modificateur à intégrer.                          *
*                                                                             *
*  Description : Intègre un nouveau transformateur à enchaîner.               *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void g_scan_modifier_pipe_add(GScanModifierPipe *pipe, GScanTokenModifier *modifier)
{
    pipe->modifiers = realloc(pipe->modifiers, ++pipe->count * sizeof(GScanTokenModifier *));

    pipe->modifiers[pipe->count - 1] = modifier;
    g_object_ref(G_OBJECT(modifier));

}


/******************************************************************************
*                                                                             *
*  Paramètres  : pipe = série à consulter.                                    *
*                                                                             *
*  Description : Indique le nombre de transformateurs intégrés dans la série. *
*                                                                             *
*  Retour      : Nombre de modificateurs représentés.                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

size_t g_scan_modifier_pipe_count(const GScanModifierPipe *pipe)
{
    size_t result;                          /* Quantité à retourner        */

    result = pipe->count;

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : pipe  = série à consulter.                                   *
*                index = indice du paramètre à retourner.                     *
*                                                                             *
*  Description : Fournit un transformateur donné de la série.                 *
*                                                                             *
*  Retour      : Modificateur inclus dans la pipee ou NULL si mauvais indice. *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GScanTokenModifier *g_scan_modifier_pipe_get(const GScanModifierPipe *pipe, size_t index)
{
    GScanTokenModifier *result;             /* Instance à retourner        */

    assert(index < pipe->count);

    if (index < pipe->count)
    {
        result = pipe->modifiers[index];
        g_object_ref(G_OBJECT(result));
    }

    else
        result = NULL;

    return result;

}



/* ---------------------------------------------------------------------------------- */
/*                       IMPLEMENTATION DES FONCTIONS DE CLASSE                       */
/* ---------------------------------------------------------------------------------- */


/******************************************************************************
*                                                                             *
*  Paramètres  : modifier = modificateur à consulter.                         *
*                                                                             *
*  Description : Fournit le nom d'appel d'un modificateur pour motif.         *
*                                                                             *
*  Retour      : Désignation humaine.                                         *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static char *g_scan_modifier_pipe_get_name(const GScanModifierPipe *modifier)
{
    char *result;                           /* Désignation à retourner     */

    result = strdup("(pipe)");

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : modifier = modificateur à solliciter.                        *
*                src      = séquences d'octets à traiter.                     *
*                scount   = quantité de ces séquences.                        *
*                dest     = nouvelle(s) séquence(s) d'octets obtenue(s) [OUT] *
*                dcount   = quantité de ces séquences.                        *
*                                                                             *
*  Description : Transforme une séquence d'octets pour motif de recherche.    *
*                                                                             *
*  Retour      : Bilan de l'opération : succès ou échec.                      *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static bool g_scan_modifier_pipe_transform(const GScanModifierPipe *modifier, const sized_binary_t *src, size_t scount, sized_binary_t **dest, size_t *dcount)
{
    bool result;                            /* Bilan d'opération à renvoyer*/
    size_t i;                               /* Boucle de parcours #1       */
    sized_binary_t *tmp_in;                 /* Motifs supplémentaires      */
    size_t tmp_in_count;                    /* Quantité de ces motifs      */
    sized_binary_t *tmp_out;                /* Motifs supplémentaires      */
    size_t tmp_out_count;                   /* Quantité de ces motifs      */
    size_t k;                               /* Boucle de parcours #2       */

    for (i = 0; i < modifier->count; i++)
    {
        if (i == 0)
            result = g_scan_token_modifier_transform(modifier->modifiers[i],
                                                     src, scount, &tmp_out, &tmp_out_count);

        else
        {
            tmp_in = tmp_out;
            tmp_in_count = tmp_out_count;

            result = g_scan_token_modifier_transform(modifier->modifiers[i],
                                                     tmp_in, tmp_in_count, &tmp_out, &tmp_out_count);

            for (k = 0; k < tmp_in_count; k++)
                exit_szstr(&tmp_in[k]);

            if (tmp_in != NULL)
                free(tmp_in);

        }

        if (!result)
            break;

    }

    if (!result)
    {
        for (k = 0; k < tmp_out_count; k++)
            exit_szstr(&tmp_out[k]);

        if (tmp_out != NULL)
            free(tmp_out);

        *dest = NULL;
        *dcount = 0;

    }
    else
    {
        *dcount += tmp_out_count;
        *dest = tmp_out;
    }

    return result;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : modifier = modificateur à consulter.                         *
*                index    = indice de la combinaison ciblée. [OUT]            *
*                                                                             *
*  Description : Retrouve l'origine d'une correspondance à partir d'un indice.*
*                                                                             *
*  Retour      : Version humainement lisible de la combinaison.               *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

static char *g_scan_modifier_pipe_get_path(const GScanModifierPipe *modifier, size_t *index)
{
    char *result;                           /* Combinaison à retourner     */
    size_t i;                               /* Boucle de parcours #1       */

    result = NULL;

    for (i = 0; i < modifier->count && result == NULL; i++)
        result = g_scan_token_modifier_get_path(modifier->modifiers[i], index);

    return result;

}