/* OpenIDA - Outil d'analyse de fichiers binaires
 * dot.c - interactions avec le système dot
 *
 * Copyright (C) 2009 Cyrille Bagard
 *
 *  This file is part of OpenIDA.
 *
 *  OpenIDA 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.
 *
 *  OpenIDA 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 "dot.h"


#include <malloc.h>
#include <graphviz/gvc.h>
#include <graphviz/types.h>



/* Graphique selon Graphviz */
struct _graph_layout
{
    GVC_t *context;                         /* Contexte pour Graphviz      */
    graph_t *graph;                         /* Graphique construit         */

};



/******************************************************************************
*                                                                             *
*  Paramètres  : cmds = description textuelle du graphique à représenter.     *
*                                                                             *
*  Description : Charge un graphique à partir de sa description.              *
*                                                                             *
*  Retour      : Bilan de l'opération.                                        *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

graph_layout *create_graph_layout(char *cmds)
{
    graph_layout *result;                   /* Composants à retourner      */
    int ret;                                /* Bilan d'un appel            */

    result = (graph_layout *)calloc(1, sizeof(graph_layout));

    result->context = gvContext();
    result->graph = agmemread(cmds);

    if (result->graph == NULL) goto cdl_error;



    ret = gvLayout(result->context, result->graph, "dot");


    printf("ret = %d\n", ret);

    /*
    ret = gvLayoutJobs(result->context, result->graph);
    printf("ret = %d\n", ret);
    ret = gvRenderJobs(result->context, result->graph);
    printf("ret = %d\n", ret);
    */


    ret = gvRender(result->context, result->graph, "dot", NULL);



    ret = gvRender(result->context, result->graph, "plain", NULL);

    printf("ret = %d\n", ret);





    return result;

 cdl_error:

    delete_graph_layout(result);

    return NULL;

}


/******************************************************************************
*                                                                             *
*  Paramètres  : layout = graphique à supprimer de la mémoire.                *
*                                                                             *
*  Description : Décharge un graphique.                                       *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void delete_graph_layout(graph_layout *layout)
{
    if (layout->graph != NULL)
    {
        gvFreeLayout(layout->context, layout->graph);
        agclose(layout->graph);
    }

    gvFreeContext(layout->context);

    free(layout);

}


/******************************************************************************
*                                                                             *
*  Paramètres  : layout = graphique à supprimer de la mémoire.                *
*                view   = support de destination.                             *
*                nodes  = liste de noeuds à traiter.                          *
*                count  = taille de la liste.                                 *
*                                                                             *
*  Description : Place tous les éléments du graphique à l'écran.              *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

void place_nodes_of_graph_layout(const graph_layout *layout, GtkGraphView *view, GGraphNode **nodes, size_t count)
{
    int height;                             /* Hauteur du graphique        */
    node_t *iter;                           /* Boucle de parcours          */
    GGraphNode *node;                       /* Intermédiaire concerné      */

    height = GD_bb(layout->graph).UR.y;

    for (iter = agfstnode(layout->graph); iter != NULL; iter = agnxtnode(layout->graph, iter))
    {

        printf(" pos :: (%d ; %d)\n", iter->u.coord.x, height - iter->u.coord.y);

        node = find_graph_node_by_name(nodes, count, iter->name);
        g_graph_node_place(node, view, iter->u.coord.x, height - iter->u.coord.y);
    }

}


/******************************************************************************
*                                                                             *
*  Paramètres  : layout = graphique à supprimer de la mémoire.                *
*                count  = nombre d'éléments mis en place.                     *
*                                                                             *
*  Description : Charge la définition de tous les liens graphiques.           *
*                                                                             *
*  Retour      : -                                                            *
*                                                                             *
*  Remarques   : -                                                            *
*                                                                             *
******************************************************************************/

GtkLinkRenderer **create_links_from_graph_layout(const graph_layout *layout, size_t *count)
{
    GtkLinkRenderer **result;               /* Liste à retourner           */
    int height;                             /* Hauteur du graphique        */
    node_t *niter;                          /* Boucle de parcours #1       */
    edge_t *eiter;                          /* Boucle de parcours #2       */
    splines *lines;                         /* Lignes déjà tracées         */
    int i;                                  /* Boucle de parcours #3       */
    int k;                                  /* Boucle de parcours #4       */
    GdkPoint *points;                       /* Points de ligne relus       */
    size_t points_count;                    /* Nombre de ces points        */

    result = NULL;
    *count = 0;

    height = GD_bb(layout->graph).UR.y;

    for (niter = agfstnode(layout->graph); niter != NULL; niter = agnxtnode(layout->graph, niter))
        for (eiter = agfstout(layout->graph, niter); eiter != NULL; eiter = agnxtout(layout->graph, eiter))
        {
            lines = ED_spl(eiter);

            //printf("edge == %p\n", eiter);

            points = NULL;
            points_count = 0;

            for (i = 0; i < lines->size; i++)
            {
                points = (GdkPoint *)realloc(points, (points_count + lines->list[i].size) * sizeof(GdkPoint));

                for (k = 0; k < lines->list[i].size; k++)
                {
                    points[points_count + k].x = lines->list[i].list[k].x;
                    points[points_count + k].y = height - lines->list[i].list[k].y;

                    /*
                    printf("  ... ( %d ; %d)\n",
                           lines->list[i].list[k].x, height - lines->list[i].list[k].y);
                    */

                }

                points_count += lines->list[i].size;

                //printf("  ...\n");

            }

            result = (GtkLinkRenderer **)realloc(result, ++(*count) * sizeof(GtkLinkRenderer *));
            result[*count - 1] = gtk_link_renderer_new(points, points_count);

        }

    return result;

}